/*
THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
https://www.infragistics.com/legal/license/igultimate-la
https://www.infragistics.com/legal/license/igultimate-eula
GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
*/
import { AxisLabelPanelBase } from "./AxisLabelPanelBase";
import { Boolean_$type, typeCast, markType, Point_$type, typeGetValue, fromEnum, runOn, Number_$type, markDep } from "igniteui-angular-core";
import { AxisLabelPanelBaseView } from "./AxisLabelPanelBaseView";
import { Rect } from "igniteui-angular-core";
import { Extensions } from "igniteui-angular-core";
import { Axis } from "./Axis";
import { List$1 } from "igniteui-angular-core";
import { LabelPosition } from "./LabelPosition";
import { XamDataChart } from "./XamDataChart";
import { CategoryAxisBase } from "./CategoryAxisBase";
import { IAngleScaler_$type } from "./IAngleScaler";
import { CategoryAxisRenderer } from "./CategoryAxisRenderer";
import { DependencyProperty } from "igniteui-angular-core";
import { PolarAxisRenderingManager } from "./PolarAxisRenderingManager";
import { AxisLabelManager } from "./AxisLabelManager";
import { ViewportUtils } from "./ViewportUtils";
import { RadialAxisRenderingParameters } from "./RadialAxisRenderingParameters";
import { CategoryTickmarkValues } from "./CategoryTickmarkValues";
import { MathUtil } from "igniteui-angular-core";
import { SeriesViewer } from "./SeriesViewer";
import { ScalerParams } from "./ScalerParams";
import { AxisRangeChangedEventArgs } from "./AxisRangeChangedEventArgs";
import { LineGeometry } from "igniteui-angular-core";
import { PropertyMetadata } from "igniteui-angular-core";
import { RangeInfo } from "./RangeInfo";
import { isNaN_, isInfinity } from "igniteui-angular-core";
import { NumericAxisBase } from "./NumericAxisBase";
import { LogarithmicTickmarkValues } from "./LogarithmicTickmarkValues";
import { PolarAxisRenderingParameters } from "./PolarAxisRenderingParameters";
import { RadialAxisLabelPanel } from "./RadialAxisLabelPanel";
import { LinearTickmarkValues } from "./LinearTickmarkValues";
import { IPolarRadialRenderingParameters_$type } from "./IPolarRadialRenderingParameters";
import { PathGeometry } from "igniteui-angular-core";
import { PathFigure } from "igniteui-angular-core";
import { ArcSegment } from "igniteui-angular-core";
import { Size } from "igniteui-angular-core";
import { CategoryAxisBaseView } from "./CategoryAxisBaseView";
import { NumericAxisBaseView } from "./NumericAxisBaseView";
/**
 * @hidden
 */
export class AngleAxisLabelPanel extends AxisLabelPanelBase {
    constructor() {
        super();
        this.ct = false;
        this.cz = null;
        this.cx = 0;
        this.cu = 0;
        this.cw = 0;
        this.cv = 0;
    }
    ad() {
        return new AngleAxisLabelPanelView(this);
    }
    b8(a) {
        super.b8(a);
        this.cs = a;
    }
    ao(a, b) {
        if (!Extensions.b(b)) {
            return false;
        }
        if (this.ac == null || this.ac.i1.isEmpty) {
            return super.ao(a, b);
        }
        return true;
    }
    ay() {
        let a = new List$1(Rect.$, 0);
        let b = new List$1(Boolean_$type, 0);
        if (this.a3.count != this.a2.count) {
            return a;
        }
        this.cs.ay(a, b);
        let c = false;
        this.am = this.al(a, b);
        if (!this.ac.bz()) {
            c = true;
            this.a9 = this.cx / 2;
            this.a9 = this.a9 + this.cy();
        }
        else {
            c = true;
            this.cs.ac();
        }
        if (c) {
            for (let d = 0; d < a.count; d++) {
                let e = this.a3._inner[d];
                let f = this.a2._inner[d];
                let g = a._inner[d];
                let h = this.cz(f.c);
                let i = h.x - this.bc(e) / 2;
                let j = h.y - this.bb(e) / 2;
                g.x = i;
                g.y = j;
                a._inner[d] = g;
            }
        }
        return a;
    }
    cy() {
        let a;
        let b;
        b = this.ac;
        a = null;
        if (b != null) {
            a = typeCast(XamDataChart.$, b.bf);
        }
        if (a == null || b == null) {
            return 0;
        }
        let c = new List$1(Axis.$, 0);
        for (let d = 0; d < a.axes.count; d++) {
            let e = a.axes._inner[d];
            if ((typeCast(NumericAngleAxis.$, e) !== null || typeCast(CategoryAngleAxis.$, e) !== null) && typeCast(AngleAxisLabelPanel.$, e.at) !== null && e.at.a3.count > 0 && (!e.bz()) && !e.by() && (e.ag == null || this.ac.ag == null || e.ag.lj == b.ag.lj)) {
                c.add(e);
            }
        }
        let f = c.indexOf(b);
        if (f == -1) {
            return 0;
        }
        let g = 0;
        let h = 5;
        if (f == 0) {
            g += h;
        }
        else {
            g += c._inner[f - 1].at.a9;
            g += c._inner[f].at.a9 * 2 + h;
        }
        return g;
    }
    ah() {
        return 4;
    }
    as(a) {
        return a == 4 || a == 5;
    }
}
AngleAxisLabelPanel.$t = markType(AngleAxisLabelPanel, 'AngleAxisLabelPanel', AxisLabelPanelBase.$);
/**
 * @hidden
 */
