palettecn 0.1.0

package/dist/web/server/_libs/d3-scale+[...].mjs

@@ -0,0 +1,1907 @@
+import { a as tickStep, c as bisector, i as tickIncrement, l as ascending, n as quantile$1, o as ticks, r as quantileSorted, s as bisectRight, t as range } from "./d3-array.mjs";
+import { i as number_default, n as round_default, r as value_default, t as piecewise } from "./d3-interpolate.mjs";
+import { a as formatPrefix, i as format, n as precisionPrefix_default, o as formatSpecifier, r as precisionFixed_default, t as precisionRound_default } from "./d3-format.mjs";
+//#region ../../node_modules/.pnpm/internmap@2.0.3/node_modules/internmap/src/index.js
+var InternMap = class extends Map {
+	constructor(entries, key = keyof) {
+		super();
+		Object.defineProperties(this, {
+			_intern: { value: /* @__PURE__ */ new Map() },
+			_key: { value: key }
+		});
+		if (entries != null) for (const [key, value] of entries) this.set(key, value);
+	}
+	get(key) {
+		return super.get(intern_get(this, key));
+	}
+	has(key) {
+		return super.has(intern_get(this, key));
+	}
+	set(key, value) {
+		return super.set(intern_set(this, key), value);
+	}
+	delete(key) {
+		return super.delete(intern_delete(this, key));
+	}
+};
+function intern_get({ _intern, _key }, value) {
+	const key = _key(value);
+	return _intern.has(key) ? _intern.get(key) : value;
+}
+function intern_set({ _intern, _key }, value) {
+	const key = _key(value);
+	if (_intern.has(key)) return _intern.get(key);
+	_intern.set(key, value);
+	return value;
+}
+function intern_delete({ _intern, _key }, value) {
+	const key = _key(value);
+	if (_intern.has(key)) {
+		value = _intern.get(key);
+		_intern.delete(key);
+	}
+	return value;
+}
+function keyof(value) {
+	return value !== null && typeof value === "object" ? value.valueOf() : value;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/init.js
+function initRange(domain, range) {
+	switch (arguments.length) {
+		case 0: break;
+		case 1:
+			this.range(domain);
+			break;
+		default:
+			this.range(range).domain(domain);
+			break;
+	}
+	return this;
+}
+function initInterpolator(domain, interpolator) {
+	switch (arguments.length) {
+		case 0: break;
+		case 1:
+			if (typeof domain === "function") this.interpolator(domain);
+			else this.range(domain);
+			break;
+		default:
+			this.domain(domain);
+			if (typeof interpolator === "function") this.interpolator(interpolator);
+			else this.range(interpolator);
+			break;
+	}
+	return this;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/ordinal.js
+var implicit = Symbol("implicit");
+function ordinal() {
+	var index = new InternMap(), domain = [], range = [], unknown = implicit;
+	function scale(d) {
+		let i = index.get(d);
+		if (i === void 0) {
+			if (unknown !== implicit) return unknown;
+			index.set(d, i = domain.push(d) - 1);
+		}
+		return range[i % range.length];
+	}
+	scale.domain = function(_) {
+		if (!arguments.length) return domain.slice();
+		domain = [], index = new InternMap();
+		for (const value of _) {
+			if (index.has(value)) continue;
+			index.set(value, domain.push(value) - 1);
+		}
+		return scale;
+	};
+	scale.range = function(_) {
+		return arguments.length ? (range = Array.from(_), scale) : range.slice();
+	};
+	scale.unknown = function(_) {
+		return arguments.length ? (unknown = _, scale) : unknown;
+	};
+	scale.copy = function() {
+		return ordinal(domain, range).unknown(unknown);
+	};
+	initRange.apply(scale, arguments);
+	return scale;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/band.js
+function band() {
+	var scale = ordinal().unknown(void 0), domain = scale.domain, ordinalRange = scale.range, r0 = 0, r1 = 1, step, bandwidth, round = false, paddingInner = 0, paddingOuter = 0, align = .5;
+	delete scale.unknown;
+	function rescale() {
+		var n = domain().length, reverse = r1 < r0, start = reverse ? r1 : r0, stop = reverse ? r0 : r1;
+		step = (stop - start) / Math.max(1, n - paddingInner + paddingOuter * 2);
+		if (round) step = Math.floor(step);
+		start += (stop - start - step * (n - paddingInner)) * align;
+		bandwidth = step * (1 - paddingInner);
+		if (round) start = Math.round(start), bandwidth = Math.round(bandwidth);
+		var values = range(n).map(function(i) {
+			return start + step * i;
+		});
+		return ordinalRange(reverse ? values.reverse() : values);
+	}
+	scale.domain = function(_) {
+		return arguments.length ? (domain(_), rescale()) : domain();
+	};
+	scale.range = function(_) {
+		return arguments.length ? ([r0, r1] = _, r0 = +r0, r1 = +r1, rescale()) : [r0, r1];
+	};
+	scale.rangeRound = function(_) {
+		return [r0, r1] = _, r0 = +r0, r1 = +r1, round = true, rescale();
+	};
+	scale.bandwidth = function() {
+		return bandwidth;
+	};
+	scale.step = function() {
+		return step;
+	};
+	scale.round = function(_) {
+		return arguments.length ? (round = !!_, rescale()) : round;
+	};
+	scale.padding = function(_) {
+		return arguments.length ? (paddingInner = Math.min(1, paddingOuter = +_), rescale()) : paddingInner;
+	};
+	scale.paddingInner = function(_) {
+		return arguments.length ? (paddingInner = Math.min(1, _), rescale()) : paddingInner;
+	};
+	scale.paddingOuter = function(_) {
+		return arguments.length ? (paddingOuter = +_, rescale()) : paddingOuter;
+	};
+	scale.align = function(_) {
+		return arguments.length ? (align = Math.max(0, Math.min(1, _)), rescale()) : align;
+	};
+	scale.copy = function() {
+		return band(domain(), [r0, r1]).round(round).paddingInner(paddingInner).paddingOuter(paddingOuter).align(align);
+	};
+	return initRange.apply(rescale(), arguments);
+}
+function pointish(scale) {
+	var copy = scale.copy;
+	scale.padding = scale.paddingOuter;
+	delete scale.paddingInner;
+	delete scale.paddingOuter;
+	scale.copy = function() {
+		return pointish(copy());
+	};
+	return scale;
+}
+function point() {
+	return pointish(band.apply(null, arguments).paddingInner(1));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/constant.js
+function constants(x) {
+	return function() {
+		return x;
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/number.js
+function number$1(x) {
+	return +x;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/continuous.js
+var unit = [0, 1];
+function identity$1(x) {
+	return x;
+}
+function normalize(a, b) {
+	return (b -= a = +a) ? function(x) {
+		return (x - a) / b;
+	} : constants(isNaN(b) ? NaN : .5);
+}
+function clamper(a, b) {
+	var t;
+	if (a > b) t = a, a = b, b = t;
+	return function(x) {
+		return Math.max(a, Math.min(b, x));
+	};
+}
+function bimap(domain, range, interpolate) {
+	var d0 = domain[0], d1 = domain[1], r0 = range[0], r1 = range[1];
+	if (d1 < d0) d0 = normalize(d1, d0), r0 = interpolate(r1, r0);
+	else d0 = normalize(d0, d1), r0 = interpolate(r0, r1);
+	return function(x) {
+		return r0(d0(x));
+	};
+}
+function polymap(domain, range, interpolate) {
+	var j = Math.min(domain.length, range.length) - 1, d = new Array(j), r = new Array(j), i = -1;
+	if (domain[j] < domain[0]) {
+		domain = domain.slice().reverse();
+		range = range.slice().reverse();
+	}
+	while (++i < j) {
+		d[i] = normalize(domain[i], domain[i + 1]);
+		r[i] = interpolate(range[i], range[i + 1]);
+	}
+	return function(x) {
+		var i = bisectRight(domain, x, 1, j) - 1;
+		return r[i](d[i](x));
+	};
+}
+function copy$1(source, target) {
+	return target.domain(source.domain()).range(source.range()).interpolate(source.interpolate()).clamp(source.clamp()).unknown(source.unknown());
+}
+function transformer$2() {
+	var domain = unit, range = unit, interpolate = value_default, transform, untransform, unknown, clamp = identity$1, piecewise, output, input;
+	function rescale() {
+		var n = Math.min(domain.length, range.length);
+		if (clamp !== identity$1) clamp = clamper(domain[0], domain[n - 1]);
+		piecewise = n > 2 ? polymap : bimap;
+		output = input = null;
+		return scale;
+	}
+	function scale(x) {
+		return x == null || isNaN(x = +x) ? unknown : (output || (output = piecewise(domain.map(transform), range, interpolate)))(transform(clamp(x)));
+	}
+	scale.invert = function(y) {
+		return clamp(untransform((input || (input = piecewise(range, domain.map(transform), number_default)))(y)));
+	};
+	scale.domain = function(_) {
+		return arguments.length ? (domain = Array.from(_, number$1), rescale()) : domain.slice();
+	};
+	scale.range = function(_) {
+		return arguments.length ? (range = Array.from(_), rescale()) : range.slice();
+	};
+	scale.rangeRound = function(_) {
+		return range = Array.from(_), interpolate = round_default, rescale();
+	};
+	scale.clamp = function(_) {
+		return arguments.length ? (clamp = _ ? true : identity$1, rescale()) : clamp !== identity$1;
+	};
+	scale.interpolate = function(_) {
+		return arguments.length ? (interpolate = _, rescale()) : interpolate;
+	};
+	scale.unknown = function(_) {
+		return arguments.length ? (unknown = _, scale) : unknown;
+	};
+	return function(t, u) {
+		transform = t, untransform = u;
+		return rescale();
+	};
+}
+function continuous() {
+	return transformer$2()(identity$1, identity$1);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/tickFormat.js
+function tickFormat(start, stop, count, specifier) {
+	var step = tickStep(start, stop, count), precision;
+	specifier = formatSpecifier(specifier == null ? ",f" : specifier);
+	switch (specifier.type) {
+		case "s":
+			var value = Math.max(Math.abs(start), Math.abs(stop));
+			if (specifier.precision == null && !isNaN(precision = precisionPrefix_default(step, value))) specifier.precision = precision;
+			return formatPrefix(specifier, value);
+		case "":
+		case "e":
+		case "g":
+		case "p":
+		case "r":
+			if (specifier.precision == null && !isNaN(precision = precisionRound_default(step, Math.max(Math.abs(start), Math.abs(stop))))) specifier.precision = precision - (specifier.type === "e");
+			break;
+		case "f":
+		case "%":
+			if (specifier.precision == null && !isNaN(precision = precisionFixed_default(step))) specifier.precision = precision - (specifier.type === "%") * 2;
+			break;
+	}
+	return format(specifier);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/linear.js
+function linearish(scale) {
+	var domain = scale.domain;
+	scale.ticks = function(count) {
+		var d = domain();
+		return ticks(d[0], d[d.length - 1], count == null ? 10 : count);
+	};
+	scale.tickFormat = function(count, specifier) {
+		var d = domain();
+		return tickFormat(d[0], d[d.length - 1], count == null ? 10 : count, specifier);
+	};
+	scale.nice = function(count) {
+		if (count == null) count = 10;
+		var d = domain();
+		var i0 = 0;
+		var i1 = d.length - 1;
+		var start = d[i0];
+		var stop = d[i1];
+		var prestep;
+		var step;
+		var maxIter = 10;
+		if (stop < start) {
+			step = start, start = stop, stop = step;
+			step = i0, i0 = i1, i1 = step;
+		}
+		while (maxIter-- > 0) {
+			step = tickIncrement(start, stop, count);
+			if (step === prestep) {
+				d[i0] = start;
+				d[i1] = stop;
+				return domain(d);
+			} else if (step > 0) {
+				start = Math.floor(start / step) * step;
+				stop = Math.ceil(stop / step) * step;
+			} else if (step < 0) {
+				start = Math.ceil(start * step) / step;
+				stop = Math.floor(stop * step) / step;
+			} else break;
+			prestep = step;
+		}
+		return scale;
+	};
+	return scale;
+}
+function linear() {
+	var scale = continuous();
+	scale.copy = function() {
+		return copy$1(scale, linear());
+	};
+	initRange.apply(scale, arguments);
+	return linearish(scale);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/identity.js
+function identity(domain) {
+	var unknown;
+	function scale(x) {
+		return x == null || isNaN(x = +x) ? unknown : x;
+	}
+	scale.invert = scale;
+	scale.domain = scale.range = function(_) {
+		return arguments.length ? (domain = Array.from(_, number$1), scale) : domain.slice();
+	};
+	scale.unknown = function(_) {
+		return arguments.length ? (unknown = _, scale) : unknown;
+	};
+	scale.copy = function() {
+		return identity(domain).unknown(unknown);
+	};
+	domain = arguments.length ? Array.from(domain, number$1) : [0, 1];
+	return linearish(scale);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/nice.js
+function nice(domain, interval) {
+	domain = domain.slice();
+	var i0 = 0, i1 = domain.length - 1, x0 = domain[i0], x1 = domain[i1], t;
+	if (x1 < x0) {
+		t = i0, i0 = i1, i1 = t;
+		t = x0, x0 = x1, x1 = t;
+	}
+	domain[i0] = interval.floor(x0);
+	domain[i1] = interval.ceil(x1);
+	return domain;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/log.js
+function transformLog(x) {
+	return Math.log(x);
+}
+function transformExp(x) {
+	return Math.exp(x);
+}
+function transformLogn(x) {
+	return -Math.log(-x);
+}
+function transformExpn(x) {
+	return -Math.exp(-x);
+}
+function pow10(x) {
+	return isFinite(x) ? +("1e" + x) : x < 0 ? 0 : x;
+}
+function powp(base) {
+	return base === 10 ? pow10 : base === Math.E ? Math.exp : (x) => Math.pow(base, x);
+}
+function logp(base) {
+	return base === Math.E ? Math.log : base === 10 && Math.log10 || base === 2 && Math.log2 || (base = Math.log(base), (x) => Math.log(x) / base);
+}
+function reflect(f) {
+	return (x, k) => -f(-x, k);
+}
+function loggish(transform) {
+	const scale = transform(transformLog, transformExp);
+	const domain = scale.domain;
+	let base = 10;
+	let logs;
+	let pows;
+	function rescale() {
+		logs = logp(base), pows = powp(base);
+		if (domain()[0] < 0) {
+			logs = reflect(logs), pows = reflect(pows);
+			transform(transformLogn, transformExpn);
+		} else transform(transformLog, transformExp);
+		return scale;
+	}
+	scale.base = function(_) {
+		return arguments.length ? (base = +_, rescale()) : base;
+	};
+	scale.domain = function(_) {
+		return arguments.length ? (domain(_), rescale()) : domain();
+	};
+	scale.ticks = (count) => {
+		const d = domain();
+		let u = d[0];
+		let v = d[d.length - 1];
+		const r = v < u;
+		if (r) [u, v] = [v, u];
+		let i = logs(u);
+		let j = logs(v);
+		let k;
+		let t;
+		const n = count == null ? 10 : +count;
+		let z = [];
+		if (!(base % 1) && j - i < n) {
+			i = Math.floor(i), j = Math.ceil(j);
+			if (u > 0) for (; i <= j; ++i) for (k = 1; k < base; ++k) {
+				t = i < 0 ? k / pows(-i) : k * pows(i);
+				if (t < u) continue;
+				if (t > v) break;
+				z.push(t);
+			}
+			else for (; i <= j; ++i) for (k = base - 1; k >= 1; --k) {
+				t = i > 0 ? k / pows(-i) : k * pows(i);
+				if (t < u) continue;
+				if (t > v) break;
+				z.push(t);
+			}
+			if (z.length * 2 < n) z = ticks(u, v, n);
+		} else z = ticks(i, j, Math.min(j - i, n)).map(pows);
+		return r ? z.reverse() : z;
+	};
+	scale.tickFormat = (count, specifier) => {
+		if (count == null) count = 10;
+		if (specifier == null) specifier = base === 10 ? "s" : ",";
+		if (typeof specifier !== "function") {
+			if (!(base % 1) && (specifier = formatSpecifier(specifier)).precision == null) specifier.trim = true;
+			specifier = format(specifier);
+		}
+		if (count === Infinity) return specifier;
+		const k = Math.max(1, base * count / scale.ticks().length);
+		return (d) => {
+			let i = d / pows(Math.round(logs(d)));
+			if (i * base < base - .5) i *= base;
+			return i <= k ? specifier(d) : "";
+		};
+	};
+	scale.nice = () => {
+		return domain(nice(domain(), {
+			floor: (x) => pows(Math.floor(logs(x))),
+			ceil: (x) => pows(Math.ceil(logs(x)))
+		}));
+	};
+	return scale;
+}
+function log() {
+	const scale = loggish(transformer$2()).domain([1, 10]);
+	scale.copy = () => copy$1(scale, log()).base(scale.base());
+	initRange.apply(scale, arguments);
+	return scale;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/symlog.js
+function transformSymlog(c) {
+	return function(x) {
+		return Math.sign(x) * Math.log1p(Math.abs(x / c));
+	};
+}
+function transformSymexp(c) {
+	return function(x) {
+		return Math.sign(x) * Math.expm1(Math.abs(x)) * c;
+	};
+}
+function symlogish(transform) {
+	var c = 1, scale = transform(transformSymlog(c), transformSymexp(c));
+	scale.constant = function(_) {
+		return arguments.length ? transform(transformSymlog(c = +_), transformSymexp(c)) : c;
+	};
+	return linearish(scale);
+}
+function symlog() {
+	var scale = symlogish(transformer$2());
+	scale.copy = function() {
+		return copy$1(scale, symlog()).constant(scale.constant());
+	};
+	return initRange.apply(scale, arguments);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/pow.js
+function transformPow(exponent) {
+	return function(x) {
+		return x < 0 ? -Math.pow(-x, exponent) : Math.pow(x, exponent);
+	};
+}
+function transformSqrt(x) {
+	return x < 0 ? -Math.sqrt(-x) : Math.sqrt(x);
+}
+function transformSquare(x) {
+	return x < 0 ? -x * x : x * x;
+}
+function powish(transform) {
+	var scale = transform(identity$1, identity$1), exponent = 1;
+	function rescale() {
+		return exponent === 1 ? transform(identity$1, identity$1) : exponent === .5 ? transform(transformSqrt, transformSquare) : transform(transformPow(exponent), transformPow(1 / exponent));
+	}
+	scale.exponent = function(_) {
+		return arguments.length ? (exponent = +_, rescale()) : exponent;
+	};
+	return linearish(scale);
+}
+function pow() {
+	var scale = powish(transformer$2());
+	scale.copy = function() {
+		return copy$1(scale, pow()).exponent(scale.exponent());
+	};
+	initRange.apply(scale, arguments);
+	return scale;
+}
+function sqrt() {
+	return pow.apply(null, arguments).exponent(.5);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/radial.js
+function square(x) {
+	return Math.sign(x) * x * x;
+}
+function unsquare(x) {
+	return Math.sign(x) * Math.sqrt(Math.abs(x));
+}
+function radial() {
+	var squared = continuous(), range = [0, 1], round = false, unknown;
+	function scale(x) {
+		var y = unsquare(squared(x));
+		return isNaN(y) ? unknown : round ? Math.round(y) : y;
+	}
+	scale.invert = function(y) {
+		return squared.invert(square(y));
+	};
+	scale.domain = function(_) {
+		return arguments.length ? (squared.domain(_), scale) : squared.domain();
+	};
+	scale.range = function(_) {
+		return arguments.length ? (squared.range((range = Array.from(_, number$1)).map(square)), scale) : range.slice();
+	};
+	scale.rangeRound = function(_) {
+		return scale.range(_).round(true);
+	};
+	scale.round = function(_) {
+		return arguments.length ? (round = !!_, scale) : round;
+	};
+	scale.clamp = function(_) {
+		return arguments.length ? (squared.clamp(_), scale) : squared.clamp();
+	};
+	scale.unknown = function(_) {
+		return arguments.length ? (unknown = _, scale) : unknown;
+	};
+	scale.copy = function() {
+		return radial(squared.domain(), range).round(round).clamp(squared.clamp()).unknown(unknown);
+	};
+	initRange.apply(scale, arguments);
+	return linearish(scale);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/quantile.js
+function quantile() {
+	var domain = [], range = [], thresholds = [], unknown;
+	function rescale() {
+		var i = 0, n = Math.max(1, range.length);
+		thresholds = new Array(n - 1);
+		while (++i < n) thresholds[i - 1] = quantileSorted(domain, i / n);
+		return scale;
+	}
+	function scale(x) {
+		return x == null || isNaN(x = +x) ? unknown : range[bisectRight(thresholds, x)];
+	}
+	scale.invertExtent = function(y) {
+		var i = range.indexOf(y);
+		return i < 0 ? [NaN, NaN] : [i > 0 ? thresholds[i - 1] : domain[0], i < thresholds.length ? thresholds[i] : domain[domain.length - 1]];
+	};
+	scale.domain = function(_) {
+		if (!arguments.length) return domain.slice();
+		domain = [];
+		for (let d of _) if (d != null && !isNaN(d = +d)) domain.push(d);
+		domain.sort(ascending);
+		return rescale();
+	};
+	scale.range = function(_) {
+		return arguments.length ? (range = Array.from(_), rescale()) : range.slice();
+	};
+	scale.unknown = function(_) {
+		return arguments.length ? (unknown = _, scale) : unknown;
+	};
+	scale.quantiles = function() {
+		return thresholds.slice();
+	};
+	scale.copy = function() {
+		return quantile().domain(domain).range(range).unknown(unknown);
+	};
+	return initRange.apply(scale, arguments);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/quantize.js
+function quantize() {
+	var x0 = 0, x1 = 1, n = 1, domain = [.5], range = [0, 1], unknown;
+	function scale(x) {
+		return x != null && x <= x ? range[bisectRight(domain, x, 0, n)] : unknown;
+	}
+	function rescale() {
+		var i = -1;
+		domain = new Array(n);
+		while (++i < n) domain[i] = ((i + 1) * x1 - (i - n) * x0) / (n + 1);
+		return scale;
+	}
+	scale.domain = function(_) {
+		return arguments.length ? ([x0, x1] = _, x0 = +x0, x1 = +x1, rescale()) : [x0, x1];
+	};
+	scale.range = function(_) {
+		return arguments.length ? (n = (range = Array.from(_)).length - 1, rescale()) : range.slice();
+	};
+	scale.invertExtent = function(y) {
+		var i = range.indexOf(y);
+		return i < 0 ? [NaN, NaN] : i < 1 ? [x0, domain[0]] : i >= n ? [domain[n - 1], x1] : [domain[i - 1], domain[i]];
+	};
+	scale.unknown = function(_) {
+		return arguments.length ? (unknown = _, scale) : scale;
+	};
+	scale.thresholds = function() {
+		return domain.slice();
+	};
+	scale.copy = function() {
+		return quantize().domain([x0, x1]).range(range).unknown(unknown);
+	};
+	return initRange.apply(linearish(scale), arguments);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/threshold.js
+function threshold() {
+	var domain = [.5], range = [0, 1], unknown, n = 1;
+	function scale(x) {
+		return x != null && x <= x ? range[bisectRight(domain, x, 0, n)] : unknown;
+	}
+	scale.domain = function(_) {
+		return arguments.length ? (domain = Array.from(_), n = Math.min(domain.length, range.length - 1), scale) : domain.slice();
+	};
+	scale.range = function(_) {
+		return arguments.length ? (range = Array.from(_), n = Math.min(domain.length, range.length - 1), scale) : range.slice();
+	};
+	scale.invertExtent = function(y) {
+		var i = range.indexOf(y);
+		return [domain[i - 1], domain[i]];
+	};
+	scale.unknown = function(_) {
+		return arguments.length ? (unknown = _, scale) : unknown;
+	};
+	scale.copy = function() {
+		return threshold().domain(domain).range(range).unknown(unknown);
+	};
+	return initRange.apply(scale, arguments);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-time@3.1.0/node_modules/d3-time/src/interval.js
+var t0 = /* @__PURE__ */ new Date(), t1 = /* @__PURE__ */ new Date();
+function timeInterval(floori, offseti, count, field) {
+	function interval(date) {
+		return floori(date = arguments.length === 0 ? /* @__PURE__ */ new Date() : /* @__PURE__ */ new Date(+date)), date;
+	}
+	interval.floor = (date) => {
+		return floori(date = /* @__PURE__ */ new Date(+date)), date;
+	};
+	interval.ceil = (date) => {
+		return floori(date = /* @__PURE__ */ new Date(date - 1)), offseti(date, 1), floori(date), date;
+	};
+	interval.round = (date) => {
+		const d0 = interval(date), d1 = interval.ceil(date);
+		return date - d0 < d1 - date ? d0 : d1;
+	};
+	interval.offset = (date, step) => {
+		return offseti(date = /* @__PURE__ */ new Date(+date), step == null ? 1 : Math.floor(step)), date;
+	};
+	interval.range = (start, stop, step) => {
+		const range = [];
+		start = interval.ceil(start);
+		step = step == null ? 1 : Math.floor(step);
+		if (!(start < stop) || !(step > 0)) return range;
+		let previous;
+		do
+			range.push(previous = /* @__PURE__ */ new Date(+start)), offseti(start, step), floori(start);
+		while (previous < start && start < stop);
+		return range;
+	};
+	interval.filter = (test) => {
+		return timeInterval((date) => {
+			if (date >= date) while (floori(date), !test(date)) date.setTime(date - 1);
+		}, (date, step) => {
+			if (date >= date) if (step < 0) while (++step <= 0) while (offseti(date, -1), !test(date));
+			else while (--step >= 0) while (offseti(date, 1), !test(date));
+		});
+	};
+	if (count) {
+		interval.count = (start, end) => {
+			t0.setTime(+start), t1.setTime(+end);
+			floori(t0), floori(t1);
+			return Math.floor(count(t0, t1));
+		};
+		interval.every = (step) => {
+			step = Math.floor(step);
+			return !isFinite(step) || !(step > 0) ? null : !(step > 1) ? interval : interval.filter(field ? (d) => field(d) % step === 0 : (d) => interval.count(0, d) % step === 0);
+		};
+	}
+	return interval;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-time@3.1.0/node_modules/d3-time/src/millisecond.js
+var millisecond = timeInterval(() => {}, (date, step) => {
+	date.setTime(+date + step);
+}, (start, end) => {
+	return end - start;
+});
+millisecond.every = (k) => {
+	k = Math.floor(k);
+	if (!isFinite(k) || !(k > 0)) return null;
+	if (!(k > 1)) return millisecond;
+	return timeInterval((date) => {
+		date.setTime(Math.floor(date / k) * k);
+	}, (date, step) => {
+		date.setTime(+date + step * k);
+	}, (start, end) => {
+		return (end - start) / k;
+	});
+};
+millisecond.range;
+//#endregion
+//#region ../../node_modules/.pnpm/d3-time@3.1.0/node_modules/d3-time/src/duration.js
+var durationSecond = 1e3;
+var durationMinute = durationSecond * 60;
+var durationHour = durationMinute * 60;
+var durationDay = durationHour * 24;
+var durationWeek = durationDay * 7;
+var durationMonth = durationDay * 30;
+var durationYear = durationDay * 365;
+//#endregion
+//#region ../../node_modules/.pnpm/d3-time@3.1.0/node_modules/d3-time/src/second.js
+var second = timeInterval((date) => {
+	date.setTime(date - date.getMilliseconds());
+}, (date, step) => {
+	date.setTime(+date + step * durationSecond);
+}, (start, end) => {
+	return (end - start) / durationSecond;
+}, (date) => {
+	return date.getUTCSeconds();
+});
+second.range;
+//#endregion
+//#region ../../node_modules/.pnpm/d3-time@3.1.0/node_modules/d3-time/src/minute.js
+var timeMinute = timeInterval((date) => {
+	date.setTime(date - date.getMilliseconds() - date.getSeconds() * durationSecond);
+}, (date, step) => {
+	date.setTime(+date + step * durationMinute);
+}, (start, end) => {
+	return (end - start) / durationMinute;
+}, (date) => {
+	return date.getMinutes();
+});
+timeMinute.range;
+var utcMinute = timeInterval((date) => {
+	date.setUTCSeconds(0, 0);
+}, (date, step) => {
+	date.setTime(+date + step * durationMinute);
+}, (start, end) => {
+	return (end - start) / durationMinute;
+}, (date) => {
+	return date.getUTCMinutes();
+});
+utcMinute.range;
+//#endregion
+//#region ../../node_modules/.pnpm/d3-time@3.1.0/node_modules/d3-time/src/hour.js
+var timeHour = timeInterval((date) => {
+	date.setTime(date - date.getMilliseconds() - date.getSeconds() * durationSecond - date.getMinutes() * durationMinute);
+}, (date, step) => {
+	date.setTime(+date + step * durationHour);
+}, (start, end) => {
+	return (end - start) / durationHour;
+}, (date) => {
+	return date.getHours();
+});
+timeHour.range;
+var utcHour = timeInterval((date) => {
+	date.setUTCMinutes(0, 0, 0);
+}, (date, step) => {
+	date.setTime(+date + step * durationHour);
+}, (start, end) => {
+	return (end - start) / durationHour;
+}, (date) => {
+	return date.getUTCHours();
+});
+utcHour.range;
+//#endregion
+//#region ../../node_modules/.pnpm/d3-time@3.1.0/node_modules/d3-time/src/day.js
+var timeDay = timeInterval((date) => date.setHours(0, 0, 0, 0), (date, step) => date.setDate(date.getDate() + step), (start, end) => (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute) / durationDay, (date) => date.getDate() - 1);
+timeDay.range;
+var utcDay = timeInterval((date) => {
+	date.setUTCHours(0, 0, 0, 0);
+}, (date, step) => {
+	date.setUTCDate(date.getUTCDate() + step);
+}, (start, end) => {
+	return (end - start) / durationDay;
+}, (date) => {
+	return date.getUTCDate() - 1;
+});
+utcDay.range;
+var unixDay = timeInterval((date) => {
+	date.setUTCHours(0, 0, 0, 0);
+}, (date, step) => {
+	date.setUTCDate(date.getUTCDate() + step);
+}, (start, end) => {
+	return (end - start) / durationDay;
+}, (date) => {
+	return Math.floor(date / durationDay);
+});
+unixDay.range;
+//#endregion
+//#region ../../node_modules/.pnpm/d3-time@3.1.0/node_modules/d3-time/src/week.js
+function timeWeekday(i) {
+	return timeInterval((date) => {
+		date.setDate(date.getDate() - (date.getDay() + 7 - i) % 7);
+		date.setHours(0, 0, 0, 0);
+	}, (date, step) => {
+		date.setDate(date.getDate() + step * 7);
+	}, (start, end) => {
+		return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute) / durationWeek;
+	});
+}
+var timeSunday = timeWeekday(0);
+var timeMonday = timeWeekday(1);
+var timeTuesday = timeWeekday(2);
+var timeWednesday = timeWeekday(3);
+var timeThursday = timeWeekday(4);
+var timeFriday = timeWeekday(5);
+var timeSaturday = timeWeekday(6);
+timeSunday.range;
+timeMonday.range;
+timeTuesday.range;
+timeWednesday.range;
+timeThursday.range;
+timeFriday.range;
+timeSaturday.range;
+function utcWeekday(i) {
+	return timeInterval((date) => {
+		date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 7 - i) % 7);
+		date.setUTCHours(0, 0, 0, 0);
+	}, (date, step) => {
+		date.setUTCDate(date.getUTCDate() + step * 7);
+	}, (start, end) => {
+		return (end - start) / durationWeek;
+	});
+}
+var utcSunday = utcWeekday(0);
+var utcMonday = utcWeekday(1);
+var utcTuesday = utcWeekday(2);
+var utcWednesday = utcWeekday(3);
+var utcThursday = utcWeekday(4);
+var utcFriday = utcWeekday(5);
+var utcSaturday = utcWeekday(6);
+utcSunday.range;
+utcMonday.range;
+utcTuesday.range;
+utcWednesday.range;
+utcThursday.range;
+utcFriday.range;
+utcSaturday.range;
+//#endregion
+//#region ../../node_modules/.pnpm/d3-time@3.1.0/node_modules/d3-time/src/month.js
+var timeMonth = timeInterval((date) => {
+	date.setDate(1);
+	date.setHours(0, 0, 0, 0);
+}, (date, step) => {
+	date.setMonth(date.getMonth() + step);
+}, (start, end) => {
+	return end.getMonth() - start.getMonth() + (end.getFullYear() - start.getFullYear()) * 12;
+}, (date) => {
+	return date.getMonth();
+});
+timeMonth.range;
+var utcMonth = timeInterval((date) => {
+	date.setUTCDate(1);
+	date.setUTCHours(0, 0, 0, 0);
+}, (date, step) => {
+	date.setUTCMonth(date.getUTCMonth() + step);
+}, (start, end) => {
+	return end.getUTCMonth() - start.getUTCMonth() + (end.getUTCFullYear() - start.getUTCFullYear()) * 12;
+}, (date) => {
+	return date.getUTCMonth();
+});
+utcMonth.range;
+//#endregion
+//#region ../../node_modules/.pnpm/d3-time@3.1.0/node_modules/d3-time/src/year.js
+var timeYear = timeInterval((date) => {
+	date.setMonth(0, 1);
+	date.setHours(0, 0, 0, 0);
+}, (date, step) => {
+	date.setFullYear(date.getFullYear() + step);
+}, (start, end) => {
+	return end.getFullYear() - start.getFullYear();
+}, (date) => {
+	return date.getFullYear();
+});
+timeYear.every = (k) => {
+	return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : timeInterval((date) => {
+		date.setFullYear(Math.floor(date.getFullYear() / k) * k);
+		date.setMonth(0, 1);
+		date.setHours(0, 0, 0, 0);
+	}, (date, step) => {
+		date.setFullYear(date.getFullYear() + step * k);
+	});
+};
+timeYear.range;
+var utcYear = timeInterval((date) => {
+	date.setUTCMonth(0, 1);
+	date.setUTCHours(0, 0, 0, 0);
+}, (date, step) => {
+	date.setUTCFullYear(date.getUTCFullYear() + step);
+}, (start, end) => {
+	return end.getUTCFullYear() - start.getUTCFullYear();
+}, (date) => {
+	return date.getUTCFullYear();
+});
+utcYear.every = (k) => {
+	return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : timeInterval((date) => {
+		date.setUTCFullYear(Math.floor(date.getUTCFullYear() / k) * k);
+		date.setUTCMonth(0, 1);
+		date.setUTCHours(0, 0, 0, 0);
+	}, (date, step) => {
+		date.setUTCFullYear(date.getUTCFullYear() + step * k);
+	});
+};
+utcYear.range;
+//#endregion
+//#region ../../node_modules/.pnpm/d3-time@3.1.0/node_modules/d3-time/src/ticks.js
+function ticker(year, month, week, day, hour, minute) {
+	const tickIntervals = [
+		[
+			second,
+			1,
+			durationSecond
+		],
+		[
+			second,
+			5,
+			5 * durationSecond
+		],
+		[
+			second,
+			15,
+			15 * durationSecond
+		],
+		[
+			second,
+			30,
+			30 * durationSecond
+		],
+		[
+			minute,
+			1,
+			durationMinute
+		],
+		[
+			minute,
+			5,
+			5 * durationMinute
+		],
+		[
+			minute,
+			15,
+			15 * durationMinute
+		],
+		[
+			minute,
+			30,
+			30 * durationMinute
+		],
+		[
+			hour,
+			1,
+			durationHour
+		],
+		[
+			hour,
+			3,
+			3 * durationHour
+		],
+		[
+			hour,
+			6,
+			6 * durationHour
+		],
+		[
+			hour,
+			12,
+			12 * durationHour
+		],
+		[
+			day,
+			1,
+			durationDay
+		],
+		[
+			day,
+			2,
+			2 * durationDay
+		],
+		[
+			week,
+			1,
+			durationWeek
+		],
+		[
+			month,
+			1,
+			durationMonth
+		],
+		[
+			month,
+			3,
+			3 * durationMonth
+		],
+		[
+			year,
+			1,
+			durationYear
+		]
+	];
+	function ticks(start, stop, count) {
+		const reverse = stop < start;
+		if (reverse) [start, stop] = [stop, start];
+		const interval = count && typeof count.range === "function" ? count : tickInterval(start, stop, count);
+		const ticks = interval ? interval.range(start, +stop + 1) : [];
+		return reverse ? ticks.reverse() : ticks;
+	}
+	function tickInterval(start, stop, count) {
+		const target = Math.abs(stop - start) / count;
+		const i = bisector(([, , step]) => step).right(tickIntervals, target);
+		if (i === tickIntervals.length) return year.every(tickStep(start / durationYear, stop / durationYear, count));
+		if (i === 0) return millisecond.every(Math.max(tickStep(start, stop, count), 1));
+		const [t, step] = tickIntervals[target / tickIntervals[i - 1][2] < tickIntervals[i][2] / target ? i - 1 : i];
+		return t.every(step);
+	}
+	return [ticks, tickInterval];
+}
+var [utcTicks, utcTickInterval] = ticker(utcYear, utcMonth, utcSunday, unixDay, utcHour, utcMinute);
+var [timeTicks, timeTickInterval] = ticker(timeYear, timeMonth, timeSunday, timeDay, timeHour, timeMinute);
+//#endregion
+//#region ../../node_modules/.pnpm/d3-time-format@4.1.0/node_modules/d3-time-format/src/locale.js
+function localDate(d) {
+	if (0 <= d.y && d.y < 100) {
+		var date = new Date(-1, d.m, d.d, d.H, d.M, d.S, d.L);
+		date.setFullYear(d.y);
+		return date;
+	}
+	return new Date(d.y, d.m, d.d, d.H, d.M, d.S, d.L);
+}
+function utcDate(d) {
+	if (0 <= d.y && d.y < 100) {
+		var date = new Date(Date.UTC(-1, d.m, d.d, d.H, d.M, d.S, d.L));
+		date.setUTCFullYear(d.y);
+		return date;
+	}
+	return new Date(Date.UTC(d.y, d.m, d.d, d.H, d.M, d.S, d.L));
+}
+function newDate(y, m, d) {
+	return {
+		y,
+		m,
+		d,
+		H: 0,
+		M: 0,
+		S: 0,
+		L: 0
+	};
+}
+function formatLocale(locale) {
+	var locale_dateTime = locale.dateTime, locale_date = locale.date, locale_time = locale.time, locale_periods = locale.periods, locale_weekdays = locale.days, locale_shortWeekdays = locale.shortDays, locale_months = locale.months, locale_shortMonths = locale.shortMonths;
+	var periodRe = formatRe(locale_periods), periodLookup = formatLookup(locale_periods), weekdayRe = formatRe(locale_weekdays), weekdayLookup = formatLookup(locale_weekdays), shortWeekdayRe = formatRe(locale_shortWeekdays), shortWeekdayLookup = formatLookup(locale_shortWeekdays), monthRe = formatRe(locale_months), monthLookup = formatLookup(locale_months), shortMonthRe = formatRe(locale_shortMonths), shortMonthLookup = formatLookup(locale_shortMonths);
+	var formats = {
+		"a": formatShortWeekday,
+		"A": formatWeekday,
+		"b": formatShortMonth,
+		"B": formatMonth,
+		"c": null,
+		"d": formatDayOfMonth,
+		"e": formatDayOfMonth,
+		"f": formatMicroseconds,
+		"g": formatYearISO,
+		"G": formatFullYearISO,
+		"H": formatHour24,
+		"I": formatHour12,
+		"j": formatDayOfYear,
+		"L": formatMilliseconds,
+		"m": formatMonthNumber,
+		"M": formatMinutes,
+		"p": formatPeriod,
+		"q": formatQuarter,
+		"Q": formatUnixTimestamp,
+		"s": formatUnixTimestampSeconds,
+		"S": formatSeconds,
+		"u": formatWeekdayNumberMonday,
+		"U": formatWeekNumberSunday,
+		"V": formatWeekNumberISO,
+		"w": formatWeekdayNumberSunday,
+		"W": formatWeekNumberMonday,
+		"x": null,
+		"X": null,
+		"y": formatYear,
+		"Y": formatFullYear,
+		"Z": formatZone,
+		"%": formatLiteralPercent
+	};
+	var utcFormats = {
+		"a": formatUTCShortWeekday,
+		"A": formatUTCWeekday,
+		"b": formatUTCShortMonth,
+		"B": formatUTCMonth,
+		"c": null,
+		"d": formatUTCDayOfMonth,
+		"e": formatUTCDayOfMonth,
+		"f": formatUTCMicroseconds,
+		"g": formatUTCYearISO,
+		"G": formatUTCFullYearISO,
+		"H": formatUTCHour24,
+		"I": formatUTCHour12,
+		"j": formatUTCDayOfYear,
+		"L": formatUTCMilliseconds,
+		"m": formatUTCMonthNumber,
+		"M": formatUTCMinutes,
+		"p": formatUTCPeriod,
+		"q": formatUTCQuarter,
+		"Q": formatUnixTimestamp,
+		"s": formatUnixTimestampSeconds,
+		"S": formatUTCSeconds,
+		"u": formatUTCWeekdayNumberMonday,
+		"U": formatUTCWeekNumberSunday,
+		"V": formatUTCWeekNumberISO,
+		"w": formatUTCWeekdayNumberSunday,
+		"W": formatUTCWeekNumberMonday,
+		"x": null,
+		"X": null,
+		"y": formatUTCYear,
+		"Y": formatUTCFullYear,
+		"Z": formatUTCZone,
+		"%": formatLiteralPercent
+	};
+	var parses = {
+		"a": parseShortWeekday,
+		"A": parseWeekday,
+		"b": parseShortMonth,
+		"B": parseMonth,
+		"c": parseLocaleDateTime,
+		"d": parseDayOfMonth,
+		"e": parseDayOfMonth,
+		"f": parseMicroseconds,
+		"g": parseYear,
+		"G": parseFullYear,
+		"H": parseHour24,
+		"I": parseHour24,
+		"j": parseDayOfYear,
+		"L": parseMilliseconds,
+		"m": parseMonthNumber,
+		"M": parseMinutes,
+		"p": parsePeriod,
+		"q": parseQuarter,
+		"Q": parseUnixTimestamp,
+		"s": parseUnixTimestampSeconds,
+		"S": parseSeconds,
+		"u": parseWeekdayNumberMonday,
+		"U": parseWeekNumberSunday,
+		"V": parseWeekNumberISO,
+		"w": parseWeekdayNumberSunday,
+		"W": parseWeekNumberMonday,
+		"x": parseLocaleDate,
+		"X": parseLocaleTime,
+		"y": parseYear,
+		"Y": parseFullYear,
+		"Z": parseZone,
+		"%": parseLiteralPercent
+	};
+	formats.x = newFormat(locale_date, formats);
+	formats.X = newFormat(locale_time, formats);
+	formats.c = newFormat(locale_dateTime, formats);
+	utcFormats.x = newFormat(locale_date, utcFormats);
+	utcFormats.X = newFormat(locale_time, utcFormats);
+	utcFormats.c = newFormat(locale_dateTime, utcFormats);
+	function newFormat(specifier, formats) {
+		return function(date) {
+			var string = [], i = -1, j = 0, n = specifier.length, c, pad, format;
+			if (!(date instanceof Date)) date = /* @__PURE__ */ new Date(+date);
+			while (++i < n) if (specifier.charCodeAt(i) === 37) {
+				string.push(specifier.slice(j, i));
+				if ((pad = pads[c = specifier.charAt(++i)]) != null) c = specifier.charAt(++i);
+				else pad = c === "e" ? " " : "0";
+				if (format = formats[c]) c = format(date, pad);
+				string.push(c);
+				j = i + 1;
+			}
+			string.push(specifier.slice(j, i));
+			return string.join("");
+		};
+	}
+	function newParse(specifier, Z) {
+		return function(string) {
+			var d = newDate(1900, void 0, 1), i = parseSpecifier(d, specifier, string += "", 0), week, day;
+			if (i != string.length) return null;
+			if ("Q" in d) return new Date(d.Q);
+			if ("s" in d) return new Date(d.s * 1e3 + ("L" in d ? d.L : 0));
+			if (Z && !("Z" in d)) d.Z = 0;
+			if ("p" in d) d.H = d.H % 12 + d.p * 12;
+			if (d.m === void 0) d.m = "q" in d ? d.q : 0;
+			if ("V" in d) {
+				if (d.V < 1 || d.V > 53) return null;
+				if (!("w" in d)) d.w = 1;
+				if ("Z" in d) {
+					week = utcDate(newDate(d.y, 0, 1)), day = week.getUTCDay();
+					week = day > 4 || day === 0 ? utcMonday.ceil(week) : utcMonday(week);
+					week = utcDay.offset(week, (d.V - 1) * 7);
+					d.y = week.getUTCFullYear();
+					d.m = week.getUTCMonth();
+					d.d = week.getUTCDate() + (d.w + 6) % 7;
+				} else {
+					week = localDate(newDate(d.y, 0, 1)), day = week.getDay();
+					week = day > 4 || day === 0 ? timeMonday.ceil(week) : timeMonday(week);
+					week = timeDay.offset(week, (d.V - 1) * 7);
+					d.y = week.getFullYear();
+					d.m = week.getMonth();
+					d.d = week.getDate() + (d.w + 6) % 7;
+				}
+			} else if ("W" in d || "U" in d) {
+				if (!("w" in d)) d.w = "u" in d ? d.u % 7 : "W" in d ? 1 : 0;
+				day = "Z" in d ? utcDate(newDate(d.y, 0, 1)).getUTCDay() : localDate(newDate(d.y, 0, 1)).getDay();
+				d.m = 0;
+				d.d = "W" in d ? (d.w + 6) % 7 + d.W * 7 - (day + 5) % 7 : d.w + d.U * 7 - (day + 6) % 7;
+			}
+			if ("Z" in d) {
+				d.H += d.Z / 100 | 0;
+				d.M += d.Z % 100;
+				return utcDate(d);
+			}
+			return localDate(d);
+		};
+	}
+	function parseSpecifier(d, specifier, string, j) {
+		var i = 0, n = specifier.length, m = string.length, c, parse;
+		while (i < n) {
+			if (j >= m) return -1;
+			c = specifier.charCodeAt(i++);
+			if (c === 37) {
+				c = specifier.charAt(i++);
+				parse = parses[c in pads ? specifier.charAt(i++) : c];
+				if (!parse || (j = parse(d, string, j)) < 0) return -1;
+			} else if (c != string.charCodeAt(j++)) return -1;
+		}
+		return j;
+	}
+	function parsePeriod(d, string, i) {
+		var n = periodRe.exec(string.slice(i));
+		return n ? (d.p = periodLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+	}
+	function parseShortWeekday(d, string, i) {
+		var n = shortWeekdayRe.exec(string.slice(i));
+		return n ? (d.w = shortWeekdayLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+	}
+	function parseWeekday(d, string, i) {
+		var n = weekdayRe.exec(string.slice(i));
+		return n ? (d.w = weekdayLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+	}
+	function parseShortMonth(d, string, i) {
+		var n = shortMonthRe.exec(string.slice(i));
+		return n ? (d.m = shortMonthLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+	}
+	function parseMonth(d, string, i) {
+		var n = monthRe.exec(string.slice(i));
+		return n ? (d.m = monthLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+	}
+	function parseLocaleDateTime(d, string, i) {
+		return parseSpecifier(d, locale_dateTime, string, i);
+	}
+	function parseLocaleDate(d, string, i) {
+		return parseSpecifier(d, locale_date, string, i);
+	}
+	function parseLocaleTime(d, string, i) {
+		return parseSpecifier(d, locale_time, string, i);
+	}
+	function formatShortWeekday(d) {
+		return locale_shortWeekdays[d.getDay()];
+	}
+	function formatWeekday(d) {
+		return locale_weekdays[d.getDay()];
+	}
+	function formatShortMonth(d) {
+		return locale_shortMonths[d.getMonth()];
+	}
+	function formatMonth(d) {
+		return locale_months[d.getMonth()];
+	}
+	function formatPeriod(d) {
+		return locale_periods[+(d.getHours() >= 12)];
+	}
+	function formatQuarter(d) {
+		return 1 + ~~(d.getMonth() / 3);
+	}
+	function formatUTCShortWeekday(d) {
+		return locale_shortWeekdays[d.getUTCDay()];
+	}
+	function formatUTCWeekday(d) {
+		return locale_weekdays[d.getUTCDay()];
+	}
+	function formatUTCShortMonth(d) {
+		return locale_shortMonths[d.getUTCMonth()];
+	}
+	function formatUTCMonth(d) {
+		return locale_months[d.getUTCMonth()];
+	}
+	function formatUTCPeriod(d) {
+		return locale_periods[+(d.getUTCHours() >= 12)];
+	}
+	function formatUTCQuarter(d) {
+		return 1 + ~~(d.getUTCMonth() / 3);
+	}
+	return {
+		format: function(specifier) {
+			var f = newFormat(specifier += "", formats);
+			f.toString = function() {
+				return specifier;
+			};
+			return f;
+		},
+		parse: function(specifier) {
+			var p = newParse(specifier += "", false);
+			p.toString = function() {
+				return specifier;
+			};
+			return p;
+		},
+		utcFormat: function(specifier) {
+			var f = newFormat(specifier += "", utcFormats);
+			f.toString = function() {
+				return specifier;
+			};
+			return f;
+		},
+		utcParse: function(specifier) {
+			var p = newParse(specifier += "", true);
+			p.toString = function() {
+				return specifier;
+			};
+			return p;
+		}
+	};
+}
+var pads = {
+	"-": "",
+	"_": " ",
+	"0": "0"
+}, numberRe = /^\s*\d+/, percentRe = /^%/, requoteRe = /[\\^$*+?|[\]().{}]/g;
+function pad(value, fill, width) {
+	var sign = value < 0 ? "-" : "", string = (sign ? -value : value) + "", length = string.length;
+	return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string);
+}
+function requote(s) {
+	return s.replace(requoteRe, "\\$&");
+}
+function formatRe(names) {
+	return new RegExp("^(?:" + names.map(requote).join("|") + ")", "i");
+}
+function formatLookup(names) {
+	return new Map(names.map((name, i) => [name.toLowerCase(), i]));
+}
+function parseWeekdayNumberSunday(d, string, i) {
+	var n = numberRe.exec(string.slice(i, i + 1));
+	return n ? (d.w = +n[0], i + n[0].length) : -1;
+}
+function parseWeekdayNumberMonday(d, string, i) {
+	var n = numberRe.exec(string.slice(i, i + 1));
+	return n ? (d.u = +n[0], i + n[0].length) : -1;
+}
+function parseWeekNumberSunday(d, string, i) {
+	var n = numberRe.exec(string.slice(i, i + 2));
+	return n ? (d.U = +n[0], i + n[0].length) : -1;
+}
+function parseWeekNumberISO(d, string, i) {
+	var n = numberRe.exec(string.slice(i, i + 2));
+	return n ? (d.V = +n[0], i + n[0].length) : -1;
+}
+function parseWeekNumberMonday(d, string, i) {
+	var n = numberRe.exec(string.slice(i, i + 2));
+	return n ? (d.W = +n[0], i + n[0].length) : -1;
+}
+function parseFullYear(d, string, i) {
+	var n = numberRe.exec(string.slice(i, i + 4));
+	return n ? (d.y = +n[0], i + n[0].length) : -1;
+}
+function parseYear(d, string, i) {
+	var n = numberRe.exec(string.slice(i, i + 2));
+	return n ? (d.y = +n[0] + (+n[0] > 68 ? 1900 : 2e3), i + n[0].length) : -1;
+}
+function parseZone(d, string, i) {
+	var n = /^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(string.slice(i, i + 6));
+	return n ? (d.Z = n[1] ? 0 : -(n[2] + (n[3] || "00")), i + n[0].length) : -1;
+}
+function parseQuarter(d, string, i) {
+	var n = numberRe.exec(string.slice(i, i + 1));
+	return n ? (d.q = n[0] * 3 - 3, i + n[0].length) : -1;
+}
+function parseMonthNumber(d, string, i) {
+	var n = numberRe.exec(string.slice(i, i + 2));
+	return n ? (d.m = n[0] - 1, i + n[0].length) : -1;
+}
+function parseDayOfMonth(d, string, i) {
+	var n = numberRe.exec(string.slice(i, i + 2));
+	return n ? (d.d = +n[0], i + n[0].length) : -1;
+}
+function parseDayOfYear(d, string, i) {
+	var n = numberRe.exec(string.slice(i, i + 3));
+	return n ? (d.m = 0, d.d = +n[0], i + n[0].length) : -1;
+}
+function parseHour24(d, string, i) {
+	var n = numberRe.exec(string.slice(i, i + 2));
+	return n ? (d.H = +n[0], i + n[0].length) : -1;
+}
+function parseMinutes(d, string, i) {
+	var n = numberRe.exec(string.slice(i, i + 2));
+	return n ? (d.M = +n[0], i + n[0].length) : -1;
+}
+function parseSeconds(d, string, i) {
+	var n = numberRe.exec(string.slice(i, i + 2));
+	return n ? (d.S = +n[0], i + n[0].length) : -1;
+}
+function parseMilliseconds(d, string, i) {
+	var n = numberRe.exec(string.slice(i, i + 3));
+	return n ? (d.L = +n[0], i + n[0].length) : -1;
+}
+function parseMicroseconds(d, string, i) {
+	var n = numberRe.exec(string.slice(i, i + 6));
+	return n ? (d.L = Math.floor(n[0] / 1e3), i + n[0].length) : -1;
+}
+function parseLiteralPercent(d, string, i) {
+	var n = percentRe.exec(string.slice(i, i + 1));
+	return n ? i + n[0].length : -1;
+}
+function parseUnixTimestamp(d, string, i) {
+	var n = numberRe.exec(string.slice(i));
+	return n ? (d.Q = +n[0], i + n[0].length) : -1;
+}
+function parseUnixTimestampSeconds(d, string, i) {
+	var n = numberRe.exec(string.slice(i));
+	return n ? (d.s = +n[0], i + n[0].length) : -1;
+}
+function formatDayOfMonth(d, p) {
+	return pad(d.getDate(), p, 2);
+}
+function formatHour24(d, p) {
+	return pad(d.getHours(), p, 2);
+}
+function formatHour12(d, p) {
+	return pad(d.getHours() % 12 || 12, p, 2);
+}
+function formatDayOfYear(d, p) {
+	return pad(1 + timeDay.count(timeYear(d), d), p, 3);
+}
+function formatMilliseconds(d, p) {
+	return pad(d.getMilliseconds(), p, 3);
+}
+function formatMicroseconds(d, p) {
+	return formatMilliseconds(d, p) + "000";
+}
+function formatMonthNumber(d, p) {
+	return pad(d.getMonth() + 1, p, 2);
+}
+function formatMinutes(d, p) {
+	return pad(d.getMinutes(), p, 2);
+}
+function formatSeconds(d, p) {
+	return pad(d.getSeconds(), p, 2);
+}
+function formatWeekdayNumberMonday(d) {
+	var day = d.getDay();
+	return day === 0 ? 7 : day;
+}
+function formatWeekNumberSunday(d, p) {
+	return pad(timeSunday.count(timeYear(d) - 1, d), p, 2);
+}
+function dISO(d) {
+	var day = d.getDay();
+	return day >= 4 || day === 0 ? timeThursday(d) : timeThursday.ceil(d);
+}
+function formatWeekNumberISO(d, p) {
+	d = dISO(d);
+	return pad(timeThursday.count(timeYear(d), d) + (timeYear(d).getDay() === 4), p, 2);
+}
+function formatWeekdayNumberSunday(d) {
+	return d.getDay();
+}
+function formatWeekNumberMonday(d, p) {
+	return pad(timeMonday.count(timeYear(d) - 1, d), p, 2);
+}
+function formatYear(d, p) {
+	return pad(d.getFullYear() % 100, p, 2);
+}
+function formatYearISO(d, p) {
+	d = dISO(d);
+	return pad(d.getFullYear() % 100, p, 2);
+}
+function formatFullYear(d, p) {
+	return pad(d.getFullYear() % 1e4, p, 4);
+}
+function formatFullYearISO(d, p) {
+	var day = d.getDay();
+	d = day >= 4 || day === 0 ? timeThursday(d) : timeThursday.ceil(d);
+	return pad(d.getFullYear() % 1e4, p, 4);
+}
+function formatZone(d) {
+	var z = d.getTimezoneOffset();
+	return (z > 0 ? "-" : (z *= -1, "+")) + pad(z / 60 | 0, "0", 2) + pad(z % 60, "0", 2);
+}
+function formatUTCDayOfMonth(d, p) {
+	return pad(d.getUTCDate(), p, 2);
+}
+function formatUTCHour24(d, p) {
+	return pad(d.getUTCHours(), p, 2);
+}
+function formatUTCHour12(d, p) {
+	return pad(d.getUTCHours() % 12 || 12, p, 2);
+}
+function formatUTCDayOfYear(d, p) {
+	return pad(1 + utcDay.count(utcYear(d), d), p, 3);
+}
+function formatUTCMilliseconds(d, p) {
+	return pad(d.getUTCMilliseconds(), p, 3);
+}
+function formatUTCMicroseconds(d, p) {
+	return formatUTCMilliseconds(d, p) + "000";
+}
+function formatUTCMonthNumber(d, p) {
+	return pad(d.getUTCMonth() + 1, p, 2);
+}
+function formatUTCMinutes(d, p) {
+	return pad(d.getUTCMinutes(), p, 2);
+}
+function formatUTCSeconds(d, p) {
+	return pad(d.getUTCSeconds(), p, 2);
+}
+function formatUTCWeekdayNumberMonday(d) {
+	var dow = d.getUTCDay();
+	return dow === 0 ? 7 : dow;
+}
+function formatUTCWeekNumberSunday(d, p) {
+	return pad(utcSunday.count(utcYear(d) - 1, d), p, 2);
+}
+function UTCdISO(d) {
+	var day = d.getUTCDay();
+	return day >= 4 || day === 0 ? utcThursday(d) : utcThursday.ceil(d);
+}
+function formatUTCWeekNumberISO(d, p) {
+	d = UTCdISO(d);
+	return pad(utcThursday.count(utcYear(d), d) + (utcYear(d).getUTCDay() === 4), p, 2);
+}
+function formatUTCWeekdayNumberSunday(d) {
+	return d.getUTCDay();
+}
+function formatUTCWeekNumberMonday(d, p) {
+	return pad(utcMonday.count(utcYear(d) - 1, d), p, 2);
+}
+function formatUTCYear(d, p) {
+	return pad(d.getUTCFullYear() % 100, p, 2);
+}
+function formatUTCYearISO(d, p) {
+	d = UTCdISO(d);
+	return pad(d.getUTCFullYear() % 100, p, 2);
+}
+function formatUTCFullYear(d, p) {
+	return pad(d.getUTCFullYear() % 1e4, p, 4);
+}
+function formatUTCFullYearISO(d, p) {
+	var day = d.getUTCDay();
+	d = day >= 4 || day === 0 ? utcThursday(d) : utcThursday.ceil(d);
+	return pad(d.getUTCFullYear() % 1e4, p, 4);
+}
+function formatUTCZone() {
+	return "+0000";
+}
+function formatLiteralPercent() {
+	return "%";
+}
+function formatUnixTimestamp(d) {
+	return +d;
+}
+function formatUnixTimestampSeconds(d) {
+	return Math.floor(+d / 1e3);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-time-format@4.1.0/node_modules/d3-time-format/src/defaultLocale.js
+var locale;
+var timeFormat;
+var utcFormat;
+defaultLocale({
+	dateTime: "%x, %X",
+	date: "%-m/%-d/%Y",
+	time: "%-I:%M:%S %p",
+	periods: ["AM", "PM"],
+	days: [
+		"Sunday",
+		"Monday",
+		"Tuesday",
+		"Wednesday",
+		"Thursday",
+		"Friday",
+		"Saturday"
+	],
+	shortDays: [
+		"Sun",
+		"Mon",
+		"Tue",
+		"Wed",
+		"Thu",
+		"Fri",
+		"Sat"
+	],
+	months: [
+		"January",
+		"February",
+		"March",
+		"April",
+		"May",
+		"June",
+		"July",
+		"August",
+		"September",
+		"October",
+		"November",
+		"December"
+	],
+	shortMonths: [
+		"Jan",
+		"Feb",
+		"Mar",
+		"Apr",
+		"May",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dec"
+	]
+});
+function defaultLocale(definition) {
+	locale = formatLocale(definition);
+	timeFormat = locale.format;
+	locale.parse;
+	utcFormat = locale.utcFormat;
+	locale.utcParse;
+	return locale;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/time.js
+function date(t) {
+	return new Date(t);
+}
+function number(t) {
+	return t instanceof Date ? +t : +/* @__PURE__ */ new Date(+t);
+}
+function calendar(ticks, tickInterval, year, month, week, day, hour, minute, second, format) {
+	var scale = continuous(), invert = scale.invert, domain = scale.domain;
+	var formatMillisecond = format(".%L"), formatSecond = format(":%S"), formatMinute = format("%I:%M"), formatHour = format("%I %p"), formatDay = format("%a %d"), formatWeek = format("%b %d"), formatMonth = format("%B"), formatYear = format("%Y");
+	function tickFormat(date) {
+		return (second(date) < date ? formatMillisecond : minute(date) < date ? formatSecond : hour(date) < date ? formatMinute : day(date) < date ? formatHour : month(date) < date ? week(date) < date ? formatDay : formatWeek : year(date) < date ? formatMonth : formatYear)(date);
+	}
+	scale.invert = function(y) {
+		return new Date(invert(y));
+	};
+	scale.domain = function(_) {
+		return arguments.length ? domain(Array.from(_, number)) : domain().map(date);
+	};
+	scale.ticks = function(interval) {
+		var d = domain();
+		return ticks(d[0], d[d.length - 1], interval == null ? 10 : interval);
+	};
+	scale.tickFormat = function(count, specifier) {
+		return specifier == null ? tickFormat : format(specifier);
+	};
+	scale.nice = function(interval) {
+		var d = domain();
+		if (!interval || typeof interval.range !== "function") interval = tickInterval(d[0], d[d.length - 1], interval == null ? 10 : interval);
+		return interval ? domain(nice(d, interval)) : scale;
+	};
+	scale.copy = function() {
+		return copy$1(scale, calendar(ticks, tickInterval, year, month, week, day, hour, minute, second, format));
+	};
+	return scale;
+}
+function time() {
+	return initRange.apply(calendar(timeTicks, timeTickInterval, timeYear, timeMonth, timeSunday, timeDay, timeHour, timeMinute, second, timeFormat).domain([new Date(2e3, 0, 1), new Date(2e3, 0, 2)]), arguments);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/utcTime.js
+function utcTime() {
+	return initRange.apply(calendar(utcTicks, utcTickInterval, utcYear, utcMonth, utcSunday, utcDay, utcHour, utcMinute, second, utcFormat).domain([Date.UTC(2e3, 0, 1), Date.UTC(2e3, 0, 2)]), arguments);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/sequential.js
+function transformer$1() {
+	var x0 = 0, x1 = 1, t0, t1, k10, transform, interpolator = identity$1, clamp = false, unknown;
+	function scale(x) {
+		return x == null || isNaN(x = +x) ? unknown : interpolator(k10 === 0 ? .5 : (x = (transform(x) - t0) * k10, clamp ? Math.max(0, Math.min(1, x)) : x));
+	}
+	scale.domain = function(_) {
+		return arguments.length ? ([x0, x1] = _, t0 = transform(x0 = +x0), t1 = transform(x1 = +x1), k10 = t0 === t1 ? 0 : 1 / (t1 - t0), scale) : [x0, x1];
+	};
+	scale.clamp = function(_) {
+		return arguments.length ? (clamp = !!_, scale) : clamp;
+	};
+	scale.interpolator = function(_) {
+		return arguments.length ? (interpolator = _, scale) : interpolator;
+	};
+	function range(interpolate) {
+		return function(_) {
+			var r0, r1;
+			return arguments.length ? ([r0, r1] = _, interpolator = interpolate(r0, r1), scale) : [interpolator(0), interpolator(1)];
+		};
+	}
+	scale.range = range(value_default);
+	scale.rangeRound = range(round_default);
+	scale.unknown = function(_) {
+		return arguments.length ? (unknown = _, scale) : unknown;
+	};
+	return function(t) {
+		transform = t, t0 = t(x0), t1 = t(x1), k10 = t0 === t1 ? 0 : 1 / (t1 - t0);
+		return scale;
+	};
+}
+function copy(source, target) {
+	return target.domain(source.domain()).interpolator(source.interpolator()).clamp(source.clamp()).unknown(source.unknown());
+}
+function sequential() {
+	var scale = linearish(transformer$1()(identity$1));
+	scale.copy = function() {
+		return copy(scale, sequential());
+	};
+	return initInterpolator.apply(scale, arguments);
+}
+function sequentialLog() {
+	var scale = loggish(transformer$1()).domain([1, 10]);
+	scale.copy = function() {
+		return copy(scale, sequentialLog()).base(scale.base());
+	};
+	return initInterpolator.apply(scale, arguments);
+}
+function sequentialSymlog() {
+	var scale = symlogish(transformer$1());
+	scale.copy = function() {
+		return copy(scale, sequentialSymlog()).constant(scale.constant());
+	};
+	return initInterpolator.apply(scale, arguments);
+}
+function sequentialPow() {
+	var scale = powish(transformer$1());
+	scale.copy = function() {
+		return copy(scale, sequentialPow()).exponent(scale.exponent());
+	};
+	return initInterpolator.apply(scale, arguments);
+}
+function sequentialSqrt() {
+	return sequentialPow.apply(null, arguments).exponent(.5);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/sequentialQuantile.js
+function sequentialQuantile() {
+	var domain = [], interpolator = identity$1;
+	function scale(x) {
+		if (x != null && !isNaN(x = +x)) return interpolator((bisectRight(domain, x, 1) - 1) / (domain.length - 1));
+	}
+	scale.domain = function(_) {
+		if (!arguments.length) return domain.slice();
+		domain = [];
+		for (let d of _) if (d != null && !isNaN(d = +d)) domain.push(d);
+		domain.sort(ascending);
+		return scale;
+	};
+	scale.interpolator = function(_) {
+		return arguments.length ? (interpolator = _, scale) : interpolator;
+	};
+	scale.range = function() {
+		return domain.map((d, i) => interpolator(i / (domain.length - 1)));
+	};
+	scale.quantiles = function(n) {
+		return Array.from({ length: n + 1 }, (_, i) => quantile$1(domain, i / n));
+	};
+	scale.copy = function() {
+		return sequentialQuantile(interpolator).domain(domain);
+	};
+	return initInterpolator.apply(scale, arguments);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/diverging.js
+function transformer() {
+	var x0 = 0, x1 = .5, x2 = 1, s = 1, t0, t1, t2, k10, k21, interpolator = identity$1, transform, clamp = false, unknown;
+	function scale(x) {
+		return isNaN(x = +x) ? unknown : (x = .5 + ((x = +transform(x)) - t1) * (s * x < s * t1 ? k10 : k21), interpolator(clamp ? Math.max(0, Math.min(1, x)) : x));
+	}
+	scale.domain = function(_) {
+		return arguments.length ? ([x0, x1, x2] = _, t0 = transform(x0 = +x0), t1 = transform(x1 = +x1), t2 = transform(x2 = +x2), k10 = t0 === t1 ? 0 : .5 / (t1 - t0), k21 = t1 === t2 ? 0 : .5 / (t2 - t1), s = t1 < t0 ? -1 : 1, scale) : [
+			x0,
+			x1,
+			x2
+		];
+	};
+	scale.clamp = function(_) {
+		return arguments.length ? (clamp = !!_, scale) : clamp;
+	};
+	scale.interpolator = function(_) {
+		return arguments.length ? (interpolator = _, scale) : interpolator;
+	};
+	function range(interpolate) {
+		return function(_) {
+			var r0, r1, r2;
+			return arguments.length ? ([r0, r1, r2] = _, interpolator = piecewise(interpolate, [
+				r0,
+				r1,
+				r2
+			]), scale) : [
+				interpolator(0),
+				interpolator(.5),
+				interpolator(1)
+			];
+		};
+	}
+	scale.range = range(value_default);
+	scale.rangeRound = range(round_default);
+	scale.unknown = function(_) {
+		return arguments.length ? (unknown = _, scale) : unknown;
+	};
+	return function(t) {
+		transform = t, t0 = t(x0), t1 = t(x1), t2 = t(x2), k10 = t0 === t1 ? 0 : .5 / (t1 - t0), k21 = t1 === t2 ? 0 : .5 / (t2 - t1), s = t1 < t0 ? -1 : 1;
+		return scale;
+	};
+}
+function diverging() {
+	var scale = linearish(transformer()(identity$1));
+	scale.copy = function() {
+		return copy(scale, diverging());
+	};
+	return initInterpolator.apply(scale, arguments);
+}
+function divergingLog() {
+	var scale = loggish(transformer()).domain([
+		.1,
+		1,
+		10
+	]);
+	scale.copy = function() {
+		return copy(scale, divergingLog()).base(scale.base());
+	};
+	return initInterpolator.apply(scale, arguments);
+}
+function divergingSymlog() {
+	var scale = symlogish(transformer());
+	scale.copy = function() {
+		return copy(scale, divergingSymlog()).constant(scale.constant());
+	};
+	return initInterpolator.apply(scale, arguments);
+}
+function divergingPow() {
+	var scale = powish(transformer());
+	scale.copy = function() {
+		return copy(scale, divergingPow()).exponent(scale.exponent());
+	};
+	return initInterpolator.apply(scale, arguments);
+}
+function divergingSqrt() {
+	return divergingPow.apply(null, arguments).exponent(.5);
+}
+//#endregion
+export { linear as C, implicit as D, point as E, ordinal as O, identity as S, band as T, radial as _, divergingSymlog as a, symlog as b, sequentialLog as c, sequentialSymlog as d, utcTime as f, quantile as g, quantize as h, divergingSqrt as i, sequentialPow as l, threshold as m, divergingLog as n, sequentialQuantile as o, time as p, divergingPow as r, sequential as s, diverging as t, sequentialSqrt as u, pow as v, tickFormat as w, log as x, sqrt as y };