@vizejs/ui 0.426.3 → 0.427.0

package/dist/chart-scale-DDLe375F.mjs

@@ -0,0 +1,1049 @@
+//#region src/families/charts/chart-scale/scale-band.ts
+function copyValue(value) {
+	return value instanceof Date ? new Date(value.getTime()) : value;
+}
+/** Identity key for discrete values; dates compare by timestamp like d3's InternMap. */
+function discreteKey(value) {
+	return value instanceof Date ? value.getTime() : value;
+}
+function uniqueDomain(values) {
+	const domain = [];
+	const index = /* @__PURE__ */ new Map();
+	for (const value of values) {
+		const key = discreteKey(value);
+		if (index.has(key)) continue;
+		index.set(key, domain.length);
+		domain.push(copyValue(value));
+	}
+	return {
+		domain: Object.freeze(domain),
+		index
+	};
+}
+/**
+* Create an immutable ordinal scale. Unlike d3, unknown values never mutate the
+* domain; without an `unknown` output they cycle through the range in the order
+* they are first seen by this scale instance.
+*/
+function scaleOrdinal(options) {
+	const { domain, index } = uniqueDomain(options.domain ?? []);
+	const range = Object.freeze([...options.range]);
+	const implicit = /* @__PURE__ */ new Map();
+	const hasUnknown = "unknown" in options && options.unknown !== void 0;
+	const lookup = (value) => {
+		const key = discreteKey(value);
+		let position = index.get(key);
+		if (position === void 0) {
+			if (hasUnknown && options.unknown !== void 0) return options.unknown;
+			position = implicit.get(key);
+			if (position === void 0) {
+				position = domain.length + implicit.size;
+				implicit.set(key, position);
+			}
+		}
+		const output = range[position % range.length];
+		if (output === void 0) throw new RangeError("VIZE_UI_SCALE_EMPTY_RANGE: ordinal range is empty");
+		return output;
+	};
+	const scale = Object.assign(lookup, {
+		kind: "ordinal",
+		range,
+		with: (next) => scaleOrdinal({
+			...options,
+			domain,
+			range,
+			...next
+		})
+	});
+	Object.defineProperty(scale, "domain", {
+		enumerable: true,
+		get: () => Object.freeze(domain.map(copyValue))
+	});
+	return scale;
+}
+function layoutBands(count, range, paddingInner, paddingOuter, align, round) {
+	const [r0, r1] = range;
+	const reverse = r1 < r0;
+	let start = reverse ? r1 : r0;
+	const stop = reverse ? r0 : r1;
+	let step = (stop - start) / Math.max(1, count - paddingInner + paddingOuter * 2);
+	if (round) step = Math.floor(step);
+	start += (stop - start - step * (count - paddingInner)) * align;
+	let bandwidth = step * (1 - paddingInner);
+	if (round) {
+		start = Math.round(start);
+		bandwidth = Math.round(bandwidth);
+	}
+	const starts = Array.from({ length: count }, (_, i) => start + step * i);
+	return {
+		bandwidth,
+		starts: reverse ? starts.reverse() : starts,
+		step
+	};
+}
+function createBand(options, kind) {
+	const { domain, index } = uniqueDomain(options.domain ?? []);
+	const range = Object.freeze([options.range?.[0] ?? 0, options.range?.[1] ?? 1]);
+	const paddingOuter = options.padding ?? options.paddingOuter ?? 0;
+	const paddingInner = kind === "point" ? 1 : Math.min(1, options.padding ?? options.paddingInner ?? 0);
+	const align = Math.max(0, Math.min(1, options.align ?? .5));
+	const layout = layoutBands(domain.length, range, paddingInner, paddingOuter, align, options.round ?? false);
+	const current = {
+		...options,
+		domain,
+		range
+	};
+	const scale = Object.assign((value) => {
+		const position = index.get(discreteKey(value));
+		return position === void 0 ? NaN : layout.starts[position] ?? NaN;
+	}, {
+		kind,
+		range,
+		bandwidth: layout.bandwidth,
+		step: layout.step,
+		ticks: () => domain.map(copyValue),
+		with: (next) => createBand({
+			...current,
+			...next
+		}, kind)
+	});
+	Object.defineProperty(scale, "domain", {
+		enumerable: true,
+		get: () => Object.freeze(domain.map(copyValue))
+	});
+	return scale;
+}
+/**
+* Create an immutable band scale for categorical positions such as bars.
+*
+* @example
+* ```ts
+* const x = scaleBand({ domain: ["a", "b", "c"], range: [0, 300], paddingInner: 0.1 });
+* x("b"); // band start
+* x.bandwidth; // band width
+* ```
+*/
+function scaleBand(options = {}) {
+	return createBand(options, "band");
+}
+/** Create an immutable point scale: evenly spaced positions with zero bandwidth. */
+function scalePoint(options = {}) {
+	const { padding, ...rest } = options;
+	const band = createBand({
+		...rest,
+		paddingOuter: padding ?? rest.paddingOuter ?? 0
+	}, "point");
+	return Object.assign(band, {
+		kind: "point",
+		with: (next) => scalePoint({
+			...options,
+			...next
+		})
+	});
+}
+//#endregion
+//#region src/families/charts/chart-scale/scale-ticks.ts
+const e10 = Math.sqrt(50);
+const e5 = Math.sqrt(10);
+const e2 = Math.sqrt(2);
+function tickSpec(start, stop, count) {
+	const step = (stop - start) / Math.max(0, count);
+	const power = Math.floor(Math.log10(step));
+	const error = step / 10 ** power;
+	const factor = error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1;
+	let i1;
+	let i2;
+	let increment;
+	if (power < 0) {
+		increment = 10 ** -power / factor;
+		i1 = Math.round(start * increment);
+		i2 = Math.round(stop * increment);
+		if (i1 / increment < start) ++i1;
+		if (i2 / increment > stop) --i2;
+		increment = -increment;
+	} else {
+		increment = 10 ** power * factor;
+		i1 = Math.round(start / increment);
+		i2 = Math.round(stop / increment);
+		if (i1 * increment < start) ++i1;
+		if (i2 * increment > stop) --i2;
+	}
+	if (i2 < i1 && .5 <= count && count < 2) return tickSpec(start, stop, count * 2);
+	return [
+		i1,
+		i2,
+		increment
+	];
+}
+/**
+* Return about `count` human-friendly values (multiples of 1, 2, or 5 times a
+* power of ten) inside `[start, stop]`, in the same direction as the input.
+*/
+function ticks(start, stop, count) {
+	if (!(count > 0)) return [];
+	if (start === stop) return [start];
+	const reverse = stop < start;
+	const [i1, i2, increment] = reverse ? tickSpec(stop, start, count) : tickSpec(start, stop, count);
+	if (!(i2 >= i1)) return [];
+	const n = i2 - i1 + 1;
+	const result = [];
+	for (let i = 0; i < n; ++i) {
+		const k = reverse ? i2 - i : i1 + i;
+		result.push(increment < 0 ? k / -increment : k * increment);
+	}
+	return result;
+}
+/**
+* Tick increment for `[start, stop]`. Positive values are the step; negative
+* values are the inverse step (`-10` means `0.1`), which avoids float error.
+*/
+function tickIncrement(start, stop, count) {
+	return tickSpec(start, stop, count)[2];
+}
+/** Signed distance between adjacent ticks for `[start, stop]`. */
+function tickStep(start, stop, count) {
+	const reverse = stop < start;
+	const increment = reverse ? tickIncrement(stop, start, count) : tickIncrement(start, stop, count);
+	return (reverse ? -1 : 1) * (increment < 0 ? 1 / -increment : increment);
+}
+/**
+* Extend `[start, stop]` outward to tick-aligned values, iterating like d3's
+* `linear.nice` until the tick increment stabilizes. Direction is preserved.
+*/
+function niceExtent(start, stop, count = 10) {
+	const reverse = stop < start;
+	let lo = reverse ? stop : start;
+	let hi = reverse ? start : stop;
+	let previous;
+	for (let iteration = 0; iteration < 10; iteration++) {
+		const step = tickIncrement(lo, hi, count);
+		if (step === previous) return reverse ? [hi, lo] : [lo, hi];
+		if (step > 0) {
+			lo = Math.floor(lo / step) * step;
+			hi = Math.ceil(hi / step) * step;
+		} else if (step < 0) {
+			lo = Math.ceil(lo * step) / step;
+			hi = Math.floor(hi * step) / step;
+		} else break;
+		previous = step;
+	}
+	return [start, stop];
+}
+/** Decimal exponent of `value`, as in scientific notation (`0.05` → `-2`). */
+function decimalExponent(value) {
+	if (!Number.isFinite(value) || value === 0) return 0;
+	return Number(Math.abs(value).toExponential().split("e")[1]);
+}
+/** Fraction digits needed to distinguish ticks `step` apart (d3 `precisionFixed`). */
+function precisionFixed(step) {
+	return Math.max(0, -decimalExponent(step));
+}
+/** Index of the first element greater than `value` in an ascending array. */
+function bisectRight(values, value, lo = 0, hi = values.length) {
+	let low = lo;
+	let high = hi;
+	while (low < high) {
+		const mid = low + high >>> 1;
+		const candidate = values[mid];
+		if (candidate !== void 0 && candidate <= value) low = mid + 1;
+		else high = mid;
+	}
+	return low;
+}
+//#endregion
+//#region src/families/charts/chart-scale/scale-format.ts
+const defaultLocale = "en-US";
+/**
+* Build a localized formatter for ticks of `[start, stop]`.
+*
+* Precision follows d3's `precisionFixed(tickStep)`, so adjacent ticks are
+* always distinguishable without trailing noise; with the default `en-US`
+* locale the output equals d3's `",f"` format except that `Intl` uses an ASCII
+* hyphen-minus rather than `−`.
+*/
+function numberTickFormat(start, stop, count, options = {}) {
+	const step = tickStep(start, stop, count);
+	const percent = options.format?.style === "percent";
+	const fixed = Number.isFinite(step) ? precisionFixed(step) : 0;
+	const digits = Math.min(20, Math.max(0, percent ? fixed - 2 : fixed));
+	const formatter = new Intl.NumberFormat(options.locale ?? defaultLocale, {
+		maximumFractionDigits: digits,
+		minimumFractionDigits: digits,
+		...options.format
+	});
+	return (value) => formatter.format(value);
+}
+/** Default `Intl.DateTimeFormat` options per time tick granularity. */
+const defaultTimeTickFormats = Object.freeze({
+	millisecond: {
+		second: "2-digit",
+		fractionalSecondDigits: 3
+	},
+	second: {
+		hour: "numeric",
+		minute: "2-digit",
+		second: "2-digit"
+	},
+	minute: {
+		hour: "numeric",
+		minute: "2-digit"
+	},
+	hour: { hour: "numeric" },
+	day: {
+		weekday: "short",
+		day: "numeric"
+	},
+	week: {
+		month: "short",
+		day: "numeric"
+	},
+	month: { month: "long" },
+	year: { year: "numeric" }
+});
+/**
+* Build a granularity-aware time formatter. `granularity` decides which calendar
+* unit a tick represents (as d3's multi-scale time format does); each unit is
+* formatted with `Intl.DateTimeFormat` in `timeZone`, so labels are localized
+* and identical on server and client.
+*/
+function timeTickFormat(timeZone, granularity, options = {}) {
+	const locale = options.locale ?? defaultLocale;
+	const cache = /* @__PURE__ */ new Map();
+	const formatterFor = (unit) => {
+		const cached = cache.get(unit);
+		if (cached !== void 0) return cached;
+		const formatter = new Intl.DateTimeFormat(locale, {
+			...options.formats?.[unit] ?? defaultTimeTickFormats[unit],
+			timeZone
+		});
+		cache.set(unit, formatter);
+		return formatter;
+	};
+	return (date) => formatterFor(granularity(date)).format(date);
+}
+//#endregion
+//#region src/families/charts/chart-scale/scale-continuous.ts
+const unitInterval = Object.freeze([0, 1]);
+function normalize(a, b) {
+	const span = b - a;
+	if (span) return (x) => (x - a) / span;
+	const constant = Number.isNaN(span) ? NaN : .5;
+	return () => constant;
+}
+function interpolateNumber(a, b) {
+	return (t) => a * (1 - t) + b * t;
+}
+function interpolateRound(a, b) {
+	return (t) => Math.round(a * (1 - t) + b * t);
+}
+function clamper(a, b) {
+	const lo = a > b ? b : a;
+	const hi = a > b ? a : b;
+	return (x) => Math.max(lo, Math.min(hi, x));
+}
+function identity$1(x) {
+	return x;
+}
+function bimap(domain, range, interpolate) {
+	const d0 = domain[0] ?? 0;
+	const d1 = domain[1] ?? 0;
+	const r0 = range[0] ?? 0;
+	const r1 = range[1] ?? 0;
+	const [toUnit, fromUnit] = d1 < d0 ? [normalize(d1, d0), interpolate(r1, r0)] : [normalize(d0, d1), interpolate(r0, r1)];
+	return (x) => fromUnit(toUnit(x));
+}
+function polymap(domainInput, rangeInput, interpolate) {
+	const j = Math.min(domainInput.length, rangeInput.length) - 1;
+	const descending = (domainInput[j] ?? 0) < (domainInput[0] ?? 0);
+	const domain = descending ? [...domainInput].reverse() : domainInput;
+	const range = descending ? [...rangeInput].reverse() : rangeInput;
+	const toUnit = [];
+	const fromUnit = [];
+	for (let i = 0; i < j; i++) {
+		toUnit.push(normalize(domain[i] ?? 0, domain[i + 1] ?? 0));
+		fromUnit.push(interpolate(range[i] ?? 0, range[i + 1] ?? 0));
+	}
+	return (x) => {
+		const i = bisectRight(domain, x, 1, j) - 1;
+		const forward = toUnit[i];
+		const back = fromUnit[i];
+		return forward === void 0 || back === void 0 ? NaN : back(forward(x));
+	};
+}
+function piecewise(domain, range, interpolate) {
+	return Math.min(domain.length, range.length) > 2 ? polymap(domain, range, interpolate) : bimap(domain, range, interpolate);
+}
+/** Build the forward and inverse mappings shared by every continuous scale. */
+function createContinuousCore(config) {
+	const n = Math.min(config.domain.length, config.range.length);
+	const clamp = config.clamp ? clamper(config.domain[0] ?? 0, config.domain[n - 1] ?? 0) : identity$1;
+	const transformed = config.domain.map(config.transform);
+	const output = piecewise(transformed, config.range, config.round ? interpolateRound : interpolateNumber);
+	const input = piecewise(config.range, transformed, interpolateNumber);
+	return {
+		map: (value) => Number.isNaN(value) ? config.unknown : output(config.transform(clamp(value))),
+		invert: (value) => clamp(config.untransform(input(value)))
+	};
+}
+function toNumber(value) {
+	return value === null || value === void 0 ? NaN : +value;
+}
+function niceCount(nice) {
+	if (nice === void 0 || nice === false) return null;
+	return nice === true ? 10 : nice;
+}
+function niceDomain(domain, count) {
+	const next = [...domain];
+	const last = next.length - 1;
+	const [start, stop] = niceExtent(next[0] ?? 0, next[last] ?? 0, count);
+	next[0] = start;
+	next[last] = stop;
+	return next;
+}
+function resolveContinuous(options, applyNice) {
+	const domain = Object.freeze([...options.domain ?? unitInterval].map(Number));
+	const count = niceCount(options.nice);
+	return {
+		clamp: options.clamp ?? false,
+		domain: count === null ? domain : Object.freeze([...applyNice(domain, count)]),
+		range: Object.freeze([...options.range ?? unitInterval]),
+		round: options.round ?? false,
+		unknown: options.unknown ?? NaN
+	};
+}
+function withoutNice(options, resolved) {
+	return {
+		...options,
+		domain: resolved.domain,
+		range: resolved.range,
+		nice: false
+	};
+}
+/**
+* Create an immutable linear scale.
+*
+* @example
+* ```ts
+* const y = scaleLinear({ domain: [0, 120], range: [300, 0], nice: true });
+* y(60); // 150
+* ```
+*/
+function scaleLinear(options = {}) {
+	const resolved = resolveContinuous(options, niceDomain);
+	const core = createContinuousCore({
+		...resolved,
+		transform: identity$1,
+		untransform: identity$1
+	});
+	const current = withoutNice(options, resolved);
+	const first = resolved.domain[0] ?? 0;
+	const last = resolved.domain.at(-1) ?? 0;
+	return Object.assign((value) => core.map(toNumber(value)), {
+		kind: "linear",
+		domain: resolved.domain,
+		range: resolved.range,
+		clamp: resolved.clamp,
+		round: resolved.round,
+		invert: core.invert,
+		ticks: (count = 10) => ticks(first, last, count),
+		tickFormat: (count = 10, format = {}) => numberTickFormat(first, last, count, format),
+		nice: (count = 10) => scaleLinear({
+			...current,
+			nice: count
+		}),
+		with: (next) => scaleLinear({
+			...current,
+			...next
+		}),
+		options: () => ({ ...current })
+	});
+}
+function powTransform(exponent) {
+	if (exponent === 1) return [identity$1, identity$1];
+	if (exponent === .5) return [(x) => x < 0 ? -Math.sqrt(-x) : Math.sqrt(x), (x) => x < 0 ? -x * x : x * x];
+	const forward = (e) => (x) => x < 0 ? -((-x) ** e) : x ** e;
+	return [forward(exponent), forward(1 / exponent)];
+}
+/**
+* Create an immutable power scale. Use `exponent: 0.5` for area-proportional
+* encodings such as bubble radii.
+*/
+function scalePow(options = {}) {
+	const exponent = options.exponent ?? 1;
+	const resolved = resolveContinuous(options, niceDomain);
+	const [transform, untransform] = powTransform(exponent);
+	const core = createContinuousCore({
+		...resolved,
+		transform,
+		untransform
+	});
+	const current = {
+		...withoutNice(options, resolved),
+		exponent
+	};
+	const first = resolved.domain[0] ?? 0;
+	const last = resolved.domain.at(-1) ?? 0;
+	return Object.assign((value) => core.map(toNumber(value)), {
+		kind: "pow",
+		exponent,
+		domain: resolved.domain,
+		range: resolved.range,
+		clamp: resolved.clamp,
+		round: resolved.round,
+		invert: core.invert,
+		ticks: (count = 10) => ticks(first, last, count),
+		tickFormat: (count = 10, format = {}) => numberTickFormat(first, last, count, format),
+		nice: (count = 10) => scalePow({
+			...current,
+			nice: count
+		}),
+		with: (next) => scalePow({
+			...current,
+			...next
+		}),
+		options: () => ({ ...current })
+	});
+}
+/** Create a square-root scale, `scalePow` with `exponent: 0.5`. */
+function scaleSqrt(options = {}) {
+	return scalePow({
+		...options,
+		exponent: .5
+	});
+}
+function pow10(x) {
+	return Number.isFinite(x) ? Number(`1e${x}`) : x < 0 ? 0 : x;
+}
+function powp(base) {
+	if (base === 10) return pow10;
+	if (base === Math.E) return Math.exp;
+	return (x) => base ** x;
+}
+function logp(base) {
+	if (base === Math.E) return Math.log;
+	if (base === 10) return Math.log10;
+	if (base === 2) return Math.log2;
+	const divisor = Math.log(base);
+	return (x) => Math.log(x) / divisor;
+}
+function reflect(f) {
+	return (x) => -f(-x);
+}
+function logTicks(domain, base, count) {
+	let u = domain[0] ?? 1;
+	let v = domain.at(-1) ?? 1;
+	const reversed = v < u;
+	if (reversed) [u, v] = [v, u];
+	const negative = (domain[0] ?? 1) < 0;
+	const logs = negative ? reflect(logp(base)) : logp(base);
+	const pows = negative ? reflect(powp(base)) : powp(base);
+	let i = logs(u);
+	let j = logs(v);
+	let z = [];
+	if (!(base % 1) && j - i < count) {
+		i = Math.floor(i);
+		j = Math.ceil(j);
+		if (u > 0) for (; i <= j; ++i) for (let k = 1; k < base; ++k) {
+			const 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 (let k = base - 1; k >= 1; --k) {
+			const t = i > 0 ? k / pows(-i) : k * pows(i);
+			if (t < u) continue;
+			if (t > v) break;
+			z.push(t);
+		}
+		if (z.length * 2 < count) z = ticks(u, v, count);
+	} else z = ticks(i, j, Math.min(j - i, count)).map(pows);
+	return reversed ? z.reverse() : z;
+}
+/**
+* Create an immutable logarithmic scale. Ticks and nice domains snap to powers
+* of the base, and `tickFormat` blanks minor ticks on dense axes like d3.
+*/
+function scaleLog(options = {}) {
+	const base = options.base ?? 10;
+	const sourceDomain = options.domain ?? [1, 10];
+	const negative = (sourceDomain[0] ?? 1) < 0;
+	const logs = negative ? reflect(logp(base)) : logp(base);
+	const pows = negative ? reflect(powp(base)) : powp(base);
+	const resolved = resolveContinuous({
+		...options,
+		domain: sourceDomain
+	}, (domain) => {
+		const next = [...domain];
+		const lastIndex = next.length - 1;
+		const x0 = next[0] ?? 1;
+		const x1 = next[lastIndex] ?? 1;
+		const [lo, hi, i0, i1] = x1 < x0 ? [
+			x1,
+			x0,
+			lastIndex,
+			0
+		] : [
+			x0,
+			x1,
+			0,
+			lastIndex
+		];
+		next[i0] = pows(Math.floor(logs(lo)));
+		next[i1] = pows(Math.ceil(logs(hi)));
+		return next;
+	});
+	const core = createContinuousCore({
+		...resolved,
+		transform: negative ? (x) => -Math.log(-x) : Math.log,
+		untransform: negative ? (x) => -Math.exp(-x) : Math.exp
+	});
+	const current = {
+		...withoutNice(options, resolved),
+		base
+	};
+	const ticks = (count = 10) => logTicks(resolved.domain, base, count);
+	return Object.assign((value) => core.map(toNumber(value)), {
+		kind: "log",
+		base,
+		domain: resolved.domain,
+		range: resolved.range,
+		clamp: resolved.clamp,
+		round: resolved.round,
+		invert: core.invert,
+		ticks,
+		tickFormat: (count = 10, format = {}) => {
+			const formatter = new Intl.NumberFormat(format.locale ?? "en-US", {
+				notation: "compact",
+				...format.format
+			});
+			const k = Math.max(1, base * count / ticks().length);
+			return (value) => {
+				let i = value / pows(Math.round(logs(value)));
+				if (i * base < base - .5) i *= base;
+				return i <= k ? formatter.format(value) : "";
+			};
+		},
+		nice: () => scaleLog({
+			...current,
+			nice: true
+		}),
+		with: (next) => scaleLog({
+			...current,
+			...next
+		}),
+		options: () => ({ ...current })
+	});
+}
+//#endregion
+//#region src/families/charts/chart-scale/scale-time-interval.ts
+const second = 1e3;
+const minute = second * 60;
+const hour = minute * 60;
+const day = hour * 24;
+const week = day * 7;
+const month = day * 30;
+const year = day * 365;
+const partFormatters = /* @__PURE__ */ new Map();
+function partsFormatter(timeZone) {
+	const cached = partFormatters.get(timeZone);
+	if (cached !== void 0) return cached;
+	const formatter = new Intl.DateTimeFormat("en-US", {
+		timeZone,
+		hourCycle: "h23",
+		year: "numeric",
+		month: "numeric",
+		day: "numeric",
+		hour: "numeric",
+		minute: "numeric",
+		second: "numeric",
+		era: "short"
+	});
+	partFormatters.set(timeZone, formatter);
+	return formatter;
+}
+function zoneOffset(formatter, epoch) {
+	const fields = {};
+	let bce = false;
+	for (const part of formatter.formatToParts(epoch)) if (part.type === "era") bce = part.value.startsWith("B");
+	else if (part.type !== "literal") fields[part.type] = Number(part.value);
+	const yearValue = fields.year ?? 1970;
+	return Date.UTC(bce ? 1 - yearValue : yearValue, (fields.month ?? 1) - 1, fields.day ?? 1, fields.hour ?? 0, fields.minute ?? 0, fields.second ?? 0) - Math.floor(epoch / second) * second;
+}
+/**
+* Create a wall-clock converter for `timeZone`.
+*
+* @throws RangeError when `timeZone` is not a supported IANA zone.
+*/
+function createZoneClock(timeZone) {
+	const canonical = new Intl.DateTimeFormat("en-US", { timeZone }).resolvedOptions().timeZone;
+	if (canonical === "UTC" || canonical === "Etc/UTC" || canonical === "Etc/GMT") return {
+		timeZone: canonical,
+		utc: true,
+		toWall: (epoch) => epoch,
+		fromWall: (wall) => wall
+	};
+	const formatter = partsFormatter(canonical);
+	const offset = (epoch) => zoneOffset(formatter, epoch);
+	return {
+		timeZone: canonical,
+		utc: false,
+		toWall: (epoch) => epoch + offset(epoch),
+		fromWall: (wall) => {
+			const guess = wall - offset(wall);
+			const corrected = wall - offset(guess);
+			return offset(corrected) === wall - corrected ? corrected : guess;
+		}
+	};
+}
+function createInterval(spec) {
+	const ceil = (epoch) => spec.floor(spec.offset(spec.floor(epoch - 1), 1));
+	const interval = {
+		floor: spec.floor,
+		offset: (epoch, step) => spec.offset(epoch, Math.floor(step)),
+		ceil,
+		range: (start, stop) => {
+			const values = [];
+			let current = ceil(start);
+			if (!(current < stop)) return values;
+			let previous;
+			do {
+				values.push(previous = current);
+				current = spec.floor(spec.offset(current, 1));
+			} while (previous < current && current < stop);
+			return values;
+		},
+		every: (stepInput) => {
+			if (spec.every !== void 0) return spec.every(stepInput);
+			const step = Math.floor(stepInput);
+			if (!Number.isFinite(step) || !(step > 0)) return null;
+			if (!(step > 1)) return interval;
+			const field = spec.field;
+			if (field === void 0) return null;
+			return filterInterval(spec, (epoch) => field(epoch) % step === 0);
+		}
+	};
+	return interval;
+}
+function filterInterval(spec, test) {
+	return createInterval({
+		floor: (input) => {
+			let epoch = spec.floor(input);
+			while (!test(epoch)) epoch = spec.floor(epoch - 1);
+			return epoch;
+		},
+		offset: (input, step) => {
+			let epoch = input;
+			if (step < 0) for (let remaining = step; remaining < 0; remaining++) do
+				epoch = spec.offset(epoch, -1);
+			while (!test(epoch));
+			else for (let remaining = step; remaining > 0; remaining--) do
+				epoch = spec.offset(epoch, 1);
+			while (!test(epoch));
+			return epoch;
+		}
+	});
+}
+function millisecondEvery(stepInput) {
+	const step = Math.floor(stepInput);
+	if (!Number.isFinite(step) || !(step > 0)) return null;
+	return createInterval({
+		floor: (epoch) => Math.floor(epoch / step) * step,
+		offset: (epoch, count) => epoch + count * step
+	});
+}
+function mod(value, divisor) {
+	return (value % divisor + divisor) % divisor;
+}
+const intervalCache = /* @__PURE__ */ new Map();
+/** Build (and cache) the calendar intervals for `timeZone`. */
+function zoneIntervals(timeZone) {
+	const cached = intervalCache.get(timeZone);
+	if (cached !== void 0) return cached;
+	const clock = createZoneClock(timeZone);
+	const { toWall, fromWall } = clock;
+	const wallDate = (epoch) => new Date(toWall(epoch));
+	const floorWall = (epoch, unit) => epoch - mod(toWall(epoch), unit);
+	const yearInterval = (every) => createInterval({
+		floor: (epoch) => {
+			const date = wallDate(epoch);
+			const y = Math.floor(date.getUTCFullYear() / every) * every;
+			date.setUTCFullYear(y, 0, 1);
+			date.setUTCHours(0, 0, 0, 0);
+			return fromWall(date.getTime());
+		},
+		offset: (epoch, step) => {
+			const date = wallDate(epoch);
+			date.setUTCFullYear(date.getUTCFullYear() + step * every);
+			return fromWall(date.getTime());
+		}
+	});
+	const intervals = {
+		clock,
+		millisecond: createInterval({
+			floor: (epoch) => epoch,
+			offset: (epoch, step) => epoch + step,
+			every: millisecondEvery
+		}),
+		second: createInterval({
+			floor: (epoch) => epoch - mod(epoch, second),
+			offset: (epoch, step) => epoch + step * second,
+			field: (epoch) => new Date(epoch).getUTCSeconds()
+		}),
+		minute: createInterval({
+			floor: (epoch) => floorWall(epoch, minute),
+			offset: (epoch, step) => epoch + step * minute,
+			field: (epoch) => wallDate(epoch).getUTCMinutes()
+		}),
+		hour: createInterval({
+			floor: (epoch) => floorWall(epoch, hour),
+			offset: (epoch, step) => epoch + step * hour,
+			field: (epoch) => wallDate(epoch).getUTCHours()
+		}),
+		day: createInterval({
+			floor: (epoch) => fromWall(toWall(epoch) - mod(toWall(epoch), day)),
+			offset: (epoch, step) => fromWall(toWall(epoch) + step * day),
+			field: clock.utc ? (epoch) => Math.floor(epoch / day) : (epoch) => wallDate(epoch).getUTCDate() - 1
+		}),
+		week: createInterval({
+			floor: (epoch) => {
+				const wall = toWall(epoch);
+				const midnight = wall - mod(wall, day);
+				return fromWall(midnight - new Date(midnight).getUTCDay() * day);
+			},
+			offset: (epoch, step) => fromWall(toWall(epoch) + step * week)
+		}),
+		month: createInterval({
+			floor: (epoch) => {
+				const date = wallDate(epoch);
+				return fromWall(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1));
+			},
+			offset: (epoch, step) => {
+				const date = wallDate(epoch);
+				date.setUTCMonth(date.getUTCMonth() + step);
+				return fromWall(date.getTime());
+			},
+			field: (epoch) => wallDate(epoch).getUTCMonth()
+		}),
+		year: createInterval({
+			floor: (epoch) => yearInterval(1).floor(epoch),
+			offset: (epoch, step) => yearInterval(1).offset(epoch, step),
+			every: (stepInput) => {
+				const step = Math.floor(stepInput);
+				return !Number.isFinite(step) || !(step > 0) ? null : yearInterval(step);
+			}
+		})
+	};
+	intervalCache.set(timeZone, intervals);
+	return intervals;
+}
+/** Choose the tick interval d3's `timeTickInterval` would pick for `[start, stop]`. */
+function timeTickInterval(intervals, start, stop, count, tickStep) {
+	const table = [
+		[
+			intervals.second,
+			1,
+			second
+		],
+		[
+			intervals.second,
+			5,
+			5 * second
+		],
+		[
+			intervals.second,
+			15,
+			15 * second
+		],
+		[
+			intervals.second,
+			30,
+			30 * second
+		],
+		[
+			intervals.minute,
+			1,
+			minute
+		],
+		[
+			intervals.minute,
+			5,
+			5 * minute
+		],
+		[
+			intervals.minute,
+			15,
+			15 * minute
+		],
+		[
+			intervals.minute,
+			30,
+			30 * minute
+		],
+		[
+			intervals.hour,
+			1,
+			hour
+		],
+		[
+			intervals.hour,
+			3,
+			3 * hour
+		],
+		[
+			intervals.hour,
+			6,
+			6 * hour
+		],
+		[
+			intervals.hour,
+			12,
+			12 * hour
+		],
+		[
+			intervals.day,
+			1,
+			day
+		],
+		[
+			intervals.day,
+			2,
+			2 * day
+		],
+		[
+			intervals.week,
+			1,
+			week
+		],
+		[
+			intervals.month,
+			1,
+			month
+		],
+		[
+			intervals.month,
+			3,
+			3 * month
+		],
+		[
+			intervals.year,
+			1,
+			year
+		]
+	];
+	const target = Math.abs(stop - start) / count;
+	let i = 0;
+	while (i < table.length && (table[i]?.[2] ?? Infinity) <= target) i++;
+	if (i === table.length) return intervals.year.every(tickStep(start / year, stop / year, count));
+	if (i === 0) return intervals.millisecond.every(Math.max(tickStep(start, stop, count), 1));
+	const before = table[i - 1];
+	const after = table[i];
+	if (before === void 0 || after === void 0) return null;
+	const [interval, step] = target / before[2] < after[2] / target ? before : after;
+	return interval.every(step);
+}
+//#endregion
+//#region src/families/charts/chart-scale/scale-time.ts
+const defaultDomain = Object.freeze([Date.UTC(2e3, 0, 1), Date.UTC(2e3, 0, 2)]);
+const unitRange = Object.freeze([0, 1]);
+function epochOf(value) {
+	if (value === null || value === void 0) return NaN;
+	return value instanceof Date ? value.getTime() : +value;
+}
+function identity(value) {
+	return value;
+}
+/**
+* Create an immutable, calendar-aware time scale.
+*
+* Ticks, nice domains, and labels are computed in `timeZone` (default `"UTC"`),
+* never in the host's local zone, so server rendering and hydration agree. With
+* `"UTC"` the ticks equal d3's `scaleUtc`; with an IANA zone they follow the
+* same calendar rules as d3's local `scaleTime` would in that zone.
+*
+* @example
+* ```ts
+* const x = scaleTime({ domain: [start, end], range: [0, 640], timeZone: "Asia/Tokyo" });
+* const format = x.tickFormat({ locale: "ja-JP" });
+* x.ticks(6).map(format);
+* ```
+*/
+function scaleTime(options = {}) {
+	const intervals = zoneIntervals(options.timeZone ?? "UTC");
+	const timeZone = intervals.clock.timeZone;
+	let domain = Object.freeze((options.domain ?? defaultDomain).map(epochOf));
+	const niceCount = options.nice === true ? 10 : options.nice === false ? null : options.nice ?? null;
+	if (niceCount !== null) {
+		const first = domain[0] ?? 0;
+		const last = domain.at(-1) ?? 0;
+		const interval = timeTickInterval(intervals, first, last, niceCount, tickStep);
+		if (interval !== null) {
+			const next = [...domain];
+			const [i0, i1] = last < first ? [next.length - 1, 0] : [0, next.length - 1];
+			next[i0] = interval.floor(Math.min(first, last));
+			next[i1] = interval.ceil(Math.max(first, last));
+			domain = Object.freeze(next);
+		}
+	}
+	const range = Object.freeze([...options.range ?? unitRange]);
+	const core = createContinuousCore({
+		clamp: options.clamp ?? false,
+		domain,
+		range,
+		round: options.round ?? false,
+		transform: identity,
+		unknown: options.unknown ?? NaN,
+		untransform: identity
+	});
+	const current = {
+		...options,
+		domain,
+		range,
+		nice: false,
+		timeZone
+	};
+	const first = domain[0] ?? 0;
+	const last = domain.at(-1) ?? 0;
+	const tickGranularity = (date) => {
+		const t = date.getTime();
+		if (intervals.second.floor(t) < t) return "millisecond";
+		if (intervals.minute.floor(t) < t) return "second";
+		if (intervals.hour.floor(t) < t) return "minute";
+		if (intervals.day.floor(t) < t) return "hour";
+		if (intervals.month.floor(t) < t) return intervals.week.floor(t) < t ? "day" : "week";
+		if (intervals.year.floor(t) < t) return "month";
+		return "year";
+	};
+	const scale = Object.assign((value) => core.map(epochOf(value)), {
+		kind: "time",
+		timeZone,
+		range,
+		clamp: options.clamp ?? false,
+		round: options.round ?? false,
+		invert: (value) => new Date(core.invert(value)),
+		ticks: (count = 10) => {
+			const reverse = last < first;
+			const [start, stop] = reverse ? [last, first] : [first, last];
+			const interval = timeTickInterval(intervals, start, stop, count, tickStep);
+			const dates = (interval === null ? [] : interval.range(start, stop + 1)).map((epoch) => new Date(epoch));
+			return reverse ? dates.reverse() : dates;
+		},
+		tickGranularity,
+		tickFormat: (format = {}) => timeTickFormat(timeZone, tickGranularity, format),
+		nice: (count = 10) => scaleTime({
+			...current,
+			nice: count
+		}),
+		with: (next) => scaleTime({
+			...current,
+			...next
+		}),
+		options: () => ({ ...current })
+	});
+	Object.defineProperty(scale, "domain", {
+		enumerable: true,
+		get: () => Object.freeze(domain.map((epoch) => new Date(epoch)))
+	});
+	return scale;
+}
+//#endregion
+export { scalePoint as C, scaleOrdinal as S, tickIncrement as _, createContinuousCore as a, discreteKey as b, scalePow as c, numberTickFormat as d, timeTickFormat as f, precisionFixed as g, niceExtent as h, zoneIntervals as i, scaleSqrt as l, decimalExponent as m, createZoneClock as n, scaleLinear as o, bisectRight as p, timeTickInterval as r, scaleLog as s, scaleTime as t, defaultTimeTickFormats as u, tickStep as v, scaleBand as x, ticks as y };