export class CategoryAngleAxis extends CategoryAxisBase {
    constructor() {
        super();
        this.k2 = null;
        this.kz = null;
        this.k3 = false;
        this.k7 = NaN;
        this.k0 = null;
        this.k8 = 0;
        this.k5 = 0;
        this.k6 = 0;
        this.lj = 1;
        this.ab = CategoryAngleAxis.$;
        this.kz = this.ky();
        this.k2 = new PolarAxisRenderingManager();
    }
    a1() {
        return new CategoryAngleAxisView(this);
    }
    gs(a) {
        super.gs(a);
        this.kx = a;
    }
    get_b0() {
        return true;
    }
    as() {
        let a = new AngleAxisLabelPanel();
        a.cz = (b) => {
            let c = this.bf != null ? this.bf.mq : Rect.empty;
            let d = !c.isEmpty ? this.i1 : Rect.empty;
            return this.lw(b, { $type: Point_$type, x: 0.5, y: 0.5 }, c, d, this.at.a9);
        };
        return a;
    }
    lh(a) {
        return Math.round(a * Math.pow(10, 10)) / Math.pow(10, 10);
    }
    ky() {
        let a = ((() => {
            let $ret = new AxisLabelManager();
            $ret.a = this;
            $ret.f = this.cw;
            $ret.e = this.cv;
            $ret.b = this.at;
            return $ret;
        })());
        if (this.aw != null) {
            this.aw.registerAxis(this);
        }
        let b = new CategoryAxisRenderer(a);
        b.u = () => {
            let c = this.a2.ay();
            let d = this.a2.a1();
            let e = this.a2.az();
            let f = this.a2.a0();
            this.he();
            this.gi(c);
            this.gi(d);
            this.gi(e);
            this.gi(f);
        };
        b.o = (c, d) => !d.isEmpty && !c.isEmpty && this.k1 != null;
        b.d = (c, d, e, f) => this.kw(c, d, e, f);
        b.v = () => {
            if (!this.k3) {
                this.k3 = true;
                this.k1.cl();
                this.k3 = false;
            }
        };
        b.g = (c) => {
            let d = typeGetValue(c);
            if (d > this.jf.count - 1) {
                d -= this.jf.count;
            }
            let e = this.jf.item(d);
            return this.e6(e);
        };
        b.b.c = (c) => {
            if ((this.aw == null || this.aw.visibility == 0) && this.k1 != null && this.k7 != c) {
                let d = typeCast(XamDataChart.$, this.bf);
                if (d == null) {
                    return;
                }
                this.k7 = c;
                this.at.a8 = c;
                d.ht();
                for (let e of fromEnum(d.axes)) {
                    if (e != this && typeCast(AngleAxisLabelPanel.$, e.at) !== null) {
                        e.a2.ad();
                    }
                }
            }
        };
        b.k = (c, d, e) => {
            let f = typeCast(RadialAxisRenderingParameters.$, c);
            this.k2.m(d, e, c.z, c.aa, f.minLength, f.maxLength, f.center);
        };
        b.l = (c, d, e, f) => {
            let g = typeCast(RadialAxisRenderingParameters.$, c);
            this.k2.n(d, e, f, g.z, c.aa, g.minLength, g.maxLength, g.center);
        };
        b.m = (c, d) => this.getScaledAngle(d);
        b.q = (c, d) => {
            if (this.lh(d - this.k8) < 0) {
                return false;
            }
            if (this.lh(d - this.k8 - (2 * Math.PI)) > 0) {
                return false;
            }
            return true;
        };
        b.j = (c) => {
            let d = typeCast(RadialAxisRenderingParameters.$, c);
            if (d.e == d.k._inner[0]) {
                this.k2.i(c.t, c.n, c.z, c.aa, d.center, d.minAngle, d.maxAngle);
            }
        };
        b.e = (c) => {
            c.n = this.lb();
            c.r = c.n;
        };
        b.p = (c, d, e) => {
            let f = typeCast(RadialAxisRenderingParameters.$, c);
            if (e) {
                return false;
            }
            let g = this.lw(d, f.center, c.aa, c.z, 0);
            if (g.x < c.z.right && g.x >= c.z.left && g.y < c.z.bottom && g.y >= c.z.top) {
                return true;
            }
            return false;
        };
        b.a = (c, d, e, f) => {
            let g = c.y;
            let h = new ScalerParams(0, c.aa, c.z, this.b8, g);
            let i = d;
            if (this.categoryMode != 0) {
                let j = (e * f) + 1;
                j = Math.min(j, this.jy);
                let k = this.dw(j, h);
                i = (d + k) / 2;
            }
            return i;
        };
        b.f = runOn(this, this.getGroupCenter);
        b.i = runOn(this, this.le);
        return b;
    }
    lw(a, b, c, d, e) {
        let f = this.lb();
        let g = ViewportUtils.b(e, c, d);
        if (this.aw != null && (this.aw.c == 5 || this.aw.c == 1)) {
            g *= -1;
        }
        let h = b.x + (f + g) * Math.cos(a);
        let i = b.y + (f + g) * Math.sin(a);
        h = ViewportUtils.c(h, c, d);
        i = ViewportUtils.f(i, c, d);
        return { $type: Point_$type, x: h, y: i };
    }
    lb() {
        if (this.k1 == null) {
            return 0;
        }
        if (!this.by()) {
            return this.k1.lo();
        }
        else {
            return this.k1.lp((this.e2));
        }
    }
    kw(a, b, c, d) {
        if (this.jf == null) {
            return null;
        }
        let e = new RadialAxisRenderingParameters();
        let f = this.jf.count - 1;
        let g = this.a2.ay();
        let h = this.a2.a1();
        let i = this.a2.az();
        let j = this.a2.a0();
        e.t = g;
        e.w = h;
        e.u = i;
        e.v = j;
        e.l = f;
        e.m = 0;
        e.h = false;
        e.z = a;
        e.y = c;
        e.x = d;
        e.aa = b;
        e.g = this.k4();
        e.p = this.lf;
        e.o = this.d9();
        e.q = this.lg;
        e.s = this.e7;
        let k = this.k2.f(b);
        let l = this.k2.g(b);
        let m = 0.5 * this.k1.lj;
        let n = 0.5 * this.k1.li;
        let o = k;
        let p = l;
        let q = this.k1.lo();
        if (isNaN_(q) || isInfinity(q)) {
            return null;
        }
        if (p >= m) {
            p = q;
        }
        if (o < n) {
            o = n;
        }
        let r = a.width;
        this.k2.k(b, e, 0, this.jf.count, this.b8, runOn(this, this.getUnscaledAngle), r);
        let s = { $type: Point_$type, x: 0.5, y: 0.5 };
        e.center = s;
        e.maxLength = p;
        e.minLength = o;
        e.effectiveMaximum = q;
        e.ae = this.jf.count;
        e.ab = this.categoryMode;
        e.ad = true;
        e.ac = this.b8;
        e.af = this.j1;
        e.f = new CategoryTickmarkValues();
        e.j = this.cj;
        return e;
    }
    getMinMaxAngle(a, b, c) {
        let d = this.k2.l(a, b, c);
        b = d.p1;
        c = d.p2;
        return {
            p1: b,
            p2: c
        };
    }
    ac() {
        super.ac();
        this.g6(false);
    }
    get k1() {
        if (this.k0 != null) {
            return this.k0;
        }
        let a = typeCast(XamDataChart.$, this.bf);
        if (a != null) {
            for (let b = 0; b < a.axes.count; b++) {
                if (typeCast(NumericRadiusAxis.$, a.axes._inner[b]) !== null) {
                    return a.axes._inner[b];
                }
            }
        }
        return this.k0;
    }
    set k1(a) {
        this.k0 = a;
    }
    ah() {
        return this.k1;
    }
    getCategorySize(a, b, c) {
        return 2 * Math.PI / this.jy;
    }
    jr(a, b, c) {
        let d = !isNaN_(this.jo) ? MathUtil.b(this.jo, 0, 1) : 0;
        let e = 0;
        if (!isNaN_(this.jv)) {
            e = Math.min(this.jv, 1);
        }
        let f = 1 - 0.5 * d;
        return this.getCategorySize(a, b, c) * f / (this.j1 - (this.j1 - 1) * e);
    }
    getGroupCenter(a, b, c, d) {
        let e = 0.5;
        if (this.j1 > 1) {
            let f = !isNaN_(this.jo) ? MathUtil.b(this.jo, 0, 1) : 0;
            let g = 0;
            if (!isNaN_(this.jv)) {
                g = Math.min(this.jv, 1);
            }
            let h = 1 - 0.5 * f;
            let i = h / (this.j1 - (this.j1 - 1) * g);
            let j = (h - i) / (this.j1 - 1);
            e = 0.25 * f + 0.5 * i + a * j;
        }
        return this.getCategorySize(b, c, d) * e;
    }
    le(a) {
        let b = 0.5;
        if (this.j1 > 1) {
            let c = !isNaN_(this.jo) ? MathUtil.b(this.jo, 0, 1) : 0;
            let d = 0;
            if (!isNaN_(this.jv)) {
                d = Math.min(this.jv, 1);
            }
            let e = 1 - 0.5 * c;
            let f = e / (this.j1 - (this.j1 - 1) * d);
            let g = (e - f) / (this.j1 - 1);
            b = 0.25 * c + 0.5 * f + a * g;
        }
        return b;
    }
    g7(a) {
        super.g7(a);
        let b = this.bf != null ? this.bf.mq : Rect.empty;
        let c = !b.isEmpty ? this.i1 : Rect.empty;
        let d = this.iw();
        let e = this.iv();
        let f = this.kz.c(a, c, b, d, e);
        if (f != null) {
            this.k9 = f.f.m;
            this.la = f.f.l;
        }
    }
    ld(a, b) {
        let c;
        let d;
        let e = this.k2.l(b, c, d);
        c = e.p1;
        d = e.p2;
        if (c == 0) {
            if (this.b8) {
                return this.jy;
            }
            else {
                return 0;
            }
        }
        let f = this.getUnscaledAngle(c);
        if (f < 0 || f > this.jy) {
            f = this.getUnscaledAngle(c + Math.PI * 2);
        }
        return f;
    }
    lc(a, b) {
        let c;
        let d;
        let e = this.k2.l(b, c, d);
        c = e.p1;
        d = e.p2;
        if (d > Math.PI * 2) {
            d = d - Math.PI * 2;
        }
        if (d == Math.PI * 2) {
            if (this.b8) {
                return 0;
            }
            else {
                return this.jy;
            }
        }
        let f = this.getUnscaledAngle(d);
        if (f < 0 || f > this.jy) {
            f = this.getUnscaledAngle(d + Math.PI * 2);
        }
        return f;
    }
    getScaledAngle(a) {
        let b = this.jy;
        let c = b >= 2 ? (a) / (b) : b == 1 ? 0.5 : NaN;
        if (this.b9) {
            c = 1 - c;
        }
        return (c * 2 * Math.PI) + this.k8;
    }
    getUnscaledAngle(a) {
        if (a < this.k8) {
            a += 2 * Math.PI;
        }
        let b = (a - this.k8) / (2 * Math.PI);
        if (this.b8) {
            b = 1 - b;
        }
        return b * (this.jy);
    }
    dw(a, b) {
        return this.getScaledAngle(a);
    }
    dz(a, b) {
        return this.getUnscaledAngle(a);
    }
    gu(a, b, c, d) {
        super.gu(a, b, c, d);
        let e = typeCast(XamDataChart.$, this.bf);
        switch (b) {
            case "CrossingAxis":
                let f = typeCast(NumericRadiusAxis.$, d);
                this.ls(f);
                if (f != null) {
                    f.ly(this);
                }
                this.cg = true;
                this.g6(false);
                break;
            case CategoryAngleAxis.$$p[0]:
                this.k8 = this.li;
                while (this.k8 < 0) {
                    this.k8 += 360;
                }
                while (this.k8 >= 360) {
                    this.k8 -= 360;
                }
                this.k8 = (this.k8 * Math.PI) / 180;
                this.cg = true;
                this.g6(false);
                for (let g of fromEnum(this.cx)) {
                    g.jd(false);
                    g.ik();
                }
                break;
            case "Label":
                if (e != null) {
                    for (let h of fromEnum(e.axes)) {
                        h.cg = true;
                        h.g5();
                    }
                }
                break;
            case "CrossingValue":
                if (e != null) {
                    for (let i of fromEnum(e.axes)) {
                        if (typeCast(NumericAngleAxis.$, i) !== null || typeCast(CategoryAngleAxis.$, i) !== null) {
                            i.cg = true;
                            i.g5();
                        }
                    }
                }
                break;
            case "LabelSettings":
                this.kz = this.ky();
                this.lq();
                this.cg = true;
                this.g6(false);
                break;
        }
    }
    lq() {
        this.k7 = NaN;
    }
    ls(a) {
        this.k1 = a;
    }
    get lf() {
        return this.c(CategoryAngleAxis.lt);
    }
    set lf(a) {
        this.h(CategoryAngleAxis.lt, a);
    }
    get k9() {
        return this.k5;
    }
    set k9(a) {
        if (this.k9 != a) {
            let b = this.k5;
            this.k5 = a;
            this.g0("ActualInterval", b, this.k9);
        }
    }
    d7() {
        return this.k9;
    }
    get lg() {
        return this.c(CategoryAngleAxis.lu);
    }
    set lg(a) {
        this.h(CategoryAngleAxis.lu, a);
    }
    get la() {
        return this.k6;
    }
    set la(a) {
        if (this.la != a) {
            let b = this.k6;
            this.k6 = a;
            this.g0("ActualMinorInterval", b, this.la);
        }
    }
    k4() {
        return false;
    }
    get_az() {
        return 2;
    }
    get az() {
        return this.get_az();
    }
    cn() {
        if (this.cg && this.co) {
            this.a9 = this.a8();
        }
        if (this.jf == null) {
            return false;
        }
        let a = this.jf.count;
        if (a != this.lk) {
            let b = new AxisRangeChangedEventArgs(0, 1, 1, this.lk, a);
            this.lk = a;
            this.g1(b);
            return true;
        }
        return false;
    }
    get lk() {
        return this.lj;
    }
    set lk(a) {
        this.lj = a;
    }
    it(a, b, c, d = null, e = null) {
        let f = typeCast(RadialAxisRenderingParameters.$, this.kz.d(c, b, d, e));
        if (f == null) {
            return null;
        }
        let g = Math.cos(a);
        let h = Math.sin(a);
        let i = f.center.x + g * f.minLength;
        let j = f.center.y + h * f.minLength;
        let k = f.center.x + g * f.maxLength;
        let l = f.center.y + h * f.maxLength;
        i = ViewportUtils.c(i, b, c);
        j = ViewportUtils.f(j, b, c);
        k = ViewportUtils.c(k, b, c);
        l = ViewportUtils.f(l, b, c);
        let m = new LineGeometry();
        m.d = { $type: Point_$type, x: i, y: j };
        m.c = { $type: Point_$type, x: k, y: l };
        return m;
    }
    get isVertical() {
        return this.cf;
    }
    j$c(a, b) {
        return this.dz.apply(this, arguments);
    }
    j$b(a, b) {
        return this.dw.apply(this, arguments);
    }
    j$d(a, b, c, d, e) {
        this.gm.apply(this, arguments);
    }
    j$e(a, b, c, d) {
        this.gn.apply(this, arguments);
    }
    j$f(a, b, c, d) {
        this.go.apply(this, arguments);
    }
    get j$a() {
        return this.b8;
    }
}
CategoryAngleAxis.$t = markType(CategoryAngleAxis, 'CategoryAngleAxis', CategoryAxisBase.$, [IAngleScaler_$type]);
CategoryAngleAxis.lt = DependencyProperty.i("Interval", Number_$type, CategoryAngleAxis.$, new PropertyMetadata(2, NaN, (a, b) => {
    a.g0("Interval", b.oldValue, b.newValue);
    a.g6(false);
}));
CategoryAngleAxis.lu = DependencyProperty.i("MinorInterval", Number_$type, CategoryAngleAxis.$, new PropertyMetadata(2, NaN, (a, b) => {
    (typeCast(CategoryAngleAxis.$, a)).g0("MinorInterval", b.oldValue, b.newValue);
    (typeCast(CategoryAngleAxis.$, a)).g6(false);
}));
CategoryAngleAxis.$$p = markDep(DependencyProperty, PropertyMetadata, CategoryAngleAxis, 'g0', ['StartAngleOffset:li:lv', [1, 0]]);
/**
 * @hidden
 */
