@hkyhy/marsun-components-core 0.1.113 → 0.1.114

package/dist/node_modules/@antv/scale/esm/scales/ordinal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ordinal.js","sources":["../../../../../../node_modules/@antv/scale/esm/scales/ordinal.js"],"sourcesContent":["import { Base } from './base';\nexport const defaultUnknown = Symbol('defaultUnknown');\n/**\n * 更新 indexMap\n *\n * @param arr 初始的数组\n * @param target 目标 map\n * @returns {Map<string, any>} 生成的 indexMap\n */\nfunction updateIndexMap(target, arr, key) {\n    for (let i = 0; i < arr.length; i += 1) {\n        if (!target.has(arr[i])) {\n            target.set(key(arr[i]), i);\n        }\n    }\n}\n/**\n * 基于 indexMap 进行映射\n *\n * @param options 相关选项\n * @see MapBetweenArrOptions\n * @return {any} 映射结果\n */\nfunction mapBetweenArrByMapIndex(options) {\n    const { value, from, to, mapper, notFoundReturn } = options;\n    let mappedIndex = mapper.get(value);\n    // index 不存在时，\n    // 如果用户显式设置了 unknown 的值，那么就返回 unknown 的值\n    // 否者我们将 value 添加到原数组, 并更新 Map\n    if (mappedIndex === undefined) {\n        if (notFoundReturn !== defaultUnknown) {\n            return notFoundReturn;\n        }\n        mappedIndex = from.push(value) - 1;\n        mapper.set(value, mappedIndex);\n    }\n    return to[mappedIndex % to.length];\n}\nfunction createKey(d) {\n    if (d instanceof Date)\n        return (d) => `${d}`;\n    if (typeof d === 'object')\n        return (d) => JSON.stringify(d);\n    return (d) => d;\n}\n/**\n * Ordinal 比例尺\n *\n * 该比例尺具有离散的域和范围，例如将一组命名类别映射到一组颜色\n *\n * - 使用 for 替代一些基于 map 的遍历，for 循环性能远高于 forEach, map\n * - 阻止无意义的更新，只有到用户调用 map、invert 或者 update 之后才会进行相应的更新\n * - 两个 map 只初始化一次，在之后的更新中复用他们，这样我们避免了重复 new Map 带来的性能问题\n *   在大量调用 update 函数场景下，较 d3-scale 效率有质的提高\n */\nexport class Ordinal extends Base {\n    // 覆盖默认配置\n    getDefaultOptions() {\n        return {\n            domain: [],\n            range: [],\n            unknown: defaultUnknown,\n        };\n    }\n    // 显示指定 options 的类型为 OrdinalOptions，从而推断出 O 的类型\n    constructor(options) {\n        super(options);\n    }\n    map(x) {\n        if (this.domainIndexMap.size === 0) {\n            updateIndexMap(this.domainIndexMap, this.getDomain(), this.domainKey);\n        }\n        return mapBetweenArrByMapIndex({\n            value: this.domainKey(x),\n            mapper: this.domainIndexMap,\n            from: this.getDomain(),\n            to: this.getRange(),\n            notFoundReturn: this.options.unknown,\n        });\n    }\n    invert(y) {\n        if (this.rangeIndexMap.size === 0) {\n            updateIndexMap(this.rangeIndexMap, this.getRange(), this.rangeKey);\n        }\n        return mapBetweenArrByMapIndex({\n            value: this.rangeKey(y),\n            mapper: this.rangeIndexMap,\n            from: this.getRange(),\n            to: this.getDomain(),\n            notFoundReturn: this.options.unknown,\n        });\n    }\n    // 因为 ordinal 比例尺更新内部状态的开销较大，所以按需更新\n    rescale(options) {\n        const [d] = this.options.domain;\n        const [r] = this.options.range;\n        this.domainKey = createKey(d);\n        this.rangeKey = createKey(r);\n        // 如果 rangeIndexMap 没有初始化，说明是在初始化阶段\n        if (!this.rangeIndexMap) {\n            this.rangeIndexMap = new Map();\n            this.domainIndexMap = new Map();\n            return;\n        }\n        // 否者是在更新阶段\n        if (!options || options.range) {\n            this.rangeIndexMap.clear();\n        }\n        if (!options || options.domain || options.compare) {\n            this.domainIndexMap.clear();\n            this.sortedDomain = undefined;\n        }\n    }\n    clone() {\n        return new Ordinal(this.options);\n    }\n    getRange() {\n        return this.options.range;\n    }\n    getDomain() {\n        // 如果设置了比较器，就排序\n        if (this.sortedDomain)\n            return this.sortedDomain;\n        const { domain, compare } = this.options;\n        this.sortedDomain = compare ? [...domain].sort(compare) : domain;\n        return this.sortedDomain;\n    }\n}\n//# sourceMappingURL=ordinal.js.map"],"names":["defaultUnknown","updateIndexMap","target","arr","key","i","mapBetweenArrByMapIndex","options","value","from","to","mapper","notFoundReturn","mappedIndex","createKey","d","Ordinal","Base","x","y","r","domain","compare"],"mappings":";AACY,MAACA,IAAiB,OAAO,gBAAgB;AAQrD,SAASC,EAAeC,GAAQC,GAAKC,GAAK;AACtC,WAASC,IAAI,GAAGA,IAAIF,EAAI,QAAQE,KAAK;AACjC,IAAKH,EAAO,IAAIC,EAAIE,CAAC,CAAC,KAClBH,EAAO,IAAIE,EAAID,EAAIE,CAAC,CAAC,GAAGA,CAAC;AAGrC;AAQA,SAASC,EAAwBC,GAAS;AACtC,QAAM,EAAE,OAAAC,GAAO,MAAAC,GAAM,IAAAC,GAAI,QAAAC,GAAQ,gBAAAC,EAAc,IAAKL;AACpD,MAAIM,IAAcF,EAAO,IAAIH,CAAK;AAIlC,MAAIK,MAAgB,QAAW;AAC3B,QAAID,MAAmBZ;AACnB,aAAOY;AAEX,IAAAC,IAAcJ,EAAK,KAAKD,CAAK,IAAI,GACjCG,EAAO,IAAIH,GAAOK,CAAW;AAAA,EACjC;AACA,SAAOH,EAAGG,IAAcH,EAAG,MAAM;AACrC;AACA,SAASI,EAAUC,GAAG;AAClB,SAAIA,aAAa,OACN,CAACA,MAAM,GAAGA,CAAC,KAClB,OAAOA,KAAM,WACN,CAACA,MAAM,KAAK,UAAUA,CAAC,IAC3B,CAACA,MAAMA;AAClB;AAWO,MAAMC,UAAgBC,EAAK;AAAA;AAAA,EAE9B,oBAAoB;AAChB,WAAO;AAAA,MACH,QAAQ,CAAA;AAAA,MACR,OAAO,CAAA;AAAA,MACP,SAASjB;AAAA,IACrB;AAAA,EACI;AAAA;AAAA,EAEA,YAAYO,GAAS;AACjB,UAAMA,CAAO;AAAA,EACjB;AAAA,EACA,IAAIW,GAAG;AACH,WAAI,KAAK,eAAe,SAAS,KAC7BjB,EAAe,KAAK,gBAAgB,KAAK,UAAS,GAAI,KAAK,SAAS,GAEjEK,EAAwB;AAAA,MAC3B,OAAO,KAAK,UAAUY,CAAC;AAAA,MACvB,QAAQ,KAAK;AAAA,MACb,MAAM,KAAK,UAAS;AAAA,MACpB,IAAI,KAAK,SAAQ;AAAA,MACjB,gBAAgB,KAAK,QAAQ;AAAA,IACzC,CAAS;AAAA,EACL;AAAA,EACA,OAAOC,GAAG;AACN,WAAI,KAAK,cAAc,SAAS,KAC5BlB,EAAe,KAAK,eAAe,KAAK,SAAQ,GAAI,KAAK,QAAQ,GAE9DK,EAAwB;AAAA,MAC3B,OAAO,KAAK,SAASa,CAAC;AAAA,MACtB,QAAQ,KAAK;AAAA,MACb,MAAM,KAAK,SAAQ;AAAA,MACnB,IAAI,KAAK,UAAS;AAAA,MAClB,gBAAgB,KAAK,QAAQ;AAAA,IACzC,CAAS;AAAA,EACL;AAAA;AAAA,EAEA,QAAQZ,GAAS;AACb,UAAM,CAACQ,CAAC,IAAI,KAAK,QAAQ,QACnB,CAACK,CAAC,IAAI,KAAK,QAAQ;AAIzB,QAHA,KAAK,YAAYN,EAAUC,CAAC,GAC5B,KAAK,WAAWD,EAAUM,CAAC,GAEvB,CAAC,KAAK,eAAe;AACrB,WAAK,gBAAgB,oBAAI,IAAG,GAC5B,KAAK,iBAAiB,oBAAI,IAAG;AAC7B;AAAA,IACJ;AAEA,KAAI,CAACb,KAAWA,EAAQ,UACpB,KAAK,cAAc,MAAK,IAExB,CAACA,KAAWA,EAAQ,UAAUA,EAAQ,aACtC,KAAK,eAAe,MAAK,GACzB,KAAK,eAAe;AAAA,EAE5B;AAAA,EACA,QAAQ;AACJ,WAAO,IAAIS,EAAQ,KAAK,OAAO;AAAA,EACnC;AAAA,EACA,WAAW;AACP,WAAO,KAAK,QAAQ;AAAA,EACxB;AAAA,EACA,YAAY;AAER,QAAI,KAAK;AACL,aAAO,KAAK;AAChB,UAAM,EAAE,QAAAK,GAAQ,SAAAC,EAAO,IAAK,KAAK;AACjC,gBAAK,eAAeA,IAAU,CAAC,GAAGD,CAAM,EAAE,KAAKC,CAAO,IAAID,GACnD,KAAK;AAAA,EAChB;AACJ;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/scale/esm/scales/point.js

@@ -0,0 +1,38 @@
+import { Band as t } from "./band.js";
+import { defaultUnknown as r } from "./ordinal.js";
+class e extends t {
+  // 覆盖默认配置
+  getDefaultOptions() {
+    return {
+      domain: [],
+      range: [0, 1],
+      align: 0.5,
+      round: !1,
+      padding: 0,
+      unknown: r,
+      paddingInner: 1,
+      paddingOuter: 0
+    };
+  }
+  // 能接受的参数只是 PointOptions，不能有 paddingInner 这些属性
+  constructor(n) {
+    super(n);
+  }
+  // Point 的 paddingInner 只能是1，不能被覆盖
+  getPaddingInner() {
+    return 1;
+  }
+  clone() {
+    return new e(this.options);
+  }
+  update(n) {
+    super.update(n);
+  }
+  getPaddingOuter() {
+    return this.options.padding;
+  }
+}
+export {
+  e as Point
+};
+//# sourceMappingURL=point.js.map

package/dist/node_modules/@antv/scale/esm/scales/point.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"point.js","sources":["../../../../../../node_modules/@antv/scale/esm/scales/point.js"],"sourcesContent":["import { Band } from './band';\nimport { defaultUnknown } from './ordinal';\n/**\n * Point 比例尺\n *\n * 一种特殊的 band scale，它的 bandWidth 恒为 0。\n *\n * 由于部分选项较为抽象，见下图描述：\n *\n * PO = Padding = PaddingInner\n * domain =  [\"A\", \"B\", \"C\"]\n *\n * |<------------------------------------------- range ------------------------------------------->|\n * |             |                                 |                                 |             |\n * |<--step*PO-->|<--------------step------------->|<--------------step------------->|<--step*PO-->|\n * |             |                                 |                                 |             |\n * |             A                                 B                                 C             |\n * |-----------------------------------------------------------------------------------------------|\n *\n * 性能方便较 d3 快出 8 - 9 倍\n */\nexport class Point extends Band {\n    // 覆盖默认配置\n    getDefaultOptions() {\n        return {\n            domain: [],\n            range: [0, 1],\n            align: 0.5,\n            round: false,\n            padding: 0,\n            unknown: defaultUnknown,\n            paddingInner: 1,\n            paddingOuter: 0,\n        };\n    }\n    // 能接受的参数只是 PointOptions，不能有 paddingInner 这些属性\n    constructor(options) {\n        super(options);\n    }\n    // Point 的 paddingInner 只能是1，不能被覆盖\n    getPaddingInner() {\n        return 1;\n    }\n    clone() {\n        return new Point(this.options);\n    }\n    update(options) {\n        super.update(options);\n    }\n    getPaddingOuter() {\n        return this.options.padding;\n    }\n}\n//# sourceMappingURL=point.js.map"],"names":["Point","Band","defaultUnknown","options"],"mappings":";;AAqBO,MAAMA,UAAcC,EAAK;AAAA;AAAA,EAE5B,oBAAoB;AAChB,WAAO;AAAA,MACH,QAAQ,CAAA;AAAA,MACR,OAAO,CAAC,GAAG,CAAC;AAAA,MACZ,OAAO;AAAA,MACP,OAAO;AAAA,MACP,SAAS;AAAA,MACT,SAASC;AAAA,MACT,cAAc;AAAA,MACd,cAAc;AAAA,IAC1B;AAAA,EACI;AAAA;AAAA,EAEA,YAAYC,GAAS;AACjB,UAAMA,CAAO;AAAA,EACjB;AAAA;AAAA,EAEA,kBAAkB;AACd,WAAO;AAAA,EACX;AAAA,EACA,QAAQ;AACJ,WAAO,IAAIH,EAAM,KAAK,OAAO;AAAA,EACjC;AAAA,EACA,OAAOG,GAAS;AACZ,UAAM,OAAOA,CAAO;AAAA,EACxB;AAAA,EACA,kBAAkB;AACd,WAAO,KAAK,QAAQ;AAAA,EACxB;AACJ;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/scale/esm/scales/pow.js

@@ -0,0 +1,38 @@
+import { Continuous as a } from "./continuous.js";
+import { d3Ticks as i } from "../tick-methods/d3-ticks.js";
+import { createInterpolateValue as u } from "../utils/interpolate.js";
+import o from "../../../util/esm/lodash/identity.js";
+const c = (r) => (t) => t < 0 ? -((-t) ** r) : t ** r, m = (r) => (t) => t < 0 ? -((-t) ** (1 / r)) : t ** (1 / r), f = (r) => r < 0 ? -Math.sqrt(-r) : Math.sqrt(r);
+class n extends a {
+  getDefaultOptions() {
+    return {
+      domain: [0, 1],
+      range: [0, 1],
+      nice: !1,
+      clamp: !1,
+      round: !1,
+      exponent: 2,
+      interpolate: u,
+      tickMethod: i,
+      tickCount: 5
+    };
+  }
+  // 显示指定 options 的类型为 PowOptions O 的类型
+  constructor(t) {
+    super(t);
+  }
+  chooseTransforms() {
+    const { exponent: t } = this.options;
+    if (t === 1)
+      return [o, o];
+    const e = t === 0.5 ? f : c(t), s = m(t);
+    return [e, s];
+  }
+  clone() {
+    return new n(this.options);
+  }
+}
+export {
+  n as Pow
+};
+//# sourceMappingURL=pow.js.map

package/dist/node_modules/@antv/scale/esm/scales/pow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pow.js","sources":["../../../../../../node_modules/@antv/scale/esm/scales/pow.js"],"sourcesContent":["import { identity } from '@antv/util';\nimport { Continuous } from './continuous';\nimport { createInterpolateValue } from '../utils';\nimport { d3Ticks } from '../tick-methods/d3-ticks';\nconst transformPow = (exponent) => {\n    return (x) => {\n        return x < 0 ? -((-x) ** exponent) : x ** exponent;\n    };\n};\nconst transformPowInvert = (exponent) => {\n    return (x) => {\n        return x < 0 ? -((-x) ** (1 / exponent)) : x ** (1 / exponent);\n    };\n};\nconst transformSqrt = (x) => {\n    return x < 0 ? -Math.sqrt(-x) : Math.sqrt(x);\n};\n/**\n * Pow 比例尺\n *\n * 类似于 linear scale, 不同之处在于在计算输出范围值之前对输入域值应用了指数变换,.\n * 即 y = x ^ k 其中 k（指数）可以是任何实数。\n */\nexport class Pow extends Continuous {\n    getDefaultOptions() {\n        return {\n            domain: [0, 1],\n            range: [0, 1],\n            nice: false,\n            clamp: false,\n            round: false,\n            exponent: 2,\n            interpolate: createInterpolateValue,\n            tickMethod: d3Ticks,\n            tickCount: 5,\n        };\n    }\n    // 显示指定 options 的类型为 PowOptions O 的类型\n    constructor(options) {\n        super(options);\n    }\n    chooseTransforms() {\n        const { exponent } = this.options;\n        if (exponent === 1)\n            return [identity, identity];\n        const transform = exponent === 0.5 ? transformSqrt : transformPow(exponent);\n        const untransform = transformPowInvert(exponent);\n        return [transform, untransform];\n    }\n    clone() {\n        return new Pow(this.options);\n    }\n}\n//# sourceMappingURL=pow.js.map"],"names":["transformPow","exponent","x","transformPowInvert","transformSqrt","Pow","Continuous","createInterpolateValue","d3Ticks","options","identity","transform","untransform"],"mappings":";;;;AAIA,MAAMA,IAAe,CAACC,MACX,CAACC,MACGA,IAAI,IAAI,GAAG,CAACA,MAAMD,KAAYC,KAAKD,GAG5CE,IAAqB,CAACF,MACjB,CAACC,MACGA,IAAI,IAAI,GAAG,CAACA,OAAO,IAAID,MAAaC,MAAM,IAAID,IAGvDG,IAAgB,CAACF,MACZA,IAAI,IAAI,CAAC,KAAK,KAAK,CAACA,CAAC,IAAI,KAAK,KAAKA,CAAC;AAQxC,MAAMG,UAAYC,EAAW;AAAA,EAChC,oBAAoB;AAChB,WAAO;AAAA,MACH,QAAQ,CAAC,GAAG,CAAC;AAAA,MACb,OAAO,CAAC,GAAG,CAAC;AAAA,MACZ,MAAM;AAAA,MACN,OAAO;AAAA,MACP,OAAO;AAAA,MACP,UAAU;AAAA,MACV,aAAaC;AAAA,MACb,YAAYC;AAAA,MACZ,WAAW;AAAA,IACvB;AAAA,EACI;AAAA;AAAA,EAEA,YAAYC,GAAS;AACjB,UAAMA,CAAO;AAAA,EACjB;AAAA,EACA,mBAAmB;AACf,UAAM,EAAE,UAAAR,MAAa,KAAK;AAC1B,QAAIA,MAAa;AACb,aAAO,CAACS,GAAUA,CAAQ;AAC9B,UAAMC,IAAYV,MAAa,MAAMG,IAAgBJ,EAAaC,CAAQ,GACpEW,IAAcT,EAAmBF,CAAQ;AAC/C,WAAO,CAACU,GAAWC,CAAW;AAAA,EAClC;AAAA,EACA,QAAQ;AACJ,WAAO,IAAIP,EAAI,KAAK,OAAO;AAAA,EAC/B;AACJ;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/scale/esm/scales/quantile.js

@@ -0,0 +1,42 @@
+import { Threshold as d } from "./threshold.js";
+import { wilkinsonExtended as h } from "../tick-methods/wilkinson-extended.js";
+import { createQuartile as c } from "../utils/create-quartile.js";
+class r extends d {
+  getDefaultOptions() {
+    return {
+      domain: [],
+      range: [],
+      tickCount: 5,
+      unknown: void 0,
+      tickMethod: h
+    };
+  }
+  constructor(n) {
+    super(n);
+  }
+  rescale() {
+    const { domain: n, range: t } = this.options;
+    this.n = t.length - 1, this.thresholds = c(n, this.n + 1, !1);
+  }
+  /**
+   * 如果是在第一段后或者最后一段就把两端的值添加上
+   */
+  invert(n) {
+    const [t, e] = super.invert(n), { domain: o } = this.options, s = o[0], i = o[o.length - 1];
+    return t === void 0 && e === void 0 ? [t, e] : [t || s, e || i];
+  }
+  getThresholds() {
+    return this.thresholds;
+  }
+  clone() {
+    return new r(this.options);
+  }
+  getTicks() {
+    const { tickCount: n, domain: t, tickMethod: e } = this.options, o = t.length - 1, s = t[0], i = t[o];
+    return e(s, i, n);
+  }
+}
+export {
+  r as Quantile
+};
+//# sourceMappingURL=quantile.js.map

package/dist/node_modules/@antv/scale/esm/scales/quantile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quantile.js","sources":["../../../../../../node_modules/@antv/scale/esm/scales/quantile.js"],"sourcesContent":["import { Threshold } from './threshold';\nimport { wilkinsonExtended } from '../tick-methods/wilkinson-extended';\nimport { createQuartile } from '../utils/create-quartile';\n/**\n * 类似 Threshold 比例尺，区别在于分位数比例尺 (Quantile) 将一个离散的输入域映射到一个离散的输出域\n * 输入域被指定为一组离散的样本值，输出域中的值的数量决定了分位数的数量。\n */\nexport class Quantile extends Threshold {\n    getDefaultOptions() {\n        return {\n            domain: [],\n            range: [],\n            tickCount: 5,\n            unknown: undefined,\n            tickMethod: wilkinsonExtended,\n        };\n    }\n    constructor(options) {\n        super(options);\n    }\n    rescale() {\n        const { domain, range } = this.options;\n        this.n = range.length - 1;\n        this.thresholds = createQuartile(domain, this.n + 1, false);\n    }\n    /**\n     * 如果是在第一段后或者最后一段就把两端的值添加上\n     */\n    invert(y) {\n        const [a, b] = super.invert(y);\n        const { domain } = this.options;\n        const dMin = domain[0];\n        const dMax = domain[domain.length - 1];\n        return a === undefined && b === undefined ? [a, b] : [a || dMin, b || dMax];\n    }\n    getThresholds() {\n        return this.thresholds;\n    }\n    clone() {\n        return new Quantile(this.options);\n    }\n    getTicks() {\n        const { tickCount, domain, tickMethod } = this.options;\n        const lastIndex = domain.length - 1;\n        const min = domain[0];\n        const max = domain[lastIndex];\n        return tickMethod(min, max, tickCount);\n    }\n}\n//# sourceMappingURL=quantile.js.map"],"names":["Quantile","Threshold","wilkinsonExtended","options","domain","range","createQuartile","y","a","b","dMin","dMax","tickCount","tickMethod","lastIndex","min","max"],"mappings":";;;AAOO,MAAMA,UAAiBC,EAAU;AAAA,EACpC,oBAAoB;AAChB,WAAO;AAAA,MACH,QAAQ,CAAA;AAAA,MACR,OAAO,CAAA;AAAA,MACP,WAAW;AAAA,MACX,SAAS;AAAA,MACT,YAAYC;AAAA,IACxB;AAAA,EACI;AAAA,EACA,YAAYC,GAAS;AACjB,UAAMA,CAAO;AAAA,EACjB;AAAA,EACA,UAAU;AACN,UAAM,EAAE,QAAAC,GAAQ,OAAAC,EAAK,IAAK,KAAK;AAC/B,SAAK,IAAIA,EAAM,SAAS,GACxB,KAAK,aAAaC,EAAeF,GAAQ,KAAK,IAAI,GAAG,EAAK;AAAA,EAC9D;AAAA;AAAA;AAAA;AAAA,EAIA,OAAOG,GAAG;AACN,UAAM,CAACC,GAAGC,CAAC,IAAI,MAAM,OAAOF,CAAC,GACvB,EAAE,QAAAH,MAAW,KAAK,SAClBM,IAAON,EAAO,CAAC,GACfO,IAAOP,EAAOA,EAAO,SAAS,CAAC;AACrC,WAAOI,MAAM,UAAaC,MAAM,SAAY,CAACD,GAAGC,CAAC,IAAI,CAACD,KAAKE,GAAMD,KAAKE,CAAI;AAAA,EAC9E;AAAA,EACA,gBAAgB;AACZ,WAAO,KAAK;AAAA,EAChB;AAAA,EACA,QAAQ;AACJ,WAAO,IAAIX,EAAS,KAAK,OAAO;AAAA,EACpC;AAAA,EACA,WAAW;AACP,UAAM,EAAE,WAAAY,GAAW,QAAAR,GAAQ,YAAAS,EAAU,IAAK,KAAK,SACzCC,IAAYV,EAAO,SAAS,GAC5BW,IAAMX,EAAO,CAAC,GACdY,IAAMZ,EAAOU,CAAS;AAC5B,WAAOD,EAAWE,GAAKC,GAAKJ,CAAS;AAAA,EACzC;AACJ;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/scale/esm/scales/quantize.js

@@ -0,0 +1,56 @@
+import { Threshold as r } from "./threshold.js";
+import { wilkinsonExtended as h } from "../tick-methods/wilkinson-extended.js";
+import { d3LinearNice as c } from "../utils/d3-linear-nice.js";
+class e extends r {
+  getDefaultOptions() {
+    return {
+      domain: [0, 1],
+      range: [0.5],
+      nice: !1,
+      tickCount: 5,
+      tickMethod: h
+    };
+  }
+  constructor(t) {
+    super(t);
+  }
+  nice() {
+    const { nice: t } = this.options;
+    if (t) {
+      const [n, i, o] = this.getTickMethodOptions();
+      this.options.domain = c(n, i, o);
+    }
+  }
+  getTicks() {
+    const { tickMethod: t } = this.options, [n, i, o] = this.getTickMethodOptions();
+    return t(n, i, o);
+  }
+  getTickMethodOptions() {
+    const { domain: t, tickCount: n } = this.options, i = t[0], o = t[t.length - 1];
+    return [i, o, n];
+  }
+  rescale() {
+    this.nice();
+    const { range: t, domain: n } = this.options, [i, o] = n;
+    this.n = t.length - 1, this.thresholds = new Array(this.n);
+    for (let s = 0; s < this.n; s += 1)
+      this.thresholds[s] = ((s + 1) * o - (s - this.n) * i) / (this.n + 1);
+  }
+  /**
+   * 如果是在第一段后或者最后一段就把两端的值添加上
+   */
+  invert(t) {
+    const [n, i] = super.invert(t), [o, s] = this.options.domain;
+    return n === void 0 && i === void 0 ? [n, i] : [n || o, i || s];
+  }
+  getThresholds() {
+    return this.thresholds;
+  }
+  clone() {
+    return new e(this.options);
+  }
+}
+export {
+  e as Quantize
+};
+//# sourceMappingURL=quantize.js.map

package/dist/node_modules/@antv/scale/esm/scales/quantize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quantize.js","sources":["../../../../../../node_modules/@antv/scale/esm/scales/quantize.js"],"sourcesContent":["import { Threshold } from './threshold';\nimport { wilkinsonExtended } from '../tick-methods/wilkinson-extended';\nimport { d3LinearNice } from '../utils';\n/**\n * 类似 Threshold 比例尺，区别在于 thresholds 是根据连续的 domain 根据离散的 range 的数量计算而得到的。\n */\nexport class Quantize extends Threshold {\n    getDefaultOptions() {\n        return {\n            domain: [0, 1],\n            range: [0.5],\n            nice: false,\n            tickCount: 5,\n            tickMethod: wilkinsonExtended,\n        };\n    }\n    constructor(options) {\n        super(options);\n    }\n    nice() {\n        const { nice } = this.options;\n        if (nice) {\n            const [min, max, tickCount] = this.getTickMethodOptions();\n            this.options.domain = d3LinearNice(min, max, tickCount);\n        }\n    }\n    getTicks() {\n        const { tickMethod } = this.options;\n        const [min, max, tickCount] = this.getTickMethodOptions();\n        return tickMethod(min, max, tickCount);\n    }\n    getTickMethodOptions() {\n        const { domain, tickCount } = this.options;\n        const min = domain[0];\n        const max = domain[domain.length - 1];\n        return [min, max, tickCount];\n    }\n    rescale() {\n        this.nice();\n        const { range, domain } = this.options;\n        const [x0, x1] = domain;\n        this.n = range.length - 1;\n        this.thresholds = new Array(this.n);\n        for (let i = 0; i < this.n; i += 1) {\n            this.thresholds[i] = ((i + 1) * x1 - (i - this.n) * x0) / (this.n + 1);\n        }\n    }\n    /**\n     * 如果是在第一段后或者最后一段就把两端的值添加上\n     */\n    invert(y) {\n        const [a, b] = super.invert(y);\n        const [x0, x1] = this.options.domain;\n        return a === undefined && b === undefined ? [a, b] : [a || x0, b || x1];\n    }\n    getThresholds() {\n        return this.thresholds;\n    }\n    clone() {\n        return new Quantize(this.options);\n    }\n}\n//# sourceMappingURL=quantize.js.map"],"names":["Quantize","Threshold","wilkinsonExtended","options","nice","min","max","tickCount","d3LinearNice","tickMethod","domain","range","x0","x1","i","y","a","b"],"mappings":";;;AAMO,MAAMA,UAAiBC,EAAU;AAAA,EACpC,oBAAoB;AAChB,WAAO;AAAA,MACH,QAAQ,CAAC,GAAG,CAAC;AAAA,MACb,OAAO,CAAC,GAAG;AAAA,MACX,MAAM;AAAA,MACN,WAAW;AAAA,MACX,YAAYC;AAAA,IACxB;AAAA,EACI;AAAA,EACA,YAAYC,GAAS;AACjB,UAAMA,CAAO;AAAA,EACjB;AAAA,EACA,OAAO;AACH,UAAM,EAAE,MAAAC,MAAS,KAAK;AACtB,QAAIA,GAAM;AACN,YAAM,CAACC,GAAKC,GAAKC,CAAS,IAAI,KAAK,qBAAoB;AACvD,WAAK,QAAQ,SAASC,EAAaH,GAAKC,GAAKC,CAAS;AAAA,IAC1D;AAAA,EACJ;AAAA,EACA,WAAW;AACP,UAAM,EAAE,YAAAE,MAAe,KAAK,SACtB,CAACJ,GAAKC,GAAKC,CAAS,IAAI,KAAK,qBAAoB;AACvD,WAAOE,EAAWJ,GAAKC,GAAKC,CAAS;AAAA,EACzC;AAAA,EACA,uBAAuB;AACnB,UAAM,EAAE,QAAAG,GAAQ,WAAAH,EAAS,IAAK,KAAK,SAC7BF,IAAMK,EAAO,CAAC,GACdJ,IAAMI,EAAOA,EAAO,SAAS,CAAC;AACpC,WAAO,CAACL,GAAKC,GAAKC,CAAS;AAAA,EAC/B;AAAA,EACA,UAAU;AACN,SAAK,KAAI;AACT,UAAM,EAAE,OAAAI,GAAO,QAAAD,EAAM,IAAK,KAAK,SACzB,CAACE,GAAIC,CAAE,IAAIH;AACjB,SAAK,IAAIC,EAAM,SAAS,GACxB,KAAK,aAAa,IAAI,MAAM,KAAK,CAAC;AAClC,aAASG,IAAI,GAAGA,IAAI,KAAK,GAAGA,KAAK;AAC7B,WAAK,WAAWA,CAAC,MAAMA,IAAI,KAAKD,KAAMC,IAAI,KAAK,KAAKF,MAAO,KAAK,IAAI;AAAA,EAE5E;AAAA;AAAA;AAAA;AAAA,EAIA,OAAOG,GAAG;AACN,UAAM,CAACC,GAAGC,CAAC,IAAI,MAAM,OAAOF,CAAC,GACvB,CAACH,GAAIC,CAAE,IAAI,KAAK,QAAQ;AAC9B,WAAOG,MAAM,UAAaC,MAAM,SAAY,CAACD,GAAGC,CAAC,IAAI,CAACD,KAAKJ,GAAIK,KAAKJ,CAAE;AAAA,EAC1E;AAAA,EACA,gBAAgB;AACZ,WAAO,KAAK;AAAA,EAChB;AAAA,EACA,QAAQ;AACJ,WAAO,IAAIb,EAAS,KAAK,OAAO;AAAA,EACpC;AACJ;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/scale/esm/scales/sequential.js

@@ -0,0 +1,47 @@
+import { d3Ticks as a } from "../tick-methods/d3-ticks.js";
+import { Linear as u } from "./linear.js";
+import p from "../../../util/esm/lodash/identity.js";
+import { interpolatize as d } from "../utils/interpolatize.js";
+import { compose as s } from "../utils/compose.js";
+import { createNormalize as z } from "../utils/normalize.js";
+import { createInterpolateNumber as O } from "../utils/interpolate.js";
+var _ = function(n, e, o, r) {
+  var i = arguments.length, t = i < 3 ? e : r === null ? r = Object.getOwnPropertyDescriptor(e, o) : r, f;
+  if (typeof Reflect == "object" && typeof Reflect.decorate == "function") t = Reflect.decorate(n, e, o, r);
+  else for (var c = n.length - 1; c >= 0; c--) (f = n[c]) && (t = (i < 3 ? f(t) : i > 3 ? f(e, o, t) : f(e, o)) || t);
+  return i > 3 && t && Object.defineProperty(e, o, t), t;
+}, l;
+function b(n) {
+  return [n(0), n(1)];
+}
+const h = (n) => {
+  const [e, o] = n;
+  return s(O(0, 1), z(e, o));
+};
+let m = l = class extends u {
+  getDefaultOptions() {
+    return {
+      domain: [0, 1],
+      unknown: void 0,
+      nice: !1,
+      clamp: !1,
+      round: !1,
+      interpolator: p,
+      tickMethod: a,
+      tickCount: 5
+    };
+  }
+  constructor(e) {
+    super(e);
+  }
+  clone() {
+    return new l(this.options);
+  }
+};
+m = l = _([
+  d(b, h)
+], m);
+export {
+  m as Sequential
+};
+//# sourceMappingURL=sequential.js.map

package/dist/node_modules/@antv/scale/esm/scales/sequential.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequential.js","sources":["../../../../../../node_modules/@antv/scale/esm/scales/sequential.js"],"sourcesContent":["var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar Sequential_1;\nimport { identity } from '@antv/util';\nimport { d3Ticks } from '../tick-methods/d3-ticks';\nimport { compose, createInterpolateNumber, createNormalize, interpolatize } from '../utils';\nimport { Linear } from './linear';\nfunction rangeOf(interpolator) {\n    return [interpolator(0), interpolator(1)];\n}\nconst normalizeDomain = (domain) => {\n    const [d0, d1] = domain;\n    // [d0, d1] => [0, 1]\n    const normalize = compose(createInterpolateNumber(0, 1), createNormalize(d0, d1));\n    return normalize;\n};\n/**\n * Sequential 比例尺\n *\n * 构造可创建一个在输入和输出之间通过插值函数进行转换的比例尺\n */\n// @Sequentialish\nlet Sequential = Sequential_1 = class Sequential extends Linear {\n    getDefaultOptions() {\n        return {\n            domain: [0, 1],\n            unknown: undefined,\n            nice: false,\n            clamp: false,\n            round: false,\n            interpolator: identity,\n            tickMethod: d3Ticks,\n            tickCount: 5,\n        };\n    }\n    constructor(options) {\n        super(options);\n    }\n    clone() {\n        return new Sequential_1(this.options);\n    }\n};\nSequential = Sequential_1 = __decorate([\n    interpolatize(rangeOf, normalizeDomain)\n], Sequential);\nexport { Sequential };\n//# sourceMappingURL=sequential.js.map"],"names":["__decorate","decorators","target","key","desc","c","r","d","i","Sequential_1","rangeOf","interpolator","normalizeDomain","domain","d0","d1","compose","createInterpolateNumber","createNormalize","Sequential","Linear","identity","d3Ticks","options","interpolatize"],"mappings":";;;;;;;AAAA,IAAIA,IAA0C,SAAUC,GAAYC,GAAQC,GAAKC,GAAM;AACnF,MAAIC,IAAI,UAAU,QAAQC,IAAID,IAAI,IAAIH,IAASE,MAAS,OAAOA,IAAO,OAAO,yBAAyBF,GAAQC,CAAG,IAAIC,GAAMG;AAC3H,MAAI,OAAO,WAAY,YAAY,OAAO,QAAQ,YAAa,WAAY,CAAAD,IAAI,QAAQ,SAASL,GAAYC,GAAQC,GAAKC,CAAI;AAAA,MACxH,UAASI,IAAIP,EAAW,SAAS,GAAGO,KAAK,GAAGA,IAAK,EAAID,IAAIN,EAAWO,CAAC,OAAGF,KAAKD,IAAI,IAAIE,EAAED,CAAC,IAAID,IAAI,IAAIE,EAAEL,GAAQC,GAAKG,CAAC,IAAIC,EAAEL,GAAQC,CAAG,MAAMG;AAChJ,SAAOD,IAAI,KAAKC,KAAK,OAAO,eAAeJ,GAAQC,GAAKG,CAAC,GAAGA;AAChE,GACIG;AAKJ,SAASC,EAAQC,GAAc;AAC3B,SAAO,CAACA,EAAa,CAAC,GAAGA,EAAa,CAAC,CAAC;AAC5C;AACA,MAAMC,IAAkB,CAACC,MAAW;AAChC,QAAM,CAACC,GAAIC,CAAE,IAAIF;AAGjB,SADkBG,EAAQC,EAAwB,GAAG,CAAC,GAAGC,EAAgBJ,GAAIC,CAAE,CAAC;AAEpF;AAOG,IAACI,IAAaV,IAAe,cAAyBW,EAAO;AAAA,EAC5D,oBAAoB;AAChB,WAAO;AAAA,MACH,QAAQ,CAAC,GAAG,CAAC;AAAA,MACb,SAAS;AAAA,MACT,MAAM;AAAA,MACN,OAAO;AAAA,MACP,OAAO;AAAA,MACP,cAAcC;AAAA,MACd,YAAYC;AAAA,MACZ,WAAW;AAAA,IACvB;AAAA,EACI;AAAA,EACA,YAAYC,GAAS;AACjB,UAAMA,CAAO;AAAA,EACjB;AAAA,EACA,QAAQ;AACJ,WAAO,IAAId,EAAa,KAAK,OAAO;AAAA,EACxC;AACJ;AACAU,IAAaV,IAAeT,EAAW;AAAA,EACnCwB,EAAcd,GAASE,CAAe;AAC1C,GAAGO,CAAU;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/scale/esm/scales/sqrt.js

@@ -0,0 +1,31 @@
+import { Pow as o } from "./pow.js";
+import { d3Ticks as r } from "../tick-methods/d3-ticks.js";
+import { createInterpolateValue as n } from "../utils/interpolate.js";
+class t extends o {
+  getDefaultOptions() {
+    return {
+      domain: [0, 1],
+      range: [0, 1],
+      nice: !1,
+      clamp: !1,
+      round: !1,
+      interpolate: n,
+      tickMethod: r,
+      tickCount: 5,
+      exponent: 0.5
+    };
+  }
+  constructor(e) {
+    super(e);
+  }
+  update(e) {
+    super.update(e);
+  }
+  clone() {
+    return new t(this.options);
+  }
+}
+export {
+  t as Sqrt
+};
+//# sourceMappingURL=sqrt.js.map

package/dist/node_modules/@antv/scale/esm/scales/sqrt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqrt.js","sources":["../../../../../../node_modules/@antv/scale/esm/scales/sqrt.js"],"sourcesContent":["import { createInterpolateValue } from '../utils';\nimport { Pow } from './pow';\nimport { d3Ticks } from '../tick-methods/d3-ticks';\nexport class Sqrt extends Pow {\n    getDefaultOptions() {\n        return {\n            domain: [0, 1],\n            range: [0, 1],\n            nice: false,\n            clamp: false,\n            round: false,\n            interpolate: createInterpolateValue,\n            tickMethod: d3Ticks,\n            tickCount: 5,\n            exponent: 0.5,\n        };\n    }\n    constructor(options) {\n        super(options);\n    }\n    update(options) {\n        super.update(options);\n    }\n    clone() {\n        return new Sqrt(this.options);\n    }\n}\n//# sourceMappingURL=sqrt.js.map"],"names":["Sqrt","Pow","createInterpolateValue","d3Ticks","options"],"mappings":";;;AAGO,MAAMA,UAAaC,EAAI;AAAA,EAC1B,oBAAoB;AAChB,WAAO;AAAA,MACH,QAAQ,CAAC,GAAG,CAAC;AAAA,MACb,OAAO,CAAC,GAAG,CAAC;AAAA,MACZ,MAAM;AAAA,MACN,OAAO;AAAA,MACP,OAAO;AAAA,MACP,aAAaC;AAAA,MACb,YAAYC;AAAA,MACZ,WAAW;AAAA,MACX,UAAU;AAAA,IACtB;AAAA,EACI;AAAA,EACA,YAAYC,GAAS;AACjB,UAAMA,CAAO;AAAA,EACjB;AAAA,EACA,OAAOA,GAAS;AACZ,UAAM,OAAOA,CAAO;AAAA,EACxB;AAAA,EACA,QAAQ;AACJ,WAAO,IAAIJ,EAAK,KAAK,OAAO;AAAA,EAChC;AACJ;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/scale/esm/scales/threshold.js

@@ -0,0 +1,41 @@
+import { Base as e } from "./base.js";
+import { isValid as r } from "../utils/is-valid.js";
+import { bisect as h } from "../utils/bisect.js";
+class i extends e {
+  getDefaultOptions() {
+    return {
+      domain: [0.5],
+      range: [0, 1]
+    };
+  }
+  constructor(t) {
+    super(t);
+  }
+  /**
+   * 二分查找到输入值在哪一段，返回对应的值域中的值
+   */
+  map(t) {
+    if (!r(t))
+      return this.options.unknown;
+    const n = h(this.thresholds, t, 0, this.n);
+    return this.options.range[n];
+  }
+  /**
+   * 在值域中找到对应的值，并返回在定义域中属于哪一段
+   */
+  invert(t) {
+    const { range: n } = this.options, s = n.indexOf(t), o = this.thresholds;
+    return [o[s - 1], o[s]];
+  }
+  clone() {
+    return new i(this.options);
+  }
+  rescale() {
+    const { domain: t, range: n } = this.options;
+    this.n = Math.min(t.length, n.length - 1), this.thresholds = t;
+  }
+}
+export {
+  i as Threshold
+};
+//# sourceMappingURL=threshold.js.map

package/dist/node_modules/@antv/scale/esm/scales/threshold.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"threshold.js","sources":["../../../../../../node_modules/@antv/scale/esm/scales/threshold.js"],"sourcesContent":["import { Base } from './base';\nimport { bisect, isValid } from '../utils';\n/**\n * 将连续的定义域分段，每一段所有的值对应离散的值域中一个值\n */\nexport class Threshold extends Base {\n    getDefaultOptions() {\n        return {\n            domain: [0.5],\n            range: [0, 1],\n        };\n    }\n    constructor(options) {\n        super(options);\n    }\n    /**\n     * 二分查找到输入值在哪一段，返回对应的值域中的值\n     */\n    map(x) {\n        if (!isValid(x))\n            return this.options.unknown;\n        const index = bisect(this.thresholds, x, 0, this.n);\n        return this.options.range[index];\n    }\n    /**\n     * 在值域中找到对应的值，并返回在定义域中属于哪一段\n     */\n    invert(y) {\n        const { range } = this.options;\n        const index = range.indexOf(y);\n        const domain = this.thresholds;\n        return [domain[index - 1], domain[index]];\n    }\n    clone() {\n        return new Threshold(this.options);\n    }\n    rescale() {\n        const { domain, range } = this.options;\n        this.n = Math.min(domain.length, range.length - 1);\n        this.thresholds = domain;\n    }\n}\n//# sourceMappingURL=threshold.js.map"],"names":["Threshold","Base","options","x","isValid","index","bisect","y","range","domain"],"mappings":";;;AAKO,MAAMA,UAAkBC,EAAK;AAAA,EAChC,oBAAoB;AAChB,WAAO;AAAA,MACH,QAAQ,CAAC,GAAG;AAAA,MACZ,OAAO,CAAC,GAAG,CAAC;AAAA,IACxB;AAAA,EACI;AAAA,EACA,YAAYC,GAAS;AACjB,UAAMA,CAAO;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA,EAIA,IAAIC,GAAG;AACH,QAAI,CAACC,EAAQD,CAAC;AACV,aAAO,KAAK,QAAQ;AACxB,UAAME,IAAQC,EAAO,KAAK,YAAYH,GAAG,GAAG,KAAK,CAAC;AAClD,WAAO,KAAK,QAAQ,MAAME,CAAK;AAAA,EACnC;AAAA;AAAA;AAAA;AAAA,EAIA,OAAOE,GAAG;AACN,UAAM,EAAE,OAAAC,MAAU,KAAK,SACjBH,IAAQG,EAAM,QAAQD,CAAC,GACvBE,IAAS,KAAK;AACpB,WAAO,CAACA,EAAOJ,IAAQ,CAAC,GAAGI,EAAOJ,CAAK,CAAC;AAAA,EAC5C;AAAA,EACA,QAAQ;AACJ,WAAO,IAAIL,EAAU,KAAK,OAAO;AAAA,EACrC;AAAA,EACA,UAAU;AACN,UAAM,EAAE,QAAAS,GAAQ,OAAAD,EAAK,IAAK,KAAK;AAC/B,SAAK,IAAI,KAAK,IAAIC,EAAO,QAAQD,EAAM,SAAS,CAAC,GACjD,KAAK,aAAaC;AAAA,EACtB;AACJ;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/scale/esm/scales/time.js

@@ -0,0 +1,51 @@
+import { format as a } from "../../../../fecha/lib/fecha.js";
+import { Continuous as c } from "./continuous.js";
+import { d3Time as f } from "../tick-methods/d3-time.js";
+import { createInterpolateNumber as u } from "../utils/interpolate.js";
+import { d3TimeNice as p } from "../utils/d3-time-nice.js";
+import { chooseNiceTimeMask as l } from "../utils/choose-mask.js";
+import d from "../../../util/esm/lodash/identity.js";
+import { utcIntervalMap as k } from "../utils/utc-interval.js";
+import { localIntervalMap as g } from "../utils/time-interval.js";
+function h(i) {
+  const e = i.getTimezoneOffset(), t = new Date(i);
+  return t.setMinutes(t.getMinutes() + e, t.getSeconds(), t.getMilliseconds()), t;
+}
+class s extends c {
+  getDefaultOptions() {
+    return {
+      domain: [new Date(2e3, 0, 1), new Date(2e3, 0, 2)],
+      range: [0, 1],
+      nice: !1,
+      tickCount: 5,
+      tickInterval: void 0,
+      unknown: void 0,
+      clamp: !1,
+      tickMethod: f,
+      interpolate: u,
+      mask: void 0,
+      utc: !1
+    };
+  }
+  chooseTransforms() {
+    return [(n) => +n, (n) => new Date(n)];
+  }
+  chooseNice() {
+    return p;
+  }
+  getTickMethodOptions() {
+    const { domain: e, tickCount: t, tickInterval: n, utc: r } = this.options, o = e[0], m = e[e.length - 1];
+    return [o, m, t, n, r];
+  }
+  getFormatter() {
+    const { mask: e, utc: t } = this.options, n = t ? k : g, r = t ? h : d;
+    return (o) => a(r(o), e || l(o, n));
+  }
+  clone() {
+    return new s(this.options);
+  }
+}
+export {
+  s as Time
+};
+//# sourceMappingURL=time.js.map

package/dist/node_modules/@antv/scale/esm/scales/time.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.js","sources":["../../../../../../node_modules/@antv/scale/esm/scales/time.js"],"sourcesContent":["import { identity } from '@antv/util';\nimport { format } from 'fecha';\nimport { Continuous } from './continuous';\nimport { d3Time } from '../tick-methods/d3-time';\nimport { d3TimeNice, createInterpolateNumber, localIntervalMap, utcIntervalMap, chooseNiceTimeMask } from '../utils';\nfunction offset(date) {\n    const minuteOffset = date.getTimezoneOffset();\n    const d = new Date(date);\n    d.setMinutes(d.getMinutes() + minuteOffset, d.getSeconds(), d.getMilliseconds());\n    return d;\n}\nexport class Time extends Continuous {\n    getDefaultOptions() {\n        return {\n            domain: [new Date(2000, 0, 1), new Date(2000, 0, 2)],\n            range: [0, 1],\n            nice: false,\n            tickCount: 5,\n            tickInterval: undefined,\n            unknown: undefined,\n            clamp: false,\n            tickMethod: d3Time,\n            interpolate: createInterpolateNumber,\n            mask: undefined,\n            utc: false,\n        };\n    }\n    chooseTransforms() {\n        const transform = (x) => +x;\n        const untransform = (x) => new Date(x);\n        return [transform, untransform];\n    }\n    chooseNice() {\n        return d3TimeNice;\n    }\n    getTickMethodOptions() {\n        const { domain, tickCount, tickInterval, utc } = this.options;\n        const min = domain[0];\n        const max = domain[domain.length - 1];\n        return [min, max, tickCount, tickInterval, utc];\n    }\n    getFormatter() {\n        const { mask, utc } = this.options;\n        const maskMap = utc ? utcIntervalMap : localIntervalMap;\n        const time = utc ? offset : identity; // fecha 不支持 utc 格式化，所以需要设置一个偏移\n        return (d) => format(time(d), mask || chooseNiceTimeMask(d, maskMap));\n    }\n    clone() {\n        return new Time(this.options);\n    }\n}\n//# sourceMappingURL=time.js.map"],"names":["offset","date","minuteOffset","d","Time","Continuous","d3Time","createInterpolateNumber","x","d3TimeNice","domain","tickCount","tickInterval","utc","min","max","mask","maskMap","utcIntervalMap","localIntervalMap","time","identity","format","chooseNiceTimeMask"],"mappings":";;;;;;;;;AAKA,SAASA,EAAOC,GAAM;AAClB,QAAMC,IAAeD,EAAK,kBAAiB,GACrCE,IAAI,IAAI,KAAKF,CAAI;AACvB,SAAAE,EAAE,WAAWA,EAAE,eAAeD,GAAcC,EAAE,WAAU,GAAIA,EAAE,iBAAiB,GACxEA;AACX;AACO,MAAMC,UAAaC,EAAW;AAAA,EACjC,oBAAoB;AAChB,WAAO;AAAA,MACH,QAAQ,CAAC,IAAI,KAAK,KAAM,GAAG,CAAC,GAAG,IAAI,KAAK,KAAM,GAAG,CAAC,CAAC;AAAA,MACnD,OAAO,CAAC,GAAG,CAAC;AAAA,MACZ,MAAM;AAAA,MACN,WAAW;AAAA,MACX,cAAc;AAAA,MACd,SAAS;AAAA,MACT,OAAO;AAAA,MACP,YAAYC;AAAA,MACZ,aAAaC;AAAA,MACb,MAAM;AAAA,MACN,KAAK;AAAA,IACjB;AAAA,EACI;AAAA,EACA,mBAAmB;AAGf,WAAO,CAFW,CAACC,MAAM,CAACA,GACN,CAACA,MAAM,IAAI,KAAKA,CAAC,CACP;AAAA,EAClC;AAAA,EACA,aAAa;AACT,WAAOC;AAAA,EACX;AAAA,EACA,uBAAuB;AACnB,UAAM,EAAE,QAAAC,GAAQ,WAAAC,GAAW,cAAAC,GAAc,KAAAC,EAAG,IAAK,KAAK,SAChDC,IAAMJ,EAAO,CAAC,GACdK,IAAML,EAAOA,EAAO,SAAS,CAAC;AACpC,WAAO,CAACI,GAAKC,GAAKJ,GAAWC,GAAcC,CAAG;AAAA,EAClD;AAAA,EACA,eAAe;AACX,UAAM,EAAE,MAAAG,GAAM,KAAAH,EAAG,IAAK,KAAK,SACrBI,IAAUJ,IAAMK,IAAiBC,GACjCC,IAAOP,IAAMb,IAASqB;AAC5B,WAAO,CAAClB,MAAMmB,EAAOF,EAAKjB,CAAC,GAAGa,KAAQO,EAAmBpB,GAAGc,CAAO,CAAC;AAAA,EACxE;AAAA,EACA,QAAQ;AACJ,WAAO,IAAIb,EAAK,KAAK,OAAO;AAAA,EAChC;AACJ;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/scale/esm/tick-methods/d3-log.js

@@ -0,0 +1,37 @@
+import { d3Ticks as d } from "./d3-ticks.js";
+import { logs as M, pows as w } from "../utils/log.js";
+const v = (l, m, e, f = 10) => {
+  const h = l < 0, k = w(f, h), g = M(f, h), u = m < l, n = u ? m : l, p = u ? l : m;
+  let o = g(n), t = g(p), s = [];
+  if (!(f % 1) && t - o < e) {
+    if (o = Math.floor(o), t = Math.ceil(t), h)
+      for (; o <= t; o += 1) {
+        const i = k(o);
+        for (let c = f - 1; c >= 1; c -= 1) {
+          const r = i * c;
+          if (r > p)
+            break;
+          r >= n && s.push(r);
+        }
+      }
+    else
+      for (; o <= t; o += 1) {
+        const i = k(o);
+        for (let c = 1; c < f; c += 1) {
+          const r = i * c;
+          if (r > p)
+            break;
+          r >= n && s.push(r);
+        }
+      }
+    s.length * 2 < e && (s = d(n, p, e));
+  } else {
+    const i = e === -1 ? t - o : Math.min(t - o, e);
+    s = d(o, t, i).map(k);
+  }
+  return u ? s.reverse() : s;
+};
+export {
+  v as d3Log
+};
+//# sourceMappingURL=d3-log.js.map

package/dist/node_modules/@antv/scale/esm/tick-methods/d3-log.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"d3-log.js","sources":["../../../../../../node_modules/@antv/scale/esm/tick-methods/d3-log.js"],"sourcesContent":["import { d3Ticks } from './d3-ticks';\nimport { pows, logs } from '../utils';\nexport const d3Log = (a, b, n, base = 10) => {\n    const shouldReflect = a < 0;\n    const pow = pows(base, shouldReflect);\n    const log = logs(base, shouldReflect);\n    const r = b < a;\n    const min = r ? b : a;\n    const max = r ? a : b;\n    let i = log(min);\n    let j = log(max);\n    let ticks = [];\n    // 如果 base 是整数\n    if (!(base % 1) && j - i < n) {\n        i = Math.floor(i);\n        j = Math.ceil(j);\n        if (shouldReflect) {\n            for (; i <= j; i += 1) {\n                const p = pow(i);\n                for (let k = base - 1; k >= 1; k -= 1) {\n                    const t = p * k;\n                    if (t > max)\n                        break;\n                    if (t >= min)\n                        ticks.push(t);\n                }\n            }\n        }\n        else {\n            for (; i <= j; i += 1) {\n                const p = pow(i);\n                for (let k = 1; k < base; k += 1) {\n                    const t = p * k;\n                    if (t > max)\n                        break;\n                    if (t >= min)\n                        ticks.push(t);\n                }\n            }\n        }\n        if (ticks.length * 2 < n)\n            ticks = d3Ticks(min, max, n);\n    }\n    else {\n        const count = n === -1 ? j - i : Math.min(j - i, n);\n        ticks = d3Ticks(i, j, count).map(pow);\n    }\n    return r ? ticks.reverse() : ticks;\n};\n//# sourceMappingURL=d3-log.js.map"],"names":["d3Log","a","b","n","base","shouldReflect","pow","pows","log","logs","r","min","max","i","j","ticks","p","k","t","d3Ticks","count"],"mappings":";;AAEY,MAACA,IAAQ,CAACC,GAAGC,GAAGC,GAAGC,IAAO,OAAO;AACzC,QAAMC,IAAgBJ,IAAI,GACpBK,IAAMC,EAAKH,GAAMC,CAAa,GAC9BG,IAAMC,EAAKL,GAAMC,CAAa,GAC9BK,IAAIR,IAAID,GACRU,IAAMD,IAAIR,IAAID,GACdW,IAAMF,IAAIT,IAAIC;AACpB,MAAIW,IAAIL,EAAIG,CAAG,GACXG,IAAIN,EAAII,CAAG,GACXG,IAAQ,CAAA;AAEZ,MAAI,EAAEX,IAAO,MAAMU,IAAID,IAAIV,GAAG;AAG1B,QAFAU,IAAI,KAAK,MAAMA,CAAC,GAChBC,IAAI,KAAK,KAAKA,CAAC,GACXT;AACA,aAAOQ,KAAKC,GAAGD,KAAK,GAAG;AACnB,cAAMG,IAAIV,EAAIO,CAAC;AACf,iBAASI,IAAIb,IAAO,GAAGa,KAAK,GAAGA,KAAK,GAAG;AACnC,gBAAMC,IAAIF,IAAIC;AACd,cAAIC,IAAIN;AACJ;AACJ,UAAIM,KAAKP,KACLI,EAAM,KAAKG,CAAC;AAAA,QACpB;AAAA,MACJ;AAAA;AAGA,aAAOL,KAAKC,GAAGD,KAAK,GAAG;AACnB,cAAMG,IAAIV,EAAIO,CAAC;AACf,iBAASI,IAAI,GAAGA,IAAIb,GAAMa,KAAK,GAAG;AAC9B,gBAAMC,IAAIF,IAAIC;AACd,cAAIC,IAAIN;AACJ;AACJ,UAAIM,KAAKP,KACLI,EAAM,KAAKG,CAAC;AAAA,QACpB;AAAA,MACJ;AAEJ,IAAIH,EAAM,SAAS,IAAIZ,MACnBY,IAAQI,EAAQR,GAAKC,GAAKT,CAAC;AAAA,EACnC,OACK;AACD,UAAMiB,IAAQjB,MAAM,KAAKW,IAAID,IAAI,KAAK,IAAIC,IAAID,GAAGV,CAAC;AAClD,IAAAY,IAAQI,EAAQN,GAAGC,GAAGM,CAAK,EAAE,IAAId,CAAG;AAAA,EACxC;AACA,SAAOI,IAAIK,EAAM,QAAO,IAAKA;AACjC;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/scale/esm/tick-methods/d3-ticks.js

@@ -0,0 +1,29 @@
+import { tickIncrement as a } from "../utils/ticks.js";
+const u = (s, o) => {
+  if (!(o != null && o.length))
+    return s;
+  const c = [...s, ...o.flatMap((e) => [e.start, e.end])], l = Array.from(new Set(c)).sort((e, t) => e - t).filter((e) => !o.some(({ start: t, end: i }) => e > t && e < i));
+  return l.length ? l : s;
+}, h = (s, o, c, f) => {
+  let l, e, t = s, i = o;
+  if (t === i && c > 0)
+    return [t];
+  let r = a(t, i, c);
+  if (r === 0 || !Number.isFinite(r))
+    return [];
+  if (r > 0) {
+    t = Math.ceil(t / r), i = Math.floor(i / r), e = new Array(l = Math.ceil(i - t + 1));
+    for (let n = 0; n < l; n += 1)
+      e[n] = (t + n) * r;
+  } else {
+    r = -r, t = Math.ceil(t * r), i = Math.floor(i * r), e = new Array(l = Math.ceil(i - t + 1));
+    for (let n = 0; n < l; n += 1)
+      e[n] = (t + n) / r;
+  }
+  return u(e, f);
+};
+export {
+  h as d3Ticks,
+  u as insertBreaksToTicks
+};
+//# sourceMappingURL=d3-ticks.js.map

package/dist/node_modules/@antv/scale/esm/tick-methods/d3-ticks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"d3-ticks.js","sources":["../../../../../../node_modules/@antv/scale/esm/tick-methods/d3-ticks.js"],"sourcesContent":["import { tickIncrement } from '../utils';\n/**\n *  Insert breaks into ticks and delete the ticks covered by breaks.\n */\nexport const insertBreaksToTicks = (ticks, breaks) => {\n    if (!(breaks === null || breaks === void 0 ? void 0 : breaks.length))\n        return ticks;\n    const edgePoints = [...ticks, ...breaks.flatMap((b) => [b.start, b.end])];\n    const uniqueSortedTicks = Array.from(new Set(edgePoints)).sort((a, b) => a - b);\n    const filteredTicks = uniqueSortedTicks.filter((tick) => !breaks.some(({ start, end }) => tick > start && tick < end));\n    return filteredTicks.length ? filteredTicks : ticks;\n};\nexport const d3Ticks = (begin, end, count, breaks) => {\n    let n;\n    let ticks;\n    let start = begin;\n    let stop = end;\n    if (start === stop && count > 0) {\n        return [start];\n    }\n    let step = tickIncrement(start, stop, count);\n    if (step === 0 || !Number.isFinite(step)) {\n        return [];\n    }\n    if (step > 0) {\n        start = Math.ceil(start / step);\n        stop = Math.floor(stop / step);\n        ticks = new Array((n = Math.ceil(stop - start + 1)));\n        for (let i = 0; i < n; i += 1) {\n            ticks[i] = (start + i) * step;\n        }\n    }\n    else {\n        step = -step;\n        start = Math.ceil(start * step);\n        stop = Math.floor(stop * step);\n        ticks = new Array((n = Math.ceil(stop - start + 1)));\n        for (let i = 0; i < n; i += 1) {\n            ticks[i] = (start + i) / step;\n        }\n    }\n    return insertBreaksToTicks(ticks, breaks);\n};\n//# sourceMappingURL=d3-ticks.js.map"],"names":["insertBreaksToTicks","ticks","breaks","edgePoints","b","filteredTicks","a","tick","start","end","d3Ticks","begin","count","n","stop","step","tickIncrement","i"],"mappings":";AAIY,MAACA,IAAsB,CAACC,GAAOC,MAAW;AAClD,MAAI,EAAEA,KAAW,QAAqCA,EAAO;AACzD,WAAOD;AACX,QAAME,IAAa,CAAC,GAAGF,GAAO,GAAGC,EAAO,QAAQ,CAACE,MAAM,CAACA,EAAE,OAAOA,EAAE,GAAG,CAAC,CAAC,GAElEC,IADoB,MAAM,KAAK,IAAI,IAAIF,CAAU,CAAC,EAAE,KAAK,CAACG,GAAGF,MAAME,IAAIF,CAAC,EACtC,OAAO,CAACG,MAAS,CAACL,EAAO,KAAK,CAAC,EAAE,OAAAM,GAAO,KAAAC,EAAG,MAAOF,IAAOC,KAASD,IAAOE,CAAG,CAAC;AACrH,SAAOJ,EAAc,SAASA,IAAgBJ;AAClD,GACaS,IAAU,CAACC,GAAOF,GAAKG,GAAOV,MAAW;AAClD,MAAIW,GACAZ,GACAO,IAAQG,GACRG,IAAOL;AACX,MAAID,MAAUM,KAAQF,IAAQ;AAC1B,WAAO,CAACJ,CAAK;AAEjB,MAAIO,IAAOC,EAAcR,GAAOM,GAAMF,CAAK;AAC3C,MAAIG,MAAS,KAAK,CAAC,OAAO,SAASA,CAAI;AACnC,WAAO,CAAA;AAEX,MAAIA,IAAO,GAAG;AACV,IAAAP,IAAQ,KAAK,KAAKA,IAAQO,CAAI,GAC9BD,IAAO,KAAK,MAAMA,IAAOC,CAAI,GAC7Bd,IAAQ,IAAI,MAAOY,IAAI,KAAK,KAAKC,IAAON,IAAQ,CAAC,CAAC;AAClD,aAASS,IAAI,GAAGA,IAAIJ,GAAGI,KAAK;AACxB,MAAAhB,EAAMgB,CAAC,KAAKT,IAAQS,KAAKF;AAAA,EAEjC,OACK;AACD,IAAAA,IAAO,CAACA,GACRP,IAAQ,KAAK,KAAKA,IAAQO,CAAI,GAC9BD,IAAO,KAAK,MAAMA,IAAOC,CAAI,GAC7Bd,IAAQ,IAAI,MAAOY,IAAI,KAAK,KAAKC,IAAON,IAAQ,CAAC,CAAC;AAClD,aAASS,IAAI,GAAGA,IAAIJ,GAAGI,KAAK;AACxB,MAAAhB,EAAMgB,CAAC,KAAKT,IAAQS,KAAKF;AAAA,EAEjC;AACA,SAAOf,EAAoBC,GAAOC,CAAM;AAC5C;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/scale/esm/tick-methods/d3-time.js

@@ -0,0 +1,9 @@
+import { findTickInterval as v } from "../utils/find-tick-interval.js";
+const d = (t, e, s, i, k) => {
+  const r = t > e, n = r ? e : t, o = r ? t : e, [l, p] = v(n, o, s, i, k), c = l.range(n, /* @__PURE__ */ new Date(+o + 1), p, !0);
+  return r ? c.reverse() : c;
+};
+export {
+  d as d3Time
+};
+//# sourceMappingURL=d3-time.js.map

package/dist/node_modules/@antv/scale/esm/tick-methods/d3-time.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"d3-time.js","sources":["../../../../../../node_modules/@antv/scale/esm/tick-methods/d3-time.js"],"sourcesContent":["import { findTickInterval } from '../utils';\nexport const d3Time = (min, max, count, interval, utc) => {\n    const r = min > max;\n    const lo = r ? max : min;\n    const hi = r ? min : max;\n    const [tickInterval, step] = findTickInterval(lo, hi, count, interval, utc);\n    const ticks = tickInterval.range(lo, new Date(+hi + 1), step, true);\n    return r ? ticks.reverse() : ticks;\n};\n//# sourceMappingURL=d3-time.js.map"],"names":["d3Time","min","max","count","interval","utc","lo","hi","tickInterval","step","findTickInterval","ticks"],"mappings":";AACY,MAACA,IAAS,CAACC,GAAKC,GAAKC,GAAOC,GAAUC,MAAQ;AACtD,QAAM,IAAIJ,IAAMC,GACVI,IAAK,IAAIJ,IAAMD,GACfM,IAAK,IAAIN,IAAMC,GACf,CAACM,GAAcC,CAAI,IAAIC,EAAiBJ,GAAIC,GAAIJ,GAAOC,GAAUC,CAAG,GACpEM,IAAQH,EAAa,MAAMF,GAAI,oBAAI,KAAK,CAACC,IAAK,CAAC,GAAGE,GAAM,EAAI;AAClE,SAAO,IAAIE,EAAM,QAAO,IAAKA;AACjC;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/scale/esm/tick-methods/wilkinson-extended.js

@@ -0,0 +1,95 @@
+import { prettyNumber as p } from "../utils/pretty-number.js";
+import q from "../../../util/esm/lodash/size.js";
+import C from "../../../util/esm/lodash/index-of.js";
+const G = [1, 5, 2, 2.5, 4, 3], j = Number.EPSILON * 100;
+function H(n, t) {
+  return (n % t + t) % t;
+}
+function J(n) {
+  return Math.round(n * 1e12) / 1e12;
+}
+function K(n, t, s, r, i, o) {
+  const f = q(t), e = C(t, n);
+  let c = 0;
+  const y = H(r, o);
+  return (y < j || o - y < j) && r <= 0 && i >= 0 && (c = 1), 1 - e / (f - 1) - s + c;
+}
+function R(n, t, s) {
+  const r = q(t);
+  return 1 - C(t, n) / (r - 1) - s + 1;
+}
+function V(n, t, s, r, i, o) {
+  const f = (n - 1) / (o - i), e = (t - 1) / (Math.max(o, r) - Math.min(s, i));
+  return 2 - Math.max(f / e, e / f);
+}
+function W(n, t) {
+  return n >= t ? 2 - (n - 1) / (t - 1) : 1;
+}
+function X(n, t, s, r) {
+  const i = t - n;
+  return 1 - 0.5 * ((t - r) ** 2 + (n - s) ** 2) / (0.1 * i) ** 2;
+}
+function Y(n, t, s) {
+  const r = t - n;
+  return s > r ? 1 - ((s - r) / 2) ** 2 / (0.1 * r) ** 2 : 1;
+}
+function Z() {
+  return 1;
+}
+const w = (n, t, s = 5, r = !0, i = G, o = [0.25, 0.2, 0.5, 0.05]) => {
+  const f = s < 0 ? 0 : Math.round(s);
+  if (Number.isNaN(n) || Number.isNaN(t) || typeof n != "number" || typeof t != "number" || !f)
+    return [];
+  if (t - n < 1e-15 || f === 1)
+    return [n];
+  const e = {
+    score: -2,
+    lmin: 0,
+    lmax: 0,
+    lstep: 0
+  };
+  let c = 1;
+  for (; c < 1 / 0; ) {
+    for (let l = 0; l < i.length; l += 1) {
+      const N = i[l], g = R(N, i, c);
+      if (o[0] * g + o[1] + o[2] + o[3] < e.score) {
+        c = 1 / 0;
+        break;
+      }
+      let u = 2;
+      for (; u < 1 / 0; ) {
+        const z = W(u, f);
+        if (o[0] * g + o[1] + o[2] * z + o[3] < e.score)
+          break;
+        const D = (t - n) / (u + 1) / c / N;
+        let k = Math.ceil(Math.log10(D));
+        for (; k < 1 / 0; ) {
+          const m = c * N * 10 ** k, F = Y(n, t, m * (u - 1));
+          if (o[0] * g + o[1] * F + o[2] * z + o[3] < e.score)
+            break;
+          const v = Math.floor(t / m) * c - (u - 1) * c, A = Math.ceil(n / m) * c;
+          if (v <= A) {
+            const P = A - v;
+            for (let I = 0; I <= P; I += 1) {
+              const a = (v + I) * (m / c), h = a + m * (u - 1), L = m, T = K(N, i, c, a, h, L), U = X(n, t, a, h), _ = V(u, f, n, t, a, h), B = Z(), O = o[0] * T + o[1] * U + o[2] * _ + o[3] * B;
+              O > e.score && (!r || a <= n && h >= t) && (e.lmin = a, e.lmax = h, e.lstep = L, e.score = O);
+            }
+          }
+          k += 1;
+        }
+        u += 1;
+      }
+    }
+    c += 1;
+  }
+  const y = p(e.lmax), x = p(e.lmin), S = p(e.lstep), E = Math.floor(J((y - x) / S)) + 1, b = new Array(E);
+  b[0] = p(x);
+  for (let l = 1; l < E; l += 1)
+    b[l] = p(b[l - 1] + S);
+  return b;
+};
+export {
+  G as DEFAULT_Q,
+  w as wilkinsonExtended
+};
+//# sourceMappingURL=wilkinson-extended.js.map