export class NumericAngleAxis extends NumericAxisBase {
    constructor() {
        super();
        this.lf = null;
        this.lg = false;
        this.lh = NaN;
        this.li = 0;
        this.ld = null;
        this.ab = NumericAngleAxis.$;
        this.lf = new PolarAxisRenderingManager();
        this.jf = this.jd();
    }
    a1() {
        return new NumericAngleAxisView(this);
    }
    gs(a) {
        super.gs(a);
        this.lc = a;
    }
    get_b0() {
        return true;
    }
    as() {
        let a = new AngleAxisLabelPanel();
        a.cz = (b) => {
            let c = this.bf != null ? this.bf.mq : Rect.empty;
            let d = !c.isEmpty ? this.i1 : Rect.empty;
            return this.ls(b, { $type: Point_$type, x: 0.5, y: 0.5 }, c, d, this.at.a9);
        };
        return a;
    }
    lj() {
        if (this.le == null) {
            return 0;
        }
        if (!this.by()) {
            return this.le.lo();
        }
        else {
            return this.le.lp((this.e2));
        }
    }
    ll(a) {
        return Math.round(a * Math.pow(10, 10)) / Math.pow(10, 10);
    }
    jd() {
        let a = super.jd();
        a.b.c = (b) => {
            if ((this.aw == null || this.aw.visibility == 0) && this.le != null && this.lh != b) {
                let c = typeCast(XamDataChart.$, this.bf);
                if (c == null) {
                    return;
                }
                this.lh = b;
                this.at.a8 = b;
                c.ht();
                for (let d of fromEnum(c.axes)) {
                    if (d != this && typeCast(AngleAxisLabelPanel.$, d.at) !== null) {
                        d.a2.ad();
                    }
                }
            }
        };
        a.e = (b) => {
            b.n = this.lj();
            b.r = b.n;
        };
        a.j = (b) => {
            let c = typeCast(PolarAxisRenderingParameters.$, b);
            if (c.e == c.k._inner[0]) {
                this.lf.i(b.t, b.n, b.z, b.aa, c.center, c.minAngle, c.maxAngle);
            }
        };
        a.k = (b, c, d) => {
            let e = typeCast(PolarAxisRenderingParameters.$, b);
            this.lf.m(c, d, b.z, b.aa, e.minLength, e.maxLength, e.center);
        };
        a.l = (b, c, d, e) => {
            let f = typeCast(PolarAxisRenderingParameters.$, b);
            this.lf.n(c, d, e, f.z, b.aa, f.minLength, f.maxLength, f.center);
        };
        a.d = (b, c, d, e) => {
            let f = typeCast(PolarAxisRenderingParameters.$, this.jg(b, c, d, e));
            return f;
        };
        a.v = () => {
            if (!this.lg) {
                this.lg = true;
                this.le.cl();
                this.lg = false;
            }
        };
        a.m = (b, c) => this.getScaledAngle(c);
        a.o = (b, c) => !c.isEmpty && !b.isEmpty && this.le != null;
        a.q = (b, c) => {
            if (this.ll(c - this.li) < 0) {
                return false;
            }
            if (this.ll(c - this.li - (2 * Math.PI)) > 0) {
                return false;
            }
            return true;
        };
        a.p = (b, c, d) => {
            let e = typeCast(PolarAxisRenderingParameters.$, b);
            let f = this.ls(this.getScaledAngle(e.l), e.center, b.aa, b.z, 0);
            let g = this.ls(c, e.center, b.aa, b.z, 0);
            if (d && MathUtil.e(f.x - g.x, f.y - g.y) < 2) {
                return false;
            }
            if (g.x < b.z.right && g.x >= b.z.left && g.y < b.z.bottom && g.y >= b.z.top) {
                return true;
            }
            return false;
        };
        a.r = (b, c, d, e) => {
            if (c < b.m && typeCast(LogarithmicTickmarkValues.$, b.f) !== null) {
                return b.m;
            }
            else if (c > b.l && (typeCast(LogarithmicTickmarkValues.$, b.f) !== null || b.h)) {
                return b.l;
            }
            return c;
        };
        return a;
    }
    ls(a, b, c, d, e) {
        let f = this.lj();
        let g = ViewportUtils.b(e, c, d);
        if (this.aw != null && (this.aw.c == 5 || this.aw.c == 1)) {
            g *= -1;
        }
        let h = b.x + (f + g) * Math.cos(a);
        let i = b.y + (f + g) * Math.sin(a);
        h = ViewportUtils.c(h, c, d);
        i = ViewportUtils.f(i, c, d);
        return { $type: Point_$type, x: h, y: i };
    }
    dw(a, b) {
        return this.getScaledAngle(a);
    }
    getScaledAngle1(a, b, c) {
        let d = 0;
        if (b) {
            d = (Math.log(a) - this.ka) / (this.j9 - this.ka);
        }
        else {
            d = (a - this.j4) / (this.j3 - this.j4);
        }
        if (c) {
            d = 1 - d;
        }
        return (d * 2 * Math.PI) + this.li;
    }
    getScaledAngle(a) {
        return this.getScaledAngle1(a, this.ju, this.b9);
    }
    dz(a, b) {
        return this.getUnscaledAngle(a);
    }
    getUnscaledAngle(a) {
        let b = (a - this.li) / (2 * Math.PI);
        if (this.b8) {
            b = 1 - b;
        }
        if (this.ju) {
            return Math.exp(b * (this.j9 - this.ka) + this.ka);
        }
        else {
            return this.j4 + b * (this.j3 - this.j4);
        }
    }
    gu(a, b, c, d) {
        super.gu(a, b, c, d);
        let e = typeCast(XamDataChart.$, this.bf);
        switch (b) {
            case "CrossingAxis":
                let f = typeCast(NumericRadiusAxis.$, d);
                this.lq(f);
                if (f != null) {
                    f.ly(this);
                }
                this.g6(false);
                break;
            case NumericAngleAxis.$$p[0]:
                this.li = this.lm;
                while (this.li < 0) {
                    this.li += 360;
                }
                while (this.li >= 360) {
                    this.li -= 360;
                }
                this.li = (this.lm * Math.PI) / 180;
                this.g6(false);
                for (let g of fromEnum(this.cu())) {
                    g.jd(false);
                    g.ik();
                }
                break;
            case "Label":
                if (e != null) {
                    for (let h of fromEnum(e.axes)) {
                        h.g5();
                    }
                }
                break;
            case "CrossingValue":
                if (e != null) {
                    for (let i of fromEnum(e.axes)) {
                        if (typeCast(NumericAngleAxis.$, i) !== null || typeCast(CategoryAngleAxis.$, i) !== null) {
                            i.g5();
                        }
                    }
                }
                break;
            case "LabelSettings":
                this.jf = this.jd();
                this.lo();
                this.cg = true;
                this.g6(false);
                break;
        }
    }
    lo() {
        this.lh = NaN;
    }
    jh() {
        return new PolarAxisRenderingParameters();
    }
    jg(a, b, c, d) {
        let e = typeCast(PolarAxisRenderingParameters.$, super.jg(a, b, c, d));
        let f = this.lf.f(b);
        let g = this.lf.g(b);
        let h = 0.5 * this.le.lj;
        let i = 0.5 * this.le.li;
        let j = f;
        let k = g;
        let l = this.le.lo();
        if (isNaN_(l) || isInfinity(l)) {
            return null;
        }
        if (k >= h) {
            k = l;
        }
        if (j < i) {
            j = i;
        }
        let m = a.width;
        this.lf.k(b, e, this.j4, this.j3, this.b8, runOn(this, this.getUnscaledAngle), m);
        let n = { $type: Point_$type, x: 0.5, y: 0.5 };
        e.center = n;
        e.maxLength = k;
        e.minLength = j;
        e.effectiveMaximum = l;
        return e;
    }
    getMinMaxAngle(a, b, c) {
        let d = this.lf.l(a, b, c);
        b = d.p1;
        c = d.p2;
        return {
            p1: b,
            p2: c
        };
    }
    g7(a) {
        super.g7(a);
        let b = this.bf != null ? this.bf.mq : Rect.empty;
        let c = !b.isEmpty ? this.i1 : Rect.empty;
        let d = this.iw();
        let e = this.iv();
        let f = this.jf.c(a, c, b, d, e);
        if (f != null) {
            this.j2 = f.f.m;
            this.j5 = f.f.l;
        }
    }
    get le() {
        if (this.ld != null) {
            return this.ld;
        }
        let a = typeCast(XamDataChart.$, this.bf);
        if (a != null) {
            for (let b = 0; b < a.axes.count; b++) {
                if (a.axes._inner[b].cc) {
                    return a.axes._inner[b];
                }
            }
        }
        return this.ld;
    }
    set le(a) {
        this.ld = a;
    }
    ah() {
        return this.le;
    }
    lq(a) {
        this.le = a;
    }
    hh(a, b) {
        super.hh(a, b);
        if (b.height != a.height || b.width != a.width) {
            this.cl();
        }
    }
    get_az() {
        return 2;
    }
    get az() {
        return this.get_az();
    }
    it(a, b, c, d = null, e = null) {
        if (this.le == null) {
            return null;
        }
        let f = typeCast(PolarAxisRenderingParameters.$, this.jg(c, b, d, e));
        if (f == null) {
            return null;
        }
        let g = Math.cos(a);
        let h = Math.sin(a);
        let i = f.center.x + g * f.minLength;
        let j = f.center.y + h * f.minLength;
        let k = f.center.x + g * f.maxLength;
        let l = f.center.y + h * f.maxLength;
        i = ViewportUtils.c(i, b, c);
        j = ViewportUtils.f(j, b, c);
        k = ViewportUtils.c(k, b, c);
        l = ViewportUtils.f(l, b, c);
        let m = new LineGeometry();
        m.d = { $type: Point_$type, x: i, y: j };
        m.c = { $type: Point_$type, x: k, y: l };
        return m;
    }
}
NumericAngleAxis.$t = markType(NumericAngleAxis, 'NumericAngleAxis', NumericAxisBase.$, [IAngleScaler_$type]);
NumericAngleAxis.$$p = markDep(DependencyProperty, PropertyMetadata, NumericAngleAxis, 'g0', ['StartAngleOffset:lm:lr', [1, 0]]);
/**
 * @hidden
 */
export class NumericRadiusAxis extends NumericAxisBase {
    constructor() {
        super();
        this.lf = null;
        this.lg = false;
        this.lh = NaN;
        this.lj = 0;
        this.li = 0;
        this.ll = 0;
        this.lc = null;
        this.ab = NumericRadiusAxis.$;
        this.lj = this.lt;
        this.li = this.ls;
        this.lf = new PolarAxisRenderingManager();
        this.jf = this.jd();
    }
    a1() {
        return new NumericRadiusAxisView(this);
    }
    gs(a) {
        super.gs(a);
        this.le = a;
    }
    get_cc() {
        return true;
    }
    dv() {
        let a = this.lj;
        let b = this.li;
        let c = Math.min(this.ln(), this.lm()) * (a - b) / 2;
        c = Math.max(c, 14);
        return c;
    }
    ln() {
        return this.i1.width;
    }
    lm() {
        return this.i1.height;
    }
    as() {
        return new RadialAxisLabelPanel();
    }
    lk(a) {
        if (a == null) {
            return 0;
        }
        return a;
    }
    jd() {
        let a = super.jd();
        a.b.c = (b) => {
            if ((this.aw == null || this.aw.visibility == 0) && this.ld != null) {
                if ((this.aw == null || (this.aw.c == 4 || this.aw.c == 5)) && this.lh != b) {
                    this.lh = b;
                    this.at.a8 = b;
                    this.bf.ht();
                }
            }
        };
        a.k = (b, c, d) => {
            let e = typeCast(PolarAxisRenderingParameters.$, b);
            this.lf.i(c, d, e.z, e.aa, e.center, e.minAngle, e.maxAngle);
        };
        a.l = (b, c, d, e) => {
            if (d == e) {
                return;
            }
            let f = typeCast(PolarAxisRenderingParameters.$, b);
            this.lf.j(c, d, e, f.z, f.aa, f.center, f.minAngle, f.maxAngle);
        };
        a.m = (b, c) => this.lp(c);
        a.q = (b, c) => {
            let d = typeCast(PolarAxisRenderingParameters.$, b);
            return c <= d.effectiveMaximum;
        };
        a.n = (b, c) => {
            let d = typeCast(PolarAxisRenderingParameters.$, b);
            return c <= d.effectiveMaximum;
        };
        a.j = (b) => {
            let c = typeCast(PolarAxisRenderingParameters.$, b);
            this.lf.m(b.t, c.crossingAngleRadians, b.z, b.aa, c.minLength, c.maxLength, c.center);
        };
        a.e = (b) => {
            b.n = this.aw == null || (this.aw.c == 4 || this.aw.c == 0) ? b.z.top : b.z.bottom;
            b.r = b.n;
            let c = typeCast(PolarAxisRenderingParameters.$, b);
            c.crossingAngleRadians = (this.lk(this.e2) * Math.PI) / 180;
            if (this.aw == null || (this.aw.c == 4 || this.aw.c == 5)) {
                c.n = ViewportUtils.f(0.5, c.aa, c.z) - b.z.top;
                c.r = c.n;
                let d = typeCast(RadialAxisLabelPanel.$, this.at);
                if (d != null) {
                    let e = 0;
                    if (this.aw != null && this.aw.c == 4) {
                        e = 1;
                    }
                    d.dh = { $type: Point_$type, x: ViewportUtils.c(0.5, c.aa, c.z), y: e };
                    d.de = c.crossingAngleRadians;
                }
            }
        };
        a.p = (b, c, d) => {
            let e = typeCast(PolarAxisRenderingParameters.$, b);
            if (this.ld == null) {
                return false;
            }
            if (c > e.effectiveMaximum) {
                return false;
            }
            let f = false;
            f = this.aw == null || (this.aw.c == 4 || this.aw.c == 5);
            let g = 0;
            if (f) {
                g = this.ll;
            }
            let h = e.center.x + c * Math.cos(g);
            let i = e.center.y + c * Math.sin(g);
            h = ViewportUtils.c(h, e.aa, e.z);
            i = ViewportUtils.f(i, e.aa, e.z);
            if (h <= b.z.right && h >= b.z.left && ((i <= b.z.bottom && i >= b.z.top) || !f)) {
                return true;
            }
            return false;
        };
        a.h = (b, c) => {
            let d = typeCast(PolarAxisRenderingParameters.$, b);
            return new LabelPosition(ViewportUtils.c(d.center.x + c, d.aa, d.z));
        };
        a.r = (b, c, d, e) => {
            if (c < b.m) {
                return b.m;
            }
            else if (c > b.l) {
                return b.l;
            }
            return c;
        };
        return a;
    }
    dw(a, b) {
        return this.lp(a);
    }
    lq(a, b, c, d, e) {
        let f = 0;
        if (b) {
            if (a <= 0) {
                f = (Math.log(this.j4) - this.ka) / (this.j9 - this.ka);
            }
            else {
                f = (Math.log(a) - this.ka) / (this.j9 - this.ka);
            }
        }
        else {
            f = (a - this.j4) / (this.j3 - this.j4);
        }
        if (c) {
            f = 1 - f;
        }
        f = e + (f * (d - e));
        f /= 2;
        return f;
    }
    lp(a) {
        return this.lq(a, this.ju, this.b9, this.lj, this.li);
    }
    lr(a) {
        let b = a * 2;
        b = (b - this.li) / (this.lj - this.li);
        if (this.b8) {
            b = 1 - b;
        }
        if (this.ju) {
            return Math.exp(b * (this.j9 - this.ka) + this.ka);
        }
        else {
            return this.j4 + b * (this.j3 - this.j4);
        }
    }
    dz(a, b) {
        return this.lr(a);
    }
    gu(a, b, c, d) {
        switch (b) {
            case "CrossingValue":
                this.ll = this.lk(this.e2) * Math.PI / 180;
                break;
        }
        super.gu(a, b, c, d);
        switch (b) {
            case NumericRadiusAxis.$$p[1]:
                this.lj = this.lt;
                if (this.lj < 0) {
                    this.lj = 0.1;
                }
                if (this.lj > 1) {
                    this.lj = 1;
                }
                if (this.li >= this.lj) {
                    this.li = this.lj - 0.01;
                    if (this.li < 0) {
                        this.li = 0;
                        this.lj = 0.01;
                    }
                }
                this.cg = true;
                this.g6(false);
                if (this.ld != null) {
                    this.ld.g5();
                }
                for (let e of fromEnum(this.cu())) {
                    e.jd(false);
                }
                break;
            case NumericRadiusAxis.$$p[0]:
                this.li = this.ls;
                if (this.li < 0) {
                    this.li = 0.1;
                }
                if (this.li > 1) {
                    this.li = 1;
                }
                if (this.li >= this.lj) {
                    this.li = this.lj - 0.01;
                    if (this.li < 0) {
                        this.li = 0;
                        this.lj = 0.01;
                    }
                }
                this.cg = true;
                this.g6(false);
                if (this.ld != null) {
                    this.ld.g5();
                }
                for (let f of fromEnum(this.cu())) {
                    f.dl = true;
                    f.jd(false);
                }
                if (this.bf != null) {
                    this.bf.h1();
                }
                break;
            case "CrossingAxis":
                let g = typeCast(NumericAngleAxis.$, d);
                let h = typeCast(CategoryAngleAxis.$, d);
                if (g == null && h == null) {
                    this.ly(null);
                }
                if (g != null) {
                    this.ly(g);
                    g.lq(this);
                }
                if (h != null) {
                    this.ly(h);
                    h.ls(this);
                }
                this.cg = true;
                this.g6(false);
                break;
            case "IsInverted":
                if (this.ld != null) {
                    this.ld.cg = true;
                    this.ld.g6(false);
                }
                break;
        }
    }
    ly(a) {
        this.ld = a;
    }
    get ld() {
        if (this.lc != null) {
            return this.lc;
        }
        let a = typeCast(XamDataChart.$, this.bf);
        if (a != null) {
            for (let b = 0; b < a.axes.count; b++) {
                if (typeCast(NumericAngleAxis.$, a.axes._inner[b]) !== null || typeCast(CategoryAngleAxis.$, a.axes._inner[b]) !== null) {
                    return a.axes._inner[b];
                }
            }
        }
        return this.lc;
    }
    set ld(a) {
        this.lc = a;
    }
    ah() {
        return this.ld;
    }
    jh() {
        return new PolarAxisRenderingParameters();
    }
    jg(a, b, c, d) {
        let e = typeCast(PolarAxisRenderingParameters.$, super.jg(a, b, c, d));
        let f = this.lf.f(b);
        let g = this.lf.g(b);
        let h = 0.5 * this.lj;
        let i = 0.5 * this.li;
        let j, k;
        if (Rect.l_op_Equality(b, SeriesViewer.m0)) {
            k = this.j3;
            j = this.j4;
        }
        else {
            k = Math.min(g, h);
            j = this.lr(f);
            k = this.lr(k);
            let l = this.lz(a, b, j, k);
            j = l.p2;
            k = l.p3;
        }
        let m = { $type: Point_$type, x: 0.5, y: 0.5 };
        let n = f;
        let o = g;
        let p = Math.min(a.width, a.height) * (this.lj - this.li) / 2;
        e.center = m;
        let q = Math.max(o, n);
        let r = Math.min(n, o);
        e.maxLength = q;
        e.minLength = r;
        let s = Math.min(j, k);
        let t = Math.max(j, k);
        if (s < this.j4) {
            s = this.j4;
        }
        if (t > this.j3) {
            t = this.j3;
        }
        this.j7 = s;
        this.j6 = t;
        e.k.add(((() => {
            let $ret = new RangeInfo();
            $ret.d = s;
            $ret.c = t;
            $ret.b = p;
            return $ret;
        })()));
        let u = typeCast(IAngleScaler_$type, this.ld);
        if (u != null) {
            let v;
            let w;
            let x = u.getMinMaxAngle(b, v, w);
            v = x.p1;
            w = x.p2;
            e.minAngle = Math.min(v, w);
            e.maxAngle = Math.max(v, w);
        }
        let y = this.lo();
        if (o >= h) {
            o = y;
        }
        if (n < i) {
            n = i;
        }
        e.minLength = n;
        e.maxLength = o;
        e.effectiveMaximum = y;
        e.f = this.jk;
        let z = typeCast(LinearTickmarkValues.$, e.f);
        if (z != null) {
            z.y = this.lu(m, e.minLength, e.maxLength, b, a);
        }
        return e;
    }
    lz(a, b, c, d) {
        let e = { $type: Point_$type, x: 0.5, y: 0.5 };
        let f = 0;
        if (this.b8) {
            f = this.lp(this.j4);
        }
        else {
            f = this.lp(this.j3);
        }
        let g = 0;
        if (this.e2 != null) {
            g = this.ll;
        }
        let h = e.x + f * Math.cos(g);
        let i = e.y + f * Math.sin(g);
        e.x = ViewportUtils.c(e.x, b, a);
        e.y = ViewportUtils.f(e.y, b, a);
        h = ViewportUtils.c(h, b, a);
        i = ViewportUtils.f(i, b, a);
        if (h >= a.left && h <= a.right && i >= a.top && i <= a.bottom) {
            if (this.b8) {
                d = this.j4;
            }
            else {
                d = this.j3;
            }
        }
        if (e.x >= a.left && e.x <= a.right && e.y >= a.top && e.y <= a.bottom) {
            if (this.b8) {
                c = this.j3;
            }
            else {
                c = this.j4;
            }
        }
        return {
            p2: c,
            p3: d
        };
    }
    lu(a, b, c, d, e) {
        let f = ViewportUtils.d(c - b, d, e);
        let g = f / Math.min(e.width, e.height);
        if (g > 0.7) {
            return 10;
        }
        return 5;
    }
    lo() {
        let a = 0;
        if (!this.b8) {
            a = this.lp(this.j3);
        }
        else {
            a = this.lp(this.j4);
        }
        return a;
    }
    k2(a) {
        if (this.ld != null) {
            this.ld.g5();
        }
    }
    g7(a) {
        super.g7(a);
        let b = this.bf != null ? this.bf.mq : Rect.empty;
        let c = !b.isEmpty ? this.i1 : Rect.empty;
        let d = this.iw();
        let e = this.iv();
        let f = this.jf.c(a, c, b, d, e);
        if (f != null) {
            this.j2 = f.f.m;
            this.j5 = f.f.l;
        }
    }
    hh(a, b) {
        super.hh(a, b);
        if (b.height != a.height || b.width != a.width) {
            this.cl();
        }
    }
    lx(a, b, c, d, e) {
        let f = typeCast(IPolarRadialRenderingParameters_$type, this.jg(b, c, d, e));
        if (f == null) {
            return;
        }
        this.lf.j(a.d, f.minLength, f.maxLength, b, c, f.center, f.minAngle, f.maxAngle);
    }
    get_az() {
        return 3;
    }
    get az() {
        return this.get_az();
    }
    it(a, b, c, d = null, e = null) {
        let f = typeCast(PolarAxisRenderingParameters.$, this.jg(c, b, d, e));
        let g = a;
        let h = new PathGeometry();
        let i = ViewportUtils.d(g, b, c);
        let j = ViewportUtils.g(g, b, c);
        if (i <= 0 || j <= 0) {
            return null;
        }
        let k = ViewportUtils.c(f.center.x, b, c);
        let l = ViewportUtils.f(f.center.y, b, c);
        if (f.maxAngle - f.minAngle < Math.PI && f.maxAngle - f.minAngle > 0) {
            let m = { $type: Point_$type, x: ViewportUtils.c(f.center.x + g * Math.cos(f.minAngle), b, c), y: ViewportUtils.f(f.center.y + g * Math.sin(f.minAngle), b, c) };
            let n = { $type: Point_$type, x: ViewportUtils.c(f.center.x + g * Math.cos(f.maxAngle), b, c), y: ViewportUtils.f(f.center.y + g * Math.sin(f.maxAngle), b, c) };
            let o = new PathFigure();
            o._startPoint = m;
            o._isClosed = false;
            o._segments.add(((() => {
                let $ret = new ArcSegment();
                $ret.b = false;
                $ret.e = n;
                $ret.f = new Size(1, i, j);
                $ret.d = 1;
                return $ret;
            })()));
            h.c.add(o);
        }
        else {
            let p = new PathFigure();
            p._startPoint = { $type: Point_$type, x: k, y: l - j };
            p._isClosed = true;
            p._segments.add(((() => {
                let $ret = new ArcSegment();
                $ret.b = false;
                $ret.e = { $type: Point_$type, x: k, y: l + j };
                $ret.f = new Size(1, i, j);
                $ret.d = 1;
                return $ret;
            })()));
            p._segments.add(((() => {
                let $ret = new ArcSegment();
                $ret.b = false;
                $ret.e = { $type: Point_$type, x: k, y: l - j };
                $ret.f = new Size(1, i, j);
                $ret.d = 1;
                return $ret;
            })()));
            h.c.add(p);
        }
        return h;
    }
}
NumericRadiusAxis.$t = markType(NumericRadiusAxis, 'NumericRadiusAxis', NumericAxisBase.$);
NumericRadiusAxis.$$p = markDep(DependencyProperty, PropertyMetadata, NumericRadiusAxis, 'g0', ['InnerRadiusExtentScale:ls:l0', [1, 0], 'RadiusExtentScale:lt:l1', [1, 0.75]]);
/**
 * @hidden
 */
export class AngleAxisLabelPanelView extends AxisLabelPanelBaseView {
    constructor(a) {
        super(a);
        this.ax = null;
        this.ax = a;
    }
    am() {
        super.am();
        this.ax.ct = true;
    }
    ay(a, b) {
        this.ax.cx = -1.7976931348623157E+308;
        this.ax.cu = -1.7976931348623157E+308;
        this.ax.cw = -1.7976931348623157E+308;
        this.ax.cv = -1.7976931348623157E+308;
        for (let c = 0; c < this.a.a3.count; c++) {
            let d = this.a.a3._inner[c];
            let e = this.a.a2._inner[c];
            let f = e.a;
            let g = this.ax.cz(e.c);
            let h = this.m(d);
            let i = this.l(d);
            let j = h + this.p() + this.q();
            let k = i + this.r() + this.o();
            let l = g.x - j / 2;
            let m = g.y - k / 2;
            this.ax.cw = Math.max(h, this.ax.cw);
            this.ax.cv = Math.max(i, this.ax.cv);
            this.ax.cx = Math.max(j, this.ax.cx);
            this.ax.cu = Math.max(k, this.ax.cu);
            let n = new Rect(0, l, m, j, k);
            a.add(n);
            b.add(f);
        }
    }
    o() {
        return 0;
    }
    p() {
        return 0;
    }
    q() {
        return 0;
    }
    r() {
        return 0;
    }
}
AngleAxisLabelPanelView.$t = markType(AngleAxisLabelPanelView, 'AngleAxisLabelPanelView', AxisLabelPanelBaseView.$);
/**
 * @hidden
 */
export class CategoryAngleAxisView extends CategoryAxisBaseView {
    constructor(a) {
        super(a);
        this.bg = null;
        this.bg = a;
    }
}
CategoryAngleAxisView.$t = markType(CategoryAngleAxisView, 'CategoryAngleAxisView', CategoryAxisBaseView.$);
/**
 * @hidden
 */
export class NumericAngleAxisView extends NumericAxisBaseView {
    constructor(a) {
        super(a);
        this.bg = null;
        this.bg = a;
    }
}
NumericAngleAxisView.$t = markType(NumericAngleAxisView, 'NumericAngleAxisView', NumericAxisBaseView.$);
/**
 * @hidden
 */
export class NumericRadiusAxisView extends NumericAxisBaseView {
    constructor(a) {
        super(a);
        this.bg = null;
        this.bg = a;
    }
}
NumericRadiusAxisView.$t = markType(NumericRadiusAxisView, 'NumericRadiusAxisView', NumericAxisBaseView.$);
//# sourceMappingURL=AngleAxisLabelPanel_combined.js.map