minerva-design 1.0.2 → 1.2.0

package/dist/weapp/controls.js

@@ -431,7 +431,7 @@ var ref = /* @__NO_SIDE_EFFECTS__ */ (name) => ({
 	kind: "ref",
 	name
 });
-var mix = /* @__NO_SIDE_EFFECTS__ */ (a, amount, b) => ({
+var mix$1 = /* @__NO_SIDE_EFFECTS__ */ (a, amount, b) => ({
 	kind: "mix",
 	a,
 	amount,
@@ -482,20 +482,20 @@ function mergeBlocks(...blocks) {
 var lengthCss = (value) => value === 0 ? "0" : `${value}px`;
 /** CSS text of a token value, exactly as written in `tokens.css`. */
 /*#__NO_SIDE_EFFECTS__*/
-function toCss(value) {
+function toCss$1(value) {
 	if (typeof value === "string") return value;
 	if (typeof value === "number") return String(value);
 	switch (value.kind) {
 		case "ref": return `var(--${value.name})`;
-		case "mix": return `color-mix(in srgb, ${/* @__PURE__ */ toCss(value.a)} ${value.amount}%, ${/* @__PURE__ */ toCss(value.b)})`;
+		case "mix": return `color-mix(in srgb, ${/* @__PURE__ */ toCss$1(value.a)} ${value.amount}%, ${/* @__PURE__ */ toCss$1(value.b)})`;
 		case "length": return value.value === 0 ? "0" : `${value.value}${value.unit}`;
-		case "clamp": return `clamp(${/* @__PURE__ */ toCss(value.min)}, ${value.vw}vw, ${/* @__PURE__ */ toCss(value.max)})`;
+		case "clamp": return `clamp(${/* @__PURE__ */ toCss$1(value.min)}, ${value.vw}vw, ${/* @__PURE__ */ toCss$1(value.max)})`;
 		case "shadow": return value.layers.length === 0 ? "none" : value.layers.map((layer) => [
 			lengthCss(layer.x),
 			lengthCss(layer.y),
 			lengthCss(layer.blur),
 			...layer.spread === void 0 ? [] : [lengthCss(layer.spread)],
-			/* @__PURE__ */ toCss(layer.color)
+			/* @__PURE__ */ toCss$1(layer.color)
 		].join(" ")).join(", ");
 		case "transition": return `${value.duration}ms ${value.easing}`;
 		case "cubic-bezier": return `cubic-bezier(${value.points.join(", ")})`;
@@ -605,7 +605,7 @@ var radiusTokens = {
 		"radius-2xl": /* @__PURE__ */ px$1(24)
 	}
 };
-var faded = /* @__NO_SIDE_EFFECTS__ */ (amount) => /* @__PURE__ */ mix(/* @__PURE__ */ ref("shadow-color"), amount, "transparent");
+var faded = /* @__NO_SIDE_EFFECTS__ */ (amount) => /* @__PURE__ */ mix$1(/* @__PURE__ */ ref("shadow-color"), amount, "transparent");
 /** Shadow scale ("standard" keeps the theme / palette shadows: no block). */
 var shadowTokens = {
 	none: {
@@ -710,21 +710,21 @@ var shadowColor = /* @__PURE__ */ ref("shadow-color");
 /** Semantic tokens derived from the base tokens. */
 var semanticTokens = {
 	"surface-color": bg,
-	"surface-muted-color": /* @__PURE__ */ mix(fg, 6, bg),
+	"surface-muted-color": /* @__PURE__ */ mix$1(fg, 6, bg),
 	"surface-elevated-color": bg,
-	"surface-subtle-color": /* @__PURE__ */ mix(fg, 3, bg),
+	"surface-subtle-color": /* @__PURE__ */ mix$1(fg, 3, bg),
 	"canvas-color": /* @__PURE__ */ ref("surface-subtle-color"),
 	"control-color": /* @__PURE__ */ ref("surface-subtle-color"),
 	"hover-color": /* @__PURE__ */ ref("surface-muted-color"),
-	"selected-color": /* @__PURE__ */ mix(/* @__PURE__ */ ref("primary-color"), 14, surface),
-	"overlay-color": /* @__PURE__ */ mix("#000000", 45, "transparent"),
-	"border-strong-color": /* @__PURE__ */ mix(fg, 35, bg),
+	"selected-color": /* @__PURE__ */ mix$1(/* @__PURE__ */ ref("primary-color"), 14, surface),
+	"overlay-color": /* @__PURE__ */ mix$1("#000000", 45, "transparent"),
+	"border-strong-color": /* @__PURE__ */ mix$1(fg, 35, bg),
 	"text-color": fg,
-	"text-secondary-color": /* @__PURE__ */ mix(fg, 75, bg),
-	"text-muted-color": /* @__PURE__ */ mix(fg, 62, bg),
-	"text-disabled-color": /* @__PURE__ */ mix(fg, 45, bg),
+	"text-secondary-color": /* @__PURE__ */ mix$1(fg, 75, bg),
+	"text-muted-color": /* @__PURE__ */ mix$1(fg, 62, bg),
+	"text-disabled-color": /* @__PURE__ */ mix$1(fg, 45, bg),
 	"text-inverse-color": "#ffffff",
-	"focus-ring-color": /* @__PURE__ */ mix(/* @__PURE__ */ ref("primary-color"), 45, "transparent"),
+	"focus-ring-color": /* @__PURE__ */ mix$1(/* @__PURE__ */ ref("primary-color"), 45, "transparent"),
 	"shadow-sm": /* @__PURE__ */ shadow({
 		x: 0,
 		y: 1,
@@ -765,11 +765,11 @@ var ROLE_COLORS = [
 var roleTokens = /* @__NO_SIDE_EFFECTS__ */ (color) => {
 	const c = /* @__PURE__ */ ref(`${color}-color`);
 	return {
-		[`${color}-color-hover`]: /* @__PURE__ */ mix(c, 85, fg),
-		[`${color}-color-active`]: /* @__PURE__ */ mix(c, 72, fg),
-		[`${color}-color-subtle`]: /* @__PURE__ */ mix(c, 12, surface),
-		[`${color}-color-border`]: /* @__PURE__ */ mix(c, 40, surface),
-		[`${color}-color-text`]: /* @__PURE__ */ mix(c, 80, fg)
+		[`${color}-color-hover`]: /* @__PURE__ */ mix$1(c, 85, fg),
+		[`${color}-color-active`]: /* @__PURE__ */ mix$1(c, 72, fg),
+		[`${color}-color-subtle`]: /* @__PURE__ */ mix$1(c, 12, surface),
+		[`${color}-color-border`]: /* @__PURE__ */ mix$1(c, 40, surface),
+		[`${color}-color-text`]: /* @__PURE__ */ mix$1(c, 80, fg)
 	};
 };
 /** Role tokens of every role color. */
@@ -1535,7 +1535,7 @@ var reducedMotionTokens = {
 //#endregion
 //#region ../core/src/tokens/color.ts
 /** CSS basic named colors (+ `transparent`) */
-var NAMED = {
+var NAMED$1 = {
 	black: "#000000",
 	silver: "#c0c0c0",
 	gray: "#808080",
@@ -1559,7 +1559,7 @@ var NAMED = {
 	transparent: "#00000000"
 };
 var clamp = (value, min, max) => Math.min(max, Math.max(min, value));
-function parseHex(hex) {
+function parseHex$1(hex) {
 	if (!/^[\da-f]+$/i.test(hex)) return void 0;
 	const digits = hex.length === 3 || hex.length === 4 ? hex.replace(/./g, (d) => d + d) : hex;
 	if (digits.length !== 6 && digits.length !== 8) return void 0;
@@ -1618,7 +1618,7 @@ function mixArgument(text) {
 	const trailing = /^(.+?)\s+(-?[\d.]+)%$/s.exec(text);
 	const leading = /^(-?[\d.]+)%\s+(.+)$/s.exec(text);
 	const [colorText, pctText] = trailing ? [trailing[1], trailing[2]] : leading ? [leading[2], leading[1]] : [text, void 0];
-	const color = parseColor(colorText);
+	const color = parseColor$1(colorText);
 	if (!color) return void 0;
 	return {
 		color,
@@ -1631,10 +1631,10 @@ function mixArgument(text) {
 * `transparent` and `color-mix(in srgb, ...)` (nested mixes included).
 * Returns `undefined` for anything else (system colors, other color spaces).
 */
-function parseColor(text) {
+function parseColor$1(text) {
 	const value = text.trim().toLowerCase();
-	if (value.startsWith("#")) return parseHex(value.slice(1));
-	if (value in NAMED) return parseHex(NAMED[value].slice(1));
+	if (value.startsWith("#")) return parseHex$1(value.slice(1));
+	if (value in NAMED$1) return parseHex$1(NAMED$1[value].slice(1));
 	const fn = /^([a-z-]+)\((.*)\)$/s.exec(value);
 	if (!fn) return void 0;
 	const [, name, args] = fn;
@@ -1874,7 +1874,7 @@ function evaluateShadow(text, context) {
 			if (length === void 0) rest.push(part);
 			else lengths.push(length);
 		}
-		const color = parseColor(rest.length ? rest.join(" ") : "black");
+		const color = parseColor$1(rest.length ? rest.join(" ") : "black");
 		if (lengths.length < 2 || lengths.length > 4 || !color) return void 0;
 		const [x, y, blur = 0, spread = 0] = lengths;
 		layers.push({
@@ -1895,7 +1895,7 @@ function evaluateShadow(text, context) {
 		l.color
 	].join(" ")).join(", ");
 	const first = layers[0];
-	const color = parseColor(first.color);
+	const color = parseColor$1(first.color);
 	return {
 		css,
 		layers,
@@ -2062,7 +2062,7 @@ function tokenCascade({ mode = "light", palette, design: designOptions, override
 	const chosen = palette === void 0 ? presetPalette(design.preset) : palette;
 	const values = /* @__PURE__ */ new Map();
 	const apply = (block) => {
-		for (const [name, value] of Object.entries(block)) if (value !== void 0) values.set(name, /* @__PURE__ */ toCss(value));
+		for (const [name, value] of Object.entries(block)) if (value !== void 0) values.set(name, /* @__PURE__ */ toCss$1(value));
 	};
 	apply(defaultThemeTokens);
 	apply(scaleTokens);
@@ -2085,7 +2085,7 @@ var pxCss = (value) => `${round(value)}px`;
 function evaluate(kind, text, context) {
 	switch (kind) {
 		case "color": {
-			const color = parseColor(text);
+			const color = parseColor$1(text);
 			if (!color) return void 0;
 			const css = formatColor(color);
 			return {
@@ -3546,19 +3546,19 @@ var messages = {
 //#endregion
 //#region ../core/src/time.ts
 var TOKEN_PATTERN = /(HH|H|hh|h|mm|m|ss|s|a)/g;
-var pad = (n) => String(n).padStart(2, "0");
+var pad$1 = (n) => String(n).padStart(2, "0");
 /** Format a time with tokens HH / H / hh / h / mm / m / ss / s / a */
-var formatTime = (date, format) => {
+var formatTime$1 = (date, format) => {
 	const hours24 = date.getHours();
 	const hours12 = hours24 % 12 || 12;
 	const values = {
-		HH: pad(hours24),
+		HH: pad$1(hours24),
 		H: String(hours24),
-		hh: pad(hours12),
+		hh: pad$1(hours12),
 		h: String(hours12),
-		mm: pad(date.getMinutes()),
+		mm: pad$1(date.getMinutes()),
 		m: String(date.getMinutes()),
-		ss: pad(date.getSeconds()),
+		ss: pad$1(date.getSeconds()),
 		s: String(date.getSeconds()),
 		a: hours24 >= 12 ? "PM" : "AM"
 	};
@@ -3630,7 +3630,7 @@ var parseTimeValue = (text) => {
 	return date;
 };
 /** The value string of `date`: `HH:mm:ss`, or `HH:mm` without seconds. */
-var toTimeValue = (date, withSeconds) => formatTime(date, withSeconds ? "HH:mm:ss" : "HH:mm");
+var toTimeValue = (date, withSeconds) => formatTime$1(date, withSeconds ? "HH:mm:ss" : "HH:mm");
 /** Seconds since midnight (compares times of day). */
 var secondsOfDay = (date) => date.getHours() * 3600 + date.getMinutes() * 60 + date.getSeconds();
 /** Whether a display format contains a seconds token (`ss` / `s`) */
@@ -4026,11 +4026,11 @@ var base = {
 	dir: "ltr",
 	messages
 };
-var text$6 = (value = "") => ({
+var text$7 = (value = "") => ({
 	type: String,
 	value
 });
-var optional$6 = (value = null) => ({
+var optional$7 = (value = null) => ({
 	type: null,
 	value
 });
@@ -4240,19 +4240,19 @@ function enhanceConfiguration(c, consumers) {
 		provider.template = `<view class="mn-provider {{themeClass}}" style="direction:{{effectiveDir}};{{themeStyle}}"><slot/></view>`;
 		def.properties = {
 			...def.properties,
-			mode: text$6(),
-			theme: optional$6(""),
-			palette: optional$6(""),
-			design: optional$6({}),
-			locale: optional$6(),
-			dir: text$6(),
-			defaultTheme: text$6(kind === "theme" ? "system" : ""),
-			defaultPalette: optional$6(""),
+			mode: text$7(),
+			theme: optional$7(""),
+			palette: optional$7(""),
+			design: optional$7({}),
+			locale: optional$7(),
+			dir: text$7(),
+			defaultTheme: text$7(kind === "theme" ? "system" : ""),
+			defaultPalette: optional$7(""),
 			disableStorage: {
 				type: Boolean,
 				value: kind !== "theme"
 			},
-			storageKey: text$6("minerva-theme")
+			storageKey: text$7("minerva-theme")
 		};
 		def.data = {
 			themeClass: "mn-root",
@@ -4369,13 +4369,13 @@ function enhanceConfiguration(c, consumers) {
 	const toggle = c.themeToggle;
 	toggle.template = `<view class="mn-theme-toggle" role="group"><button wx:for="{{themeChoices}}" wx:key="value" class="mn-theme-choice mn-button mn-variant-outline {{item.value===activeTheme?'mn-active':''}} {{disabled?'mn-disabled':''}}" aria-pressed="{{item.value===activeTheme}}" disabled="{{disabled}}" data-value="{{item.value}}" bindtap="onChoose">{{item.label}}</button></view>`;
 	Object.assign(toggle.definition.properties, {
-		value: optional$6(),
+		value: optional$7(),
 		showSystem: {
 			type: Boolean,
 			value: true
 		},
-		labels: optional$6({}),
-		customThemes: optional$6([])
+		labels: optional$7({}),
+		customThemes: optional$7([])
 	});
 	toggle.definition.data = {
 		...toggle.definition.data,
@@ -4399,7 +4399,7 @@ function enhanceConfiguration(c, consumers) {
 	const palette = c.paletteToggle;
 	palette.definition.properties = {
 		...palette.definition.properties,
-		value: optional$6("")
+		value: optional$7("")
 	};
 	palette.definition.data = {
 		...palette.definition.data,
@@ -4558,7 +4558,7 @@ function enhanceFeedback(c) {
 }
 //#endregion
 //#region src/basic-components.ts
-var text$5 = (value = "") => ({
+var text$6 = (value = "") => ({
 	type: String,
 	value
 });
@@ -4566,11 +4566,11 @@ var number$3 = (value = 0) => ({
 	type: Number,
 	value
 });
-var flag$7 = (value = false) => ({
+var flag$8 = (value = false) => ({
 	type: Boolean,
 	value
 });
-var optional$5 = (value = null) => ({
+var optional$6 = (value = null) => ({
 	type: null,
 	value
 });
@@ -4785,11 +4785,11 @@ function textareaSync(self) {
 	self.setData({ text: self.data.value === null ? self.data.localText : self.data.value });
 }
 function enhanceBasics(c) {
-	Object.assign(c.statCard.definition.properties, { icon: text$5() });
+	Object.assign(c.statCard.definition.properties, { icon: text$6() });
 	c.statCard.template = c.statCard.template.replace("<text class=\"mn-muted\">{{label}}</text>", "<view class=\"mn-stat-heading\"><text class=\"mn-muted\">{{label}}</text><view aria-hidden=\"true\"><slot name=\"icon\"/>{{icon}}</view></view>");
 	Object.assign(c.loadingState.definition.properties, {
-		size: text$5("medium"),
-		label: text$5()
+		size: text$6("medium"),
+		label: text$6()
 	});
 	c.loadingState.template = c.loadingState.template.replace("class=\"mn-loading-state\"", "class=\"mn-loading-state mn-loading-{{size}}\" role=\"status\" aria-live=\"polite\" aria-atomic=\"true\"").replace("{{label}}", "{{label || loadingLabel}}");
 	c.loadingState.definition.observers = {
@@ -4801,15 +4801,15 @@ function enhanceBasics(c) {
 	c.loadingState.definition.lifetimes = { attached() {
 		this.setData({ loadingLabel: nativeTranslate(this, "loadingState.label") });
 	} };
-	Object.assign(c.textLink.definition.properties, { variant: text$5("default") });
+	Object.assign(c.textLink.definition.properties, { variant: text$6("default") });
 	c.textLink.template = c.textLink.template.replaceAll("class=\"mn-text-link", "class=\"mn-text-link mn-text-link-{{variant}}").replaceAll("{{label}}</", "{{label}}<text wx:if=\"{{variant!=='default'}}\" class=\"mn-text-link-chevron\" aria-hidden=\"true\">›</text></");
 	patch$2(c.input, `<view class="mn-input-wrapper mn-input-{{variant}} mn-control-{{size}} {{invalid?'mn-invalid':''}} {{disabled?'mn-disabled':''}}"><text wx:if="{{prefix}}">{{prefix}}</text><slot name="prefix"/><input class="mn-input {{disabled || readOnly?'mn-disabled':''}}" value="{{text}}" disabled="{{disabled || readOnly}}" placeholder="{{placeholder}}" name="{{name}}" type="{{type==='password'?'text':type}}" password="{{(password || type==='password') && !passwordVisible}}" maxlength="{{maxlength}}" focus="{{focused}}" aria-invalid="{{invalid}}" aria-required="{{required}}" bindinput="onInput" bindfocus="onFocus" bindblur="onBlur" bindconfirm="onConfirm"/><button wx:if="{{clearable && text && !disabled && !readOnly}}" class="mn-close mn-input-clear" aria-label="{{clearText}}" bindtap="onClear">×</button><button wx:if="{{password || type==='password'}}" class="mn-close mn-password-toggle {{disabled?'mn-disabled':''}}" disabled="{{disabled}}" aria-label="{{passwordVisible?hidePasswordText:showPasswordText}}" bindtap="onPassword">{{passwordVisible?hidePasswordText:showPasswordText}}</button><text wx:if="{{showCharCount}}" class="mn-muted">{{text.length}}{{maxlength>0?' / '+maxlength:''}}</text><text wx:if="{{suffix}}">{{suffix}}</text><slot name="suffix"/></view>`, {
-		value: optional$5(),
-		defaultValue: text$5(),
+		value: optional$6(),
+		defaultValue: text$6(),
 		maxlength: number$3(-1),
-		clearLabel: text$5(),
-		showPasswordLabel: text$5(),
-		hidePasswordLabel: text$5()
+		clearLabel: text$6(),
+		showPasswordLabel: text$6(),
+		hidePasswordLabel: text$6()
 	}, {
 		onInput(e) {
 			if (blocked$4(this)) return this.data.text;
@@ -4859,14 +4859,14 @@ function enhanceBasics(c) {
 		} }
 	});
 	patch$2(c.divider, `<view class="mn-native-divider {{isVertical?'mn-native-divider-vertical':''}} {{elevation?'mn-divider-elevated':''}} mn-divider-align-{{textAlign}} mn-divider" role="separator" aria-orientation="{{isVertical?'vertical':'horizontal'}}" style="{{dividerStyle}}"><view class="mn-divider-line" style="{{lineStyle}}"/><text wx:if="{{!isVertical && label}}" class="mn-divider-label">{{label}}</text><view wx:if="{{!isVertical && label}}" class="mn-divider-line" style="{{lineStyle}}"/></view>`, {
-		orientation: text$5("horizontal"),
-		variant: text$5("solid"),
+		orientation: text$6("horizontal"),
+		variant: text$6("solid"),
 		thickness: number$3(1),
-		length: optional$5(),
+		length: optional$6(),
 		spacing: number$3(16),
-		textAlign: text$5("center"),
-		elevation: flag$7(),
-		flexItem: flag$7()
+		textAlign: text$6("center"),
+		elevation: flag$8(),
+		flexItem: flag$8()
 	}, {}, {
 		data: {
 			dividerStyle: "",
@@ -4881,13 +4881,13 @@ function enhanceBasics(c) {
 		} }
 	});
 	patch$2(c.empty, `<view class="mn-empty {{size?'mn-empty-'+size:''}} {{showShadow?'mn-empty-shadow':''}}" style="{{emptyStyle}}" role="status" aria-label="{{title}}"><view wx:if="{{icon!==null && icon!==false}}" class="mn-empty-icon"><slot name="icon"/><view wx:if="{{useSvg && !icon}}" class="mn-empty-illustration"><view class="mn-empty-ellipse"/><view class="mn-empty-box"/><view class="mn-empty-box-lip"/></view><text>{{icon || (useSvg?'':'□')}}</text></view><text wx:if="{{title}}" class="mn-title">{{title}}</text><text wx:if="{{descriptionText!==null}}" class="mn-muted">{{descriptionText}}</text><view class="mn-empty-actions"><slot name="action"/><slot name="secondaryAction"/></view><slot/></view>`, {
-		size: text$5(),
-		width: optional$5(),
-		height: optional$5(),
-		showShadow: flag$7(),
-		icon: optional$5(""),
-		description: optional$5(""),
-		useSvg: flag$7()
+		size: text$6(),
+		width: optional$6(),
+		height: optional$6(),
+		showShadow: flag$8(),
+		icon: optional$6(""),
+		description: optional$6(""),
+		useSvg: flag$8()
 	}, {}, {
 		data: {
 			emptyStyle: "",
@@ -4901,14 +4901,14 @@ function enhanceBasics(c) {
 		} }
 	});
 	patch$2(c.iconButton, `<view class="mn-icon-button-root"><button class="mn-button mn-icon-button mn-size-{{size}} mn-color-{{color}} mn-variant-{{variant}} mn-icon-shape-{{shape}} {{disabled || loading?'mn-disabled':''}} {{effectivePressed?'mn-active':''}}" aria-label="{{label}}" aria-pressed="{{isToggle?effectivePressed:undefined}}" aria-busy="{{loading}}" disabled="{{disabled || loading}}" bindtap="onTap" bindlongpress="onTooltip"><view wx:if="{{loading}}" class="mn-spinner"/><block wx:else><slot/>{{icon}}</block></button><view wx:if="{{tooltipVisible && tooltipEnabled}}" class="mn-tooltip mn-popup mn-color-{{tooltip.color || 'neutral'}} mn-variant-{{tooltip.variant || 'solid'}} mn-tooltip-{{tooltip.shape || 'default'}}" bindtap="onTooltipClose">{{tooltipText}}</view></view>`, {
-		size: text$5("medium"),
-		color: text$5("neutral"),
-		shape: text$5("circle"),
-		pressed: optional$5(),
-		defaultPressed: optional$5(),
-		toggle: flag$7(),
-		tooltip: optional$5({}),
-		showTooltip: optional$5()
+		size: text$6("medium"),
+		color: text$6("neutral"),
+		shape: text$6("circle"),
+		pressed: optional$6(),
+		defaultPressed: optional$6(),
+		toggle: flag$8(),
+		tooltip: optional$6({}),
+		showTooltip: optional$6()
 	}, {
 		onTap() {
 			if (this.data.disabled || this.data.loading) return;
@@ -4942,18 +4942,18 @@ function enhanceBasics(c) {
 		} }
 	});
 	patch$2(c.jsonField, `<view class="mn-json-field"><textarea class="mn-input mn-code mn-textarea mn-textarea-{{size}} mn-input-{{variant}} {{invalid || !jsonValid?'mn-invalid':''}} {{disabled || readOnly?'mn-disabled':''}}" value="{{text}}" disabled="{{disabled || readOnly}}" placeholder="{{placeholder}}" style="min-height:{{rows*24}}px" maxlength="{{maxlength}}" aria-invalid="{{invalid || !jsonValid}}" bindinput="onInput"/><view wx:if="{{!hideToolbar}}" class="mn-json-toolbar"><button class="mn-close mn-json-format" aria-label="{{formatText}}" disabled="{{disabled || readOnly || !jsonValid}}" bindtap="onFormat">{{formatText}}</button></view><text wx:if="{{text}}" class="{{jsonValid?'mn-muted':'mn-error'}}" role="status">{{jsonValid?validText:error}}</text></view>`, {
-		value: optional$5(),
-		defaultValue: text$5(),
+		value: optional$6(),
+		defaultValue: text$6(),
 		indent: number$3(2),
-		hideToolbar: flag$7(),
-		formatLabel: text$5(),
-		validLabel: text$5(),
-		invalidLabel: text$5(),
+		hideToolbar: flag$8(),
+		formatLabel: text$6(),
+		validLabel: text$6(),
+		invalidLabel: text$6(),
 		rows: number$3(8),
-		size: text$5("medium"),
-		variant: text$5("outline"),
-		invalid: flag$7(),
-		placeholder: text$5(),
+		size: text$6("medium"),
+		variant: text$6("outline"),
+		invalid: flag$8(),
+		placeholder: text$6(),
 		maxlength: number$3(-1)
 	}, {
 		onInput(e) {
@@ -4980,27 +4980,27 @@ function enhanceBasics(c) {
 		} }
 	});
 	Object.assign(c.radio.definition.properties, {
-		name: text$5(),
-		size: text$5("medium"),
-		color: text$5("primary"),
-		error: flag$7(),
-		required: flag$7(),
-		errorMessage: text$5(),
-		helperText: text$5(),
-		errorIcon: text$5("!"),
-		ariaLabel: text$5()
+		name: text$6(),
+		size: text$6("medium"),
+		color: text$6("primary"),
+		error: flag$8(),
+		required: flag$8(),
+		errorMessage: text$6(),
+		helperText: text$6(),
+		errorIcon: text$6("!"),
+		ariaLabel: text$6()
 	});
 	c.radio.template = `<view role="radio" aria-label="{{ariaLabel || label}}" aria-checked="{{effectiveChecked}}" aria-disabled="{{disabled}}" aria-invalid="{{error}}" aria-required="{{required}}" class="mn-choice mn-choice-size-{{size}} mn-choice-color-{{color}} {{disabled || readOnly?'mn-disabled':''}} {{error?'mn-invalid':''}}" bindtap="onChoose"><text class="mn-choice-indicator mn-radio {{effectiveChecked?'mn-active':''}}">{{effectiveChecked?'●':''}}</text><view class="mn-choice-content"><text>{{label}}</text><slot/></view><text wx:if="{{error && errorMessage || helperText}}" class="mn-choice-helper {{error?'mn-error':''}}"><block wx:if="{{error}}"><slot name="errorIcon"/>{{errorIcon}}</block>{{error && errorMessage?errorMessage:helperText}}</text></view>`;
 	patch$2(c.radioGroup, `<view class="mn-radio-group mn-{{direction}} {{error?'mn-invalid':''}}" role="radiogroup" aria-label="{{ariaLabel || label}}" aria-required="{{required}}" aria-invalid="{{error}}"><text wx:if="{{label}}">{{label}}</text><view wx:for="{{options}}" wx:key="value" class="mn-choice mn-choice-size-{{size || item.size || 'medium'}} mn-choice-color-{{color || item.color || 'primary'}} {{disabled || readOnly || item.disabled?'mn-disabled':''}}" role="radio" aria-checked="{{effectiveValue===item.value}}" aria-disabled="{{disabled || item.disabled}}" data-index="{{index}}" bindtap="onSelect"><text class="mn-choice-indicator mn-radio {{effectiveValue===item.value?'mn-active':''}}">{{effectiveValue===item.value?'●':''}}</text><text>{{item.label}}</text></view><slot/><text wx:if="{{helperText}}" class="mn-choice-helper {{error?'mn-error':''}}">{{helperText}}</text></view>`, {
-		value: optional$5(groupUnset),
-		defaultValue: optional$5(),
-		label: text$5(),
-		ariaLabel: text$5(),
-		size: text$5(),
-		color: text$5(),
-		required: flag$7(),
-		error: flag$7(),
-		helperText: text$5()
+		value: optional$6(groupUnset),
+		defaultValue: optional$6(),
+		label: text$6(),
+		ariaLabel: text$6(),
+		size: text$6(),
+		color: text$6(),
+		required: flag$8(),
+		error: flag$8(),
+		helperText: text$6()
 	}, { onSelect(e) {
 		const o = this.data.options[Number(e.currentTarget.dataset.index)];
 		if (blocked$4(this) || !o || o.disabled || o.value === this.data.effectiveValue) return;
@@ -5021,18 +5021,18 @@ function enhanceBasics(c) {
 		} }
 	});
 	patch$2(c.select, `<view class="mn-select"><button class="mn-input mn-select-trigger mn-control-{{size}} {{invalid?'mn-invalid':''}} {{disabled || readOnly?'mn-disabled':''}}" role="combobox" aria-expanded="{{expanded}}" aria-invalid="{{invalid}}" aria-required="{{required}}" aria-label="{{ariaLabel}}" disabled="{{disabled || readOnly}}" bindtap="onToggle">{{selectedLabel || placeholder}} ▾</button><view wx:if="{{expanded}}" class="mn-popup {{contentClassName}}" role="listbox"><input wx:if="{{searchable}}" class="mn-input" value="{{query}}" placeholder="{{searchLabel}}" bindinput="onQuery"/><block wx:for="{{filtered}}" wx:key="key"><view wx:if="{{item.type==='label'}}" class="mn-select-group">{{item.label}}</view><view wx:elif="{{item.type==='separator'}}" class="mn-divider" role="separator"/><button wx:else role="option" aria-selected="{{effectiveValue===item.value}}" class="mn-option {{effectiveValue===item.value?'mn-active':''}} {{item.disabled?'mn-disabled':''}}" disabled="{{item.disabled}}" data-index="{{index}}" bindtap="onChoose"><text>{{item.icon}}</text>{{item.label}}<text class="mn-muted">{{item.description}}</text></button></block><text wx:if="{{!filtered.length}}" class="mn-muted">{{emptyLabel}}</text><slot name="content"/></view><slot/></view>`, {
-		value: optional$5(),
-		defaultValue: text$5(),
-		open: optional$5(),
-		defaultOpen: flag$7(),
-		size: text$5("medium"),
-		invalid: flag$7(),
-		required: flag$7(),
-		name: text$5(),
-		ariaLabel: text$5(),
-		contentClassName: text$5(),
-		searchPlaceholder: text$5(),
-		emptyText: text$5()
+		value: optional$6(),
+		defaultValue: text$6(),
+		open: optional$6(),
+		defaultOpen: flag$8(),
+		size: text$6("medium"),
+		invalid: flag$8(),
+		required: flag$8(),
+		name: text$6(),
+		ariaLabel: text$6(),
+		contentClassName: text$6(),
+		searchPlaceholder: text$6(),
+		emptyText: text$6()
 	}, {
 		onToggle() {
 			selectOpen(this, !this.data.expanded);
@@ -5071,13 +5071,13 @@ function enhanceBasics(c) {
 		} }
 	});
 	patch$2(c.tabs, `<view class="mn-tabs mn-tabs-{{orientation}} mn-tabs-{{variant}} mn-color-{{color}}" style="direction:{{dir}}"><view class="mn-tabs-list" role="tablist" aria-orientation="{{orientation}}"><view wx:for="{{items}}" wx:key="value" class="mn-tab mn-color-{{item.color || color}} {{item.value===effectiveValue?'mn-active':''}}"><button class="mn-option {{disabled || item.disabled?'mn-disabled':''}}" role="tab" aria-selected="{{item.value===effectiveValue}}" disabled="{{disabled || item.disabled}}" data-index="{{index}}" bindtap="onChoose">{{item.label}}</button></view></view><block wx:for="{{items}}" wx:key="value"><view wx:if="{{item.forceMount || item.value===effectiveValue}}" hidden="{{item.value!==effectiveValue}}" class="mn-tab-panel" role="tabpanel">{{item.content}}<slot name="{{item.value}}"/></view></block><slot/></view>`, {
-		value: optional$5(),
-		defaultValue: text$5(),
-		orientation: text$5("horizontal"),
-		variant: text$5("line"),
-		color: text$5("primary"),
-		dir: text$5("ltr"),
-		activationMode: text$5("automatic")
+		value: optional$6(),
+		defaultValue: text$6(),
+		orientation: text$6("horizontal"),
+		variant: text$6("line"),
+		color: text$6("primary"),
+		dir: text$6("ltr"),
+		activationMode: text$6("automatic")
 	}, { onChoose(e) {
 		const item = this.data.items[Number(e.currentTarget.dataset.index)];
 		if (blocked$4(this) || !item || item.disabled || item.value === this.data.effectiveValue) return;
@@ -5098,22 +5098,22 @@ function enhanceBasics(c) {
 		} }
 	});
 	patch$2(c.skeleton, `<view wx:if="{{loading}}" class="mn-skeleton-root {{effectiveVariant==='card'?'mn-skeleton-card-root':''}} {{active?'mn-skeleton-active':''}}" role="{{decorative?'none':'status'}}" aria-hidden="{{decorative}}" aria-busy="{{!decorative}}" aria-label="{{loadingLabel}}"><view wx:if="{{avatar && !decorative}}" class="mn-skeleton mn-skeleton-{{avatarShape}} mn-skeleton-{{animation}}" style="{{avatarStyle}}"/><view class="mn-skeleton-lines"><view wx:if="{{title && !decorative}}" class="mn-skeleton mn-skeleton-title mn-skeleton-{{animation}}"/><view wx:if="{{paragraph && !decorative}}" wx:for="{{paragraphLines}}" wx:key="*this" class="mn-skeleton mn-skeleton-paragraph mn-skeleton-{{animation}}" style="width:{{item}}"/><view wx:for="{{lineItems}}" wx:key="*this" class="mn-skeleton mn-skeleton-line mn-skeleton-{{effectiveVariant}} mn-skeleton-{{animation}}" style="{{lineStyle}}"/></view></view><block wx:else><slot/></block>`, {
-		variant: text$5("text"),
-		animation: text$5("pulse"),
-		decorative: flag$7(),
-		size: optional$5(),
-		width: optional$5(),
-		height: optional$5(),
-		loading: flag$7(true),
-		borderRadius: optional$5(),
+		variant: text$6("text"),
+		animation: text$6("pulse"),
+		decorative: flag$8(),
+		size: optional$6(),
+		width: optional$6(),
+		height: optional$6(),
+		loading: flag$8(true),
+		borderRadius: optional$6(),
 		lines: number$3(1),
-		avatar: flag$7(),
-		avatarSize: optional$5(40),
-		avatarShape: text$5("circle"),
-		active: flag$7(),
-		paragraph: flag$7(),
-		title: flag$7(),
-		ariaLabel: text$5()
+		avatar: flag$8(),
+		avatarSize: optional$6(40),
+		avatarShape: text$6("circle"),
+		active: flag$8(),
+		paragraph: flag$8(),
+		title: flag$8(),
+		ariaLabel: text$6()
 	}, {}, {
 		data: {
 			lineItems: [],
@@ -5129,11 +5129,11 @@ function enhanceBasics(c) {
 		} }
 	});
 	patch$2(c.skeletonText, `<view class="mn-skeleton-text" style="{{textStyle}}" aria-hidden="true"><view wx:for="{{lineItems}}" wx:key="*this" class="mn-skeleton mn-skeleton-{{animation}}" style="{{lineStyle}};width:{{shrinkLast && index===lineItems.length-1?lastLineWidth:'100%'}}"/></view>`, {
-		lineHeight: optional$5("1em"),
-		gap: optional$5(2),
-		shrinkLast: flag$7(true),
-		lastLineWidth: text$5("70%"),
-		animation: text$5("pulse")
+		lineHeight: optional$6("1em"),
+		gap: optional$6(2),
+		shrinkLast: flag$8(true),
+		lastLineWidth: text$6("70%"),
+		animation: text$6("pulse")
 	}, {}, {
 		data: {
 			lineItems: [
@@ -5160,20 +5160,20 @@ function enhanceBasics(c) {
 		} }
 	});
 	patch$2(c.tooltip, `<view class="mn-popover"><view class="mn-popover-trigger" bindtap="onToggle" bindlongpress="onEnter" bindtouchend="onLeave"><slot/></view><view wx:if="{{visible}}" class="mn-popup mn-tooltip mn-placement-{{placement}} mn-color-{{color}} mn-variant-{{variant}} mn-tooltip-{{shape}} mn-tooltip-animation-{{animation}} {{contentClassName}}" style="{{tooltipStyle}}" role="tooltip" aria-label="{{ariaLabel}}"><view wx:if="{{arrow}}" class="mn-tooltip-arrow"/><text>{{content}}</text><button class="mn-close" bindtap="close">×</button><slot name="content"/></view></view>`, {
-		open: optional$5(),
-		defaultOpen: flag$7(),
-		placement: text$5("top"),
-		color: text$5("neutral"),
-		variant: text$5("solid"),
-		shape: text$5("default"),
-		animation: text$5("fade"),
+		open: optional$6(),
+		defaultOpen: flag$8(),
+		placement: text$6("top"),
+		color: text$6("neutral"),
+		variant: text$6("solid"),
+		shape: text$6("default"),
+		animation: text$6("fade"),
 		enterDelay: number$3(200),
 		leaveDelay: number$3(),
-		offset: optional$5([0, 0]),
+		offset: optional$6([0, 0]),
 		zIndex: number$3(1500),
-		arrow: flag$7(),
-		contentClassName: text$5(),
-		ariaLabel: text$5()
+		arrow: flag$8(),
+		contentClassName: text$6(),
+		ariaLabel: text$6()
 	}, {
 		open() {
 			tooltipRequest(this, true);
@@ -5214,10 +5214,10 @@ function enhanceBasics(c) {
 		}
 	});
 	patch$2(c.codeBlock, `<view class="mn-code-block"><view class="mn-row"><text class="mn-muted">{{language}}</text><button wx:if="{{copyable}}" class="mn-close" bindtap="onCopy">{{copyLabel}}</button></view><scroll-view scroll-x="{{!wrap}}" scroll-y style="{{codeStyle}}" role="region" aria-label="{{codeRegionLabel}}"><text class="mn-code" selectable style="white-space:{{wrap?'pre-wrap':'pre'}};word-break:{{wrap?'break-word':'normal'}}">{{code}}</text></scroll-view><text class="mn-visually-hidden" aria-live="polite">{{copyStatus}}</text></view>`, {
-		wrap: flag$7(true),
-		maxHeight: optional$5("24rem"),
-		ariaLabel: text$5(),
-		copyable: flag$7()
+		wrap: flag$8(true),
+		maxHeight: optional$6("24rem"),
+		ariaLabel: text$6(),
+		copyable: flag$8()
 	}, { onCopy() {
 		const sourceText = this.data.code;
 		wx.setClipboardData({
@@ -5268,23 +5268,23 @@ function enhanceBasics(c) {
 		}
 	});
 	patch$2(c.list, `<view class="mn-list mn-list-{{density}} {{bordered?'mn-list-bordered':''}} {{dividers && divided?'mn-list-divided':''}}" role="{{role}}"><view wx:for="{{items}}" wx:key="index" class="mn-list-item {{item.disabled?'mn-disabled':''}}" role="listitem" data-index="{{index}}" bindtap="onItem"><text wx:if="{{item.icon}}" aria-hidden="true">{{item.icon}}</text><view class="mn-list-content"><text>{{item.primary===undefined?item.title:item.primary}}</text><text class="mn-muted">{{item.secondary===undefined?item.description:item.secondary}}</text></view><view class="mn-list-actions">{{item.actions}}<slot name="{{'actions-'+index}}"/></view></view><slot/></view>`, {
-		density: text$5("default"),
-		bordered: flag$7(),
-		dividers: flag$7(true),
-		role: text$5("list")
+		density: text$6("default"),
+		bordered: flag$8(),
+		dividers: flag$8(true),
+		role: text$6("list")
 	});
 	patch$2(c.descriptionList, `<view class="mn-description-list {{bordered?'mn-list-bordered':''}} {{striped?'mn-list-striped':''}}" style="grid-template-columns:repeat({{columns}},minmax(0,1fr))"><view wx:for="{{items}}" wx:key="key" class="mn-description-item {{striped && index%2===1?'mn-row-striped':''}}"><text class="mn-muted">{{item.label}}</text><text>{{item.value}}</text><slot name="{{item.key}}"/></view><slot/></view>`, {
-		bordered: flag$7(),
-		striped: flag$7()
+		bordered: flag$8(),
+		striped: flag$8()
 	});
 	patch$2(c.textarea, `<textarea class="mn-input mn-textarea mn-textarea-{{size}} mn-input-{{variant}} {{invalid?'mn-invalid':''}} {{disabled || readOnly?'mn-disabled':''}}" value="{{text}}" disabled="{{disabled || readOnly}}" name="{{name}}" placeholder="{{placeholder}}" maxlength="{{maxlength}}" auto-height="{{autoHeight}}" style="{{rows?'min-height:'+rows*24+'px':''}}" aria-invalid="{{invalid}}" aria-required="{{required}}" bindinput="onInput" bindfocus="onFocus" bindblur="onBlur"/>`, {
-		value: optional$5(),
-		defaultValue: text$5(),
-		size: text$5("medium"),
-		variant: text$5("outline"),
-		invalid: flag$7(),
-		required: flag$7(),
-		name: text$5(),
+		value: optional$6(),
+		defaultValue: text$6(),
+		size: text$6("medium"),
+		variant: text$6("outline"),
+		invalid: flag$8(),
+		required: flag$8(),
+		name: text$6(),
 		rows: number$3()
 	}, {
 		onInput(e) {
@@ -5316,21 +5316,21 @@ function enhanceBasics(c) {
 	const switchChange = c.toggle.definition.methods.onChange;
 	Object.assign(c.toggle.definition.options ?? (c.toggle.definition.options = {}), { multipleSlots: true });
 	Object.assign(c.toggle.definition.properties, {
-		size: text$5("medium"),
-		color: text$5("primary"),
-		shape: text$5("round"),
-		variant: text$5("slider"),
-		label: text$5(),
-		offLabel: text$5(),
-		onLabel: text$5(),
-		labelPlacement: text$5("end"),
-		loading: flag$7(),
-		ripple: flag$7(true),
-		trackStyle: optional$5({}),
-		thumbStyle: optional$5({}),
-		icon: text$5(),
-		iconPlacement: text$5("start"),
-		value: text$5("on")
+		size: text$6("medium"),
+		color: text$6("primary"),
+		shape: text$6("round"),
+		variant: text$6("slider"),
+		label: text$6(),
+		offLabel: text$6(),
+		onLabel: text$6(),
+		labelPlacement: text$6("end"),
+		loading: flag$8(),
+		ripple: flag$8(true),
+		trackStyle: optional$6({}),
+		thumbStyle: optional$6({}),
+		icon: text$6(),
+		iconPlacement: text$6("start"),
+		value: text$6("on")
 	});
 	Object.assign(c.toggle.definition.methods, {
 		onChange(e) {
@@ -5363,7 +5363,7 @@ function enhanceBasics(c) {
 }
 //#endregion
 //#region src/advanced-components.ts
-var text$4 = (value = "") => ({
+var text$5 = (value = "") => ({
 	type: String,
 	value
 });
@@ -5371,11 +5371,11 @@ var number$2 = (value = 0) => ({
 	type: Number,
 	value
 });
-var flag$6 = (value = false) => ({
+var flag$7 = (value = false) => ({
 	type: Boolean,
 	value
 });
-var optional$4 = (value = null) => ({
+var optional$5 = (value = null) => ({
 	type: null,
 	value
 });
@@ -5653,17 +5653,17 @@ function commandOpen(self, open) {
 }
 function enhanceAdvanced(c) {
 	patch$1(c.drawer, `<view class="mn-drawer-root"><view class="mn-drawer-trigger" bindtap="onOpen"><slot name="trigger"/></view><view wx:if="{{visible || forceMount}}" hidden="{{!visible}}" class="mn-overlay {{modal?'':'mn-drawer-nonmodal'}}"><view class="mn-backdrop {{modal?'':'mn-backdrop-clear'}} {{overlayClassName}}" bindtap="onBackdrop"/><view class="mn-dialog mn-drawer mn-drawer-{{effectiveSide}} mn-drawer-{{size}}" role="{{role}}" aria-modal="{{modal}}" aria-label="{{title}}"><view class="mn-row"><slot name="header"/><text class="mn-title">{{title}}</text><button wx:if="{{!hideCloseButton}}" class="mn-close mn-drawer-close" aria-label="{{closeText}}" disabled="{{loading}}" bindtap="onClose">×</button></view><text class="{{description?'mn-muted':'mn-visually-hidden'}}">{{descriptionText}}</text><view class="mn-dialog-content"><slot/></view><slot name="footer"/></view></view></view>`, {
-		open: optional$4(),
-		defaultOpen: flag$6(),
-		side: text$4(),
-		size: text$4("medium"),
-		modal: flag$6(true),
-		forceMount: flag$6(),
-		hideCloseButton: flag$6(),
-		closeLabel: text$4(),
-		hiddenDescription: text$4(),
-		role: text$4("dialog"),
-		overlayClassName: text$4()
+		open: optional$5(),
+		defaultOpen: flag$7(),
+		side: text$5(),
+		size: text$5("medium"),
+		modal: flag$7(true),
+		forceMount: flag$7(),
+		hideCloseButton: flag$7(),
+		closeLabel: text$5(),
+		hiddenDescription: text$5(),
+		role: text$5("dialog"),
+		overlayClassName: text$5()
 	}, {
 		configure(config) {
 			drawers.set(this, config);
@@ -5705,15 +5705,15 @@ function enhanceAdvanced(c) {
 	};
 	c.modal.template = c.drawer.template.replaceAll("mn-drawer", "mn-modal").replace(" mn-modal-{{effectiveSide}}", "").replace("<text class=\"{{description?'mn-muted':'mn-visually-hidden'}}\">{{descriptionText}}</text>", "<text wx:if=\"{{description}}\" class=\"mn-muted\">{{description}}</text>");
 	patch$1(c.virtualList, `<scroll-view scroll-y class="mn-virtual-list" scroll-top="{{scrollTop}}" style="max-height:{{effectiveHeight}}px;height:{{effectiveHeight}}px" role="list" aria-label="{{ariaLabel}}" aria-busy="{{loading || loadingMore}}" bindscroll="onScroll"><view style="height:{{before}}px"/><view wx:for="{{visible}}" wx:key="key" class="mn-list-item mn-virtual-item" role="listitem" style="{{rowHeight?'height:'+rowHeight+'px;':''}}padding:{{itemPadding}}px;box-sizing:border-box" data-index="{{item.index}}" bindtap="onItem"><view class="mn-virtual-content"><row-renderer wx:if="{{customRowRenderer}}" row="{{item.item}}" value="{{item.label}}" row-index="{{item.index}}"/><text wx:else>{{item.label}}</text></view></view><view style="height:{{after}}px"/><view wx:if="{{loading || loadingMore}}" class="mn-virtual-loading"><view class="mn-spinner"/>{{localeLabels.loading}}</view><slot name="footer"/></scroll-view>`, {
-		itemHeight: optional$4(),
-		maxHeight: optional$4(),
+		itemHeight: optional$5(),
+		maxHeight: optional$5(),
 		itemPadding: number$2(8),
 		overscan: number$2(5),
 		loadMoreThreshold: number$2(100),
-		highPerformance: flag$6(),
-		loading: flag$6(),
-		ariaLabel: text$4(),
-		customRowRenderer: flag$6()
+		highPerformance: flag$7(),
+		loading: flag$7(),
+		ariaLabel: text$5(),
+		customRowRenderer: flag$7()
 	}, {
 		configure(config) {
 			virtualConfigs.set(this, config);
@@ -5783,16 +5783,16 @@ function enhanceAdvanced(c) {
 	});
 	Object.assign(c.virtualList, { componentGenerics: { "row-renderer": { default: "../table-cell-content/index" } } });
 	patch$1(c.upload, `<view class="mn-upload" role="group" aria-label="{{label}}" aria-busy="{{loading}}"><text>{{label}}</text><view wx:for="{{fileRows}}" wx:key="id" class="mn-upload-item"><image wx:if="{{item.previewUrl}}" class="mn-upload-preview" src="{{item.previewUrl}}" mode="aspectFit"/><text>{{item.name}}</text><text class="mn-muted">{{item.statusLabel}}</text><button wx:if="{{retryable && item.status==='error'}}" class="mn-close mn-upload-retry" disabled="{{disabled || loading}}" aria-label="{{item.retryLabel}}" data-index="{{index}}" bindtap="onRetry">↻</button><button wx:if="{{removable}}" class="mn-close mn-upload-remove" disabled="{{disabled}}" aria-label="{{item.removeLabel}}" data-index="{{index}}" bindtap="onRemove">×</button></view><button class="mn-button mn-variant-outline mn-upload-select" loading="{{loading}}" disabled="{{selectionBlocked}}" bindtap="onChoose">{{selectLabel}}</button><text wx:if="{{errorMessage}}" class="mn-error" role="alert">{{errorMessage}}</text><slot/></view>`, {
-		label: text$4(),
-		accept: text$4("*"),
-		multiple: flag$6(),
-		replace: flag$6(),
-		maxCount: optional$4(),
-		maxSize: optional$4(),
-		loading: flag$6(),
-		labels: optional$4({}),
-		removable: flag$6(true),
-		retryable: flag$6(true)
+		label: text$5(),
+		accept: text$5("*"),
+		multiple: flag$7(),
+		replace: flag$7(),
+		maxCount: optional$5(),
+		maxSize: optional$5(),
+		loading: flag$7(),
+		labels: optional$5({}),
+		removable: flag$7(true),
+		retryable: flag$7(true)
 	}, {
 		configure(config) {
 			uploadConfigs.set(this, config);
@@ -5862,28 +5862,28 @@ function enhanceAdvanced(c) {
 		}
 	});
 	patch$1(c.alert, `<view wx:if="{{!closed}}" class="mn-alert mn-color-{{effectiveColor}} mn-variant-{{variant}} mn-size-{{size}} {{banner?'mn-alert-banner':''}} {{elevation?'mn-alert-elevated':''}} {{rounded?'':'mn-alert-square'}} {{animation?'mn-alert-'+animationName:''}}" role="{{effectiveRole}}" style="{{radiusStyle}}"><view wx:if="{{showIcon}}" class="mn-alert-icon" aria-label="{{iconLabel}}"><slot name="icon"/><text wx:if="{{!customIcon}}">{{statusIcon}}</text></view><view class="mn-alert-main"><text class="mn-title">{{title}}</text><view wx:if="{{!collapsible || !title || effectiveExpanded}}" class="mn-alert-content"><text>{{description}}</text><slot/></view></view><slot name="action"/><button wx:if="{{collapsible && title}}" class="mn-close mn-alert-expand" aria-label="{{effectiveExpanded?collapseText:expandText}}" aria-expanded="{{effectiveExpanded}}" bindtap="onExpand">{{effectiveExpanded?'−':'+'}}</button><button wx:if="{{closable}}" class="mn-close mn-alert-close" aria-label="{{closeText}}" bindtap="onClose"><slot name="closeIcon"/><text wx:if="{{!customCloseIcon}}">{{closeIcon}}</text></button></view>`, {
-		color: text$4(),
-		variant: text$4("subtle"),
-		size: text$4("medium"),
-		showIcon: flag$6(true),
-		customIcon: flag$6(),
-		customCloseIcon: flag$6(),
-		icon: text$4(),
-		closeIcon: text$4("×"),
-		animation: flag$6(true),
-		animationName: text$4("slideIn"),
-		banner: flag$6(),
-		elevation: flag$6(),
-		rounded: flag$6(true),
-		borderRadius: optional$4(),
-		collapsible: flag$6(),
-		expanded: optional$4(),
-		defaultExpanded: flag$6(true),
-		closeLabel: text$4(),
-		expandLabel: text$4(),
-		collapseLabel: text$4(),
-		iconLabel: text$4(),
-		role: text$4()
+		color: text$5(),
+		variant: text$5("subtle"),
+		size: text$5("medium"),
+		showIcon: flag$7(true),
+		customIcon: flag$7(),
+		customCloseIcon: flag$7(),
+		icon: text$5(),
+		closeIcon: text$5("×"),
+		animation: flag$7(true),
+		animationName: text$5("slideIn"),
+		banner: flag$7(),
+		elevation: flag$7(),
+		rounded: flag$7(true),
+		borderRadius: optional$5(),
+		collapsible: flag$7(),
+		expanded: optional$5(),
+		defaultExpanded: flag$7(true),
+		closeLabel: text$5(),
+		expandLabel: text$5(),
+		collapseLabel: text$5(),
+		iconLabel: text$5(),
+		role: text$5()
 	}, {
 		onExpand() {
 			const expanded = !this.data.effectiveExpanded;
@@ -5921,12 +5921,12 @@ function enhanceAdvanced(c) {
 			"minH",
 			"maxW",
 			"maxH"
-		].map((key) => [key, optional$4()])),
-		bg: text$4(),
-		rounded: text$4(),
-		boxShadow: text$4(),
-		border: text$4(),
-		customStyle: optional$4({})
+		].map((key) => [key, optional$5()])),
+		bg: text$5(),
+		rounded: text$5(),
+		boxShadow: text$5(),
+		border: text$5(),
+		customStyle: optional$5({})
 	}, {}, {
 		data: { boxStyle: "" },
 		observers: { "**": function() {
@@ -5937,15 +5937,15 @@ function enhanceAdvanced(c) {
 		} }
 	});
 	patch$1(c.commandDialog, `<view class="mn-command-root"><view bindtap="onOpen"><slot name="trigger"/></view><view wx:if="{{visible}}" class="mn-overlay"><view class="mn-backdrop" bindtap="onClose"/><view class="mn-dialog" role="dialog" aria-label="{{commandLabels.title}}"><text class="mn-title">{{commandLabels.title}}</text><text>{{shortcutLabel}}</text><text class="mn-muted">{{commandLabels.description}}</text><input class="mn-input mn-command-input" value="{{query}}" placeholder="{{commandLabels.placeholder}}" bindinput="onQuery"/><view role="listbox" aria-label="{{commandLabels.results}}"><button wx:for="{{results}}" wx:key="id" class="mn-option" data-index="{{index}}" bindtap="onSelect"><text>{{item.title}}</text><text class="mn-muted">{{item.description}}</text><text>{{item.group}}</text></button></view><text wx:if="{{!results.length}}">{{commandLabels.empty}}</text><slot/></view></view></view>`, {
-		open: optional$4(),
-		defaultOpen: flag$6(),
-		title: text$4(),
-		description: text$4(),
-		placeholder: text$4(),
-		emptyText: text$4(),
-		shortcutLabel: text$4(),
-		resultsLabel: text$4(),
-		enterLabel: text$4()
+		open: optional$5(),
+		defaultOpen: flag$7(),
+		title: text$5(),
+		description: text$5(),
+		placeholder: text$5(),
+		emptyText: text$5(),
+		shortcutLabel: text$5(),
+		resultsLabel: text$5(),
+		enterLabel: text$5()
 	}, {
 		configure(config) {
 			commands.set(this, config);
@@ -6024,8 +6024,39 @@ var configurations = {
 	dataTable: method("configure", "configure(config: NativeTableConfig): void", "Same callbacks as Table; pagination receives already paginated rows by default."),
 	popover: method("configure", "configure(config: NativePopoverConfig): void", "Optional measure() supplies native anchor/panel/viewport rectangles; onInteractOutside() returning false prevents dismissal."),
 	configProvider: method("configure", "configure(config: { messages?: Record<string, Messages> }): void", "Merge custom message trees per language into the inherited core translations and refresh descendants."),
-	themeProvider: method("configure", "configure(config: { messages?: Record<string, Messages> }): void", "Merge custom message trees per language into inherited translations.")
+	themeProvider: method("configure", "configure(config: { messages?: Record<string, Messages> }): void", "Merge custom message trees per language into inherited translations."),
+	quadrantChart: method("configure", "configure(config: NativeQuadrantChartConfig): void", "renderTooltip(point, index) returns the tooltip text of a point (lines separated by \\n) or null to hide it.")
 };
+var chartConfiguration = method("configure", "configure(config: NativeChartConfig): void", "Function options: xAxis.format / yAxis.format tick formatters and renderTooltip(event) returning the tooltip text (lines separated by \\n) or null to hide it.");
+for (const name of [
+	"chart",
+	"lineChart",
+	"barChart",
+	"scatterChart"
+]) configurations[name] = chartConfiguration;
+var chartMethods = [
+	method("resize", "resize(): void", "Measure the canvas again after a host layout change (e.g. a chart created hidden)."),
+	method("resetZoom", "resetZoom(): void", "Show the whole data range."),
+	method("getView", "getView(): NativeChartView | null", "Visible axis ranges; null before the canvas is ready."),
+	method("setView", "setView(view: Partial<NativeChartView>): void", "Set the visible axis ranges."),
+	method("getPlotRect", "getPlotRect(): NativeChartRect | null", "Plot area in px of the chart, for host overlays."),
+	method("toPixel", "toPixel(x: number, y: number): { x: number; y: number } | null", "Data coordinates to px of the chart."),
+	method("fromPixel", "fromPixel(x: number, y: number): { x: number; y: number } | null", "Px of the chart to data coordinates.")
+];
+var chartEvent = {
+	hover: event("hover", "{ items: NativeChartHoverItem[]; x: number | null; xLabel: string }", "Highlighted points after a tap or a finger scrub; items is empty when cleared."),
+	zoom: event("zoom", "{ x: [number, number]; y: [number, number] }", "Visible range after a pinch, a pan or a double-tap reset."),
+	layout: event("layout", "{ x: number; y: number; width: number; height: number }", "The plot area moved or was resized (px of the chart).")
+};
+var seriesChartEvents = [
+	chartEvent.hover,
+	event("pointclick", "{ items: NativeChartHoverItem[]; x: number; xLabel: string }", "A point or bar was tapped."),
+	event("plotclick", "{ x: number; y: number }", "The plot area was tapped where there is no point (data coordinates)."),
+	chartEvent.zoom,
+	chartEvent.layout,
+	event("pointdrag", "{ item: NativeChartHoverItem; x: number; y: number }", "A scatter point is dragged (interaction.dragPoints); the data is not changed."),
+	event("pointdrop", "{ item: NativeChartHoverItem; x: number; y: number }", "A dragged scatter point was released; update the series to move it.")
+];
 var tableEvents = [
 	event("sortchange", "{ sortState: { key: string; order: 'ascend' | 'descend' | null } }", "Requested sort state."),
 	event("selectionchange", "{ selectedRowKeys: Array<string | number>; selectedRows: Record<string, unknown>[] }", "Requested row selection, excluding disabled rows from select-all."),
@@ -6035,6 +6066,19 @@ var tableEvents = [
 	event("cellaction", "{ row: Record<string, unknown>; key: string | number; index: number; columnKey: string; detail: unknown }", "Action emitted from a native rich cell or custom cell-renderer Component.")
 ];
 var events = {
+	chart: seriesChartEvents,
+	lineChart: seriesChartEvents,
+	barChart: seriesChartEvents,
+	scatterChart: seriesChartEvents,
+	quadrantChart: [
+		chartEvent.hover,
+		event("pointclick", "{ point: NativeQuadrantPoint; index: number }", "A dot was tapped."),
+		event("quadrantclick", "{ quadrant: 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight'; x: number; y: number }", "The empty area of a quadrant was tapped."),
+		event("pointdrag", "{ point: NativeQuadrantPoint; index: number; target: NativeQuadrantDropTarget }", "A dot is dragged (draggable)."),
+		event("pointdrop", "{ point: NativeQuadrantPoint; index: number; target: NativeQuadrantDropTarget }", "A dragged dot was released; update points to move it."),
+		chartEvent.zoom,
+		chartEvent.layout
+	],
 	drawer: [
 		open,
 		event("close", "{ reason: 'trigger' | 'close' | 'overlay' }", "Close reason."),
@@ -6133,6 +6177,13 @@ function annotateNativeApi(controls) {
 		if (name === "tagInput") methods.push(method("paste", "paste(text: string, start?: number, end?: number): void", "Insert delimited clipboard text at the supplied draft selection; native input does not expose browser clipboard ranges."));
 		if (name === "confirmProvider") methods.push(method("request", "request(options: NativeConfirmOptions): Promise<boolean>", "Queue a native confirmation and resolve on confirm/cancel or provider teardown."));
 		if (configurations[name]) methods.push(configurations[name]);
+		if ([
+			"chart",
+			"lineChart",
+			"barChart",
+			"scatterChart",
+			"quadrantChart"
+		].includes(name)) methods.push(...chartMethods);
 		if ([
 			"responsiveGrid",
 			"formLayout",
@@ -6155,6 +6206,3693 @@ function annotateNativeApi(controls) {
 	}
 }
 //#endregion
+//#region ../charts/src/engine/color.ts
+var clamp01 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+var parseHex = (hex) => {
+	const h = hex.slice(1);
+	if (!/^[0-9a-f]+$/i.test(h)) return null;
+	const expand = h.length === 3 || h.length === 4;
+	if (!expand && h.length !== 6 && h.length !== 8) return null;
+	const channel = (i) => expand ? parseInt(h[i] + h[i], 16) / 255 : parseInt(h.slice(i * 2, i * 2 + 2), 16) / 255;
+	const hasAlpha = h.length === 4 || h.length === 8;
+	return [
+		channel(0),
+		channel(1),
+		channel(2),
+		hasAlpha ? channel(3) : 1
+	];
+};
+var parseComponent = (part, scale) => {
+	const v = parseFloat(part);
+	if (Number.isNaN(v)) return 0;
+	return part.trim().endsWith("%") ? v / 100 : v / scale;
+};
+/** Splits `a b c / d` or `a, b, c, d` */
+var splitArgs = (args) => {
+	const [main, alpha] = args.split("/");
+	const parts = main.split(/[\s,]+/).filter(Boolean);
+	if (alpha !== void 0) parts.push(alpha.trim());
+	return parts;
+};
+/**
+* Parses the color syntaxes returned by `getComputedStyle` (`rgb()`,
+* `rgba()`, `color(srgb ...)`) and hex colors; `null` for anything else
+* (named colors, `oklch()`, ... are resolved by `resolveColor`).
+*/
+var parseColor = (input) => {
+	const value = input.trim().toLowerCase();
+	if (value.startsWith("#")) return parseHex(value);
+	if (value === "transparent") return [
+		0,
+		0,
+		0,
+		0
+	];
+	let match = /^rgba?\((.*)\)$/.exec(value);
+	if (match) {
+		const parts = splitArgs(match[1]);
+		if (parts.length < 3) return null;
+		return [
+			clamp01(parseComponent(parts[0], 255)),
+			clamp01(parseComponent(parts[1], 255)),
+			clamp01(parseComponent(parts[2], 255)),
+			parts[3] === void 0 ? 1 : clamp01(parseComponent(parts[3], 1))
+		];
+	}
+	match = /^color\(srgb\s+(.*)\)$/.exec(value);
+	if (match) {
+		const parts = splitArgs(match[1]);
+		if (parts.length < 3) return null;
+		return [
+			clamp01(parseComponent(parts[0], 1)),
+			clamp01(parseComponent(parts[1], 1)),
+			clamp01(parseComponent(parts[2], 1)),
+			parts[3] === void 0 ? 1 : clamp01(parseComponent(parts[3], 1))
+		];
+	}
+	return null;
+};
+/** Splits the arguments of `var(--name, fallback)` (the fallback may contain commas) */
+var parseVar = (value) => {
+	const match = /^var\(\s*(--[\w-]+)\s*(?:,([\s\S]*))?\)$/.exec(value.trim());
+	if (!match) return null;
+	const fallback = match[2]?.trim();
+	return {
+		name: match[1],
+		...fallback ? { fallback } : {}
+	};
+};
+/**
+* Resolves a color without a DOM (mini-programs, React Native, workers):
+* hex, `rgb()`, `transparent` and `var(--name, fallback)` looked up in
+* `variables` (nested fallbacks included).
+*/
+var resolveStaticColor = (value, variables = {}, fallback = [
+	.4,
+	.4,
+	.4,
+	1
+], depth = 0) => {
+	const direct = parseColor(value);
+	if (direct) return direct;
+	const ref = depth < 8 ? parseVar(value) : null;
+	if (ref) {
+		const defined = variables[ref.name];
+		if (defined) return resolveStaticColor(defined, variables, fallback, depth + 1);
+		if (ref.fallback) return resolveStaticColor(ref.fallback, variables, fallback, depth + 1);
+	}
+	return NAMED[value.trim().toLowerCase()] ?? fallback;
+};
+var NAMED = {
+	black: [
+		0,
+		0,
+		0,
+		1
+	],
+	white: [
+		1,
+		1,
+		1,
+		1
+	],
+	red: [
+		1,
+		0,
+		0,
+		1
+	],
+	green: [
+		0,
+		128 / 255,
+		0,
+		1
+	],
+	blue: [
+		0,
+		0,
+		1,
+		1
+	],
+	gray: [
+		128 / 255,
+		128 / 255,
+		128 / 255,
+		1
+	],
+	grey: [
+		128 / 255,
+		128 / 255,
+		128 / 255,
+		1
+	],
+	orange: [
+		1,
+		165 / 255,
+		0,
+		1
+	]
+};
+/** `rgba()` string usable by Canvas2D and the DOM */
+var toCss = (c, alpha = 1) => `rgba(${Math.round(c[0] * 255)}, ${Math.round(c[1] * 255)}, ${Math.round(c[2] * 255)}, ${+(c[3] * alpha).toFixed(3)})`;
+/** Packs a color as little-endian `unorm8x4` (r in the lowest byte) */
+var packColor = (c) => (Math.round(clamp01(c[3]) * 255) << 24 | Math.round(clamp01(c[2]) * 255) << 16 | Math.round(clamp01(c[1]) * 255) << 8 | Math.round(clamp01(c[0]) * 255)) >>> 0;
+/** Mixes two colors (t = 0 -> a, 1 -> b) */
+var mix = (a, b, t) => [
+	a[0] + (b[0] - a[0]) * t,
+	a[1] + (b[1] - a[1]) * t,
+	a[2] + (b[2] - a[2]) * t,
+	a[3] + (b[3] - a[3]) * t
+];
+//#endregion
+//#region ../charts/src/engine/data.ts
+var isColumns = (data) => typeof data === "object" && data !== null && !("length" in data) && "y" in data;
+/** Converts an x value to a number for the axis type */
+var xResolver = (type, categoryIndex) => {
+	return (value, index) => {
+		if (typeof value === "number") return value;
+		if (value instanceof Date) return value.getTime();
+		if (typeof value === "string") {
+			if (type === "category") return categoryIndex(value);
+			if (type === "time") return Date.parse(value);
+			const n = Number(value);
+			return Number.isNaN(n) ? index : n;
+		}
+		return index;
+	};
+};
+var toNumber = (v) => typeof v === "number" ? v : v === null || v === void 0 ? NaN : Number(v);
+/** Category names used by string x values, in order of appearance */
+var collectCategories = (datas) => {
+	const seen = /* @__PURE__ */ new Set();
+	const add = (v) => {
+		if (typeof v === "string") seen.add(v);
+	};
+	for (const data of datas) {
+		if (isColumns(data)) {
+			const xs = data.x;
+			if (xs && !ArrayBuffer.isView(xs)) for (let i = 0; i < xs.length; i++) add(xs[i]);
+			continue;
+		}
+		const list = data;
+		for (let i = 0; i < list.length; i++) {
+			const item = list[i];
+			if (Array.isArray(item)) add(item[0]);
+			else if (item && typeof item === "object") add(item.x);
+		}
+	}
+	return [...seen];
+};
+var finalize = (x, y, count, extra) => {
+	let xMin = Infinity;
+	let xMax = -Infinity;
+	let yMin = Infinity;
+	let yMax = -Infinity;
+	let sorted = true;
+	let prev = -Infinity;
+	for (let i = 0; i < count; i++) {
+		const xi = x[i];
+		if (!Number.isFinite(xi)) {
+			y[i] = NaN;
+			continue;
+		}
+		if (xi < prev) sorted = false;
+		prev = xi;
+		const yi = y[i];
+		if (!Number.isFinite(yi)) continue;
+		if (xi < xMin) xMin = xi;
+		if (xi > xMax) xMax = xi;
+		if (yi < yMin) yMin = yi;
+		if (yi > yMax) yMax = yi;
+	}
+	const empty = xMin > xMax;
+	return {
+		x,
+		y,
+		count,
+		sorted,
+		xMin: empty ? NaN : xMin,
+		xMax: empty ? NaN : xMax,
+		yMin: empty ? NaN : yMin,
+		yMax: empty ? NaN : yMax,
+		...extra
+	};
+};
+/** Turns any supported data form into columns */
+var normalizeData = (data, resolveX) => {
+	const none = {
+		size: null,
+		colors: null,
+		labels: null
+	};
+	if (isColumns(data)) {
+		const count = data.y.length;
+		const x = new Float64Array(count);
+		const y = new Float64Array(count);
+		const xs = data.x;
+		for (let i = 0; i < count; i++) {
+			y[i] = toNumber(data.y[i]);
+			x[i] = xs ? resolveX(xs[i], i) : i;
+		}
+		let size = null;
+		if (data.size) {
+			size = new Float32Array(count);
+			for (let i = 0; i < count; i++) size[i] = toNumber(data.size[i]);
+		}
+		return finalize(x, y, count, {
+			...none,
+			size
+		});
+	}
+	const list = data;
+	const count = list.length;
+	const x = new Float64Array(count);
+	const y = new Float64Array(count);
+	let size = null;
+	let colors = null;
+	let labels = null;
+	for (let i = 0; i < count; i++) {
+		const item = list[i];
+		if (item === null || item === void 0 || typeof item === "number") {
+			x[i] = i;
+			y[i] = toNumber(item);
+		} else if (Array.isArray(item)) {
+			x[i] = resolveX(item[0], i);
+			y[i] = toNumber(item[1]);
+		} else if (typeof item === "object") {
+			const d = item;
+			x[i] = d.x === void 0 ? i : resolveX(d.x, i);
+			y[i] = toNumber(d.y);
+			if (d.size !== void 0) {
+				size ??= new Float32Array(count).fill(NaN);
+				size[i] = d.size;
+			}
+			if (d.color !== void 0) {
+				colors ??= new Array(count);
+				colors[i] = d.color;
+			}
+			if (d.label !== void 0) {
+				labels ??= new Array(count);
+				labels[i] = d.label;
+			}
+		} else {
+			x[i] = i;
+			y[i] = NaN;
+		}
+	}
+	return finalize(x, y, count, {
+		size,
+		colors,
+		labels
+	});
+};
+/** First index whose x is >= value (sorted x) */
+var lowerBound = (x, count, value) => {
+	let lo = 0;
+	let hi = count;
+	while (lo < hi) {
+		const mid = lo + hi >>> 1;
+		if (x[mid] < value) lo = mid + 1;
+		else hi = mid;
+	}
+	return lo;
+};
+/** Index of the point with the closest x and a finite y (sorted x), -1 if none */
+var nearestIndex = (x, y, count, value) => {
+	if (count === 0) return -1;
+	const i = lowerBound(x, count, value);
+	let left = i - 1;
+	let right = i;
+	while (left >= 0 && !Number.isFinite(y[left])) left--;
+	while (right < count && !Number.isFinite(y[right])) right++;
+	if (left < 0) return right < count ? right : -1;
+	if (right >= count) return left;
+	return value - x[left] <= x[right] - value ? left : right;
+};
+//#endregion
+//#region ../charts/src/engine/decimate.ts
+/**
+* Decimates the points `[start, end)` of a line with sorted x, given as
+* interleaved `x, y` values. `column` maps an x value to its pixel column.
+* Missing values (NaN or `gap`) are kept as a single NaN point so the
+* gaps survive.
+*/
+var decimateMinMax = (points, start, end, column, gap = Infinity) => {
+	const out = new Float64Array(Math.max(0, end - start) * 2);
+	let length = 0;
+	let col = NaN;
+	let first = -1;
+	let min = -1;
+	let max = -1;
+	let last = -1;
+	const push = (i) => {
+		out[length * 2] = points[i * 2];
+		out[length * 2 + 1] = points[i * 2 + 1];
+		length++;
+	};
+	const flush = () => {
+		if (first < 0) return;
+		push(first);
+		const lo = Math.min(min, max);
+		const hi = Math.max(min, max);
+		if (lo !== first) push(lo);
+		if (hi !== lo && hi !== first) push(hi);
+		if (last !== hi && last !== lo && last !== first) push(last);
+		first = -1;
+	};
+	const valid = (v) => Number.isFinite(v) && Math.abs(v) < gap;
+	for (let i = start; i < end; i++) {
+		const x = points[i * 2];
+		const y = points[i * 2 + 1];
+		if (!valid(x) || !valid(y)) {
+			flush();
+			col = NaN;
+			if (length > 0 && !Number.isNaN(out[length * 2 - 1])) {
+				out[length * 2] = x;
+				out[length * 2 + 1] = NaN;
+				length++;
+			}
+			continue;
+		}
+		const c = Math.floor(column(x));
+		if (c !== col || first < 0) {
+			flush();
+			col = c;
+			first = min = max = last = i;
+		} else {
+			if (y < points[min * 2 + 1]) min = i;
+			if (y > points[max * 2 + 1]) max = i;
+			last = i;
+		}
+	}
+	flush();
+	return {
+		points: out,
+		length
+	};
+};
+//#endregion
+//#region ../charts/src/engine/layout.ts
+var createScales = (plot, view, reverseX, reverseY) => {
+	const [x0, x1] = view.x;
+	const [y0, y1] = view.y;
+	const xs = plot.width / (x1 - x0 || 1);
+	const ys = plot.height / (y1 - y0 || 1);
+	const left = plot.x;
+	const right = plot.x + plot.width;
+	const top = plot.y;
+	const bottom = plot.y + plot.height;
+	return {
+		plot,
+		view,
+		xToPx: reverseX ? (v) => right - (v - x0) * xs : (v) => left + (v - x0) * xs,
+		yToPx: reverseY ? (v) => top + (v - y0) * ys : (v) => bottom - (v - y0) * ys,
+		pxToX: reverseX ? (p) => x0 + (right - p) / xs : (p) => x0 + (p - left) / xs,
+		pxToY: reverseY ? (p) => y0 + (p - top) / ys : (p) => y0 + (bottom - p) / ys,
+		xPerPx: 1 / xs,
+		yPerPx: 1 / ys
+	};
+};
+/** Room for the axes, then the plot area */
+var computePlot = (input) => {
+	const { width, height, padding, fontSize } = input;
+	const line = Math.ceil(fontSize * 1.4);
+	const left = padding.left + (input.yLabelWidth > 0 ? input.yLabelWidth + 8 : 0) + (input.yTitle ? line + 6 : 0);
+	const bottom = padding.bottom + (input.xAxisVisible ? line + 8 : 0) + (input.xTitle ? line + 4 : 0);
+	const top = padding.top;
+	const right = padding.right;
+	return {
+		x: Math.round(left),
+		y: Math.round(top),
+		width: Math.max(10, Math.round(width - left - right)),
+		height: Math.max(10, Math.round(height - top - bottom))
+	};
+};
+//#endregion
+//#region ../charts/src/engine/scale.ts
+var E10 = Math.sqrt(50);
+var E5 = Math.sqrt(10);
+var E2 = Math.sqrt(2);
+/** Tick step close to `(max - min) / count`, of the form 1, 2 or 5 × 10^k */
+var tickStep = (min, max, count) => {
+	const span = Math.abs(max - min);
+	if (!(span > 0) || !Number.isFinite(span)) return 0;
+	const raw = span / Math.max(1, count);
+	const base = 10 ** Math.floor(Math.log10(raw));
+	const error = raw / base;
+	return (error >= E10 ? 10 : error >= E5 ? 5 : error >= E2 ? 2 : 1) * base;
+};
+/** Rounds a value computed from a step (avoids 0.30000000000000004) */
+var roundTo = (value, step) => {
+	const decimals = Math.max(0, -Math.floor(Math.log10(step)) + 1);
+	return decimals > 0 && decimals < 20 ? +value.toFixed(decimals) : value;
+};
+/** Tick values inside [min, max] */
+var linearTicks = (min, max, count) => {
+	if (min > max) [min, max] = [max, min];
+	const step = tickStep(min, max, count);
+	if (!step) return Number.isFinite(min) ? [min] : [];
+	const start = Math.ceil(min / step - 1e-9);
+	const end = Math.floor(max / step + 1e-9);
+	const ticks = [];
+	for (let i = start; i <= end && ticks.length < 1e3; i++) ticks.push(roundTo(i * step, step));
+	return ticks;
+};
+/** Extends [min, max] to tick boundaries */
+var niceDomain = (min, max, count) => {
+	if (min > max) [min, max] = [max, min];
+	let step = tickStep(min, max, count);
+	for (let i = 0; i < 3 && step; i++) {
+		const nextMin = Math.floor(min / step) * step;
+		const nextMax = Math.ceil(max / step) * step;
+		min = roundTo(nextMin, step);
+		max = roundTo(nextMax, step);
+		const next = tickStep(min, max, count);
+		if (next === step) break;
+		step = next;
+	}
+	return [min, max];
+};
+/**
+* Range covering [min, max] with a usable span: a single value (or no data)
+* becomes a small range around it.
+*/
+var ensureSpan = (min, max, fallback = [0, 1]) => {
+	if (!Number.isFinite(min) || !Number.isFinite(max)) return fallback;
+	if (min > max) [min, max] = [max, min];
+	if (max - min > 0) return [min, max];
+	const pad = min === 0 ? 1 : Math.abs(min) * .1;
+	return [min - pad, max + pad];
+};
+/** Number of decimals that keeps ticks distinct for a step */
+var stepDecimals = (step) => step > 0 && Number.isFinite(step) ? Math.min(12, Math.max(0, -Math.floor(Math.log10(step) + 1e-9))) : 0;
+//#endregion
+//#region ../charts/src/engine/spatial.ts
+var GridIndex = class {
+	constructor(x, y, count, pointsPerCell = 4) {
+		let xMin = Infinity;
+		let xMax = -Infinity;
+		let yMin = Infinity;
+		let yMax = -Infinity;
+		let valid = 0;
+		for (let i = 0; i < count; i++) {
+			const xi = x[i];
+			const yi = y[i];
+			if (!Number.isFinite(xi) || !Number.isFinite(yi)) continue;
+			valid++;
+			if (xi < xMin) xMin = xi;
+			if (xi > xMax) xMax = xi;
+			if (yi < yMin) yMin = yi;
+			if (yi > yMax) yMax = yi;
+		}
+		const side = Math.min(1024, Math.max(1, Math.ceil(Math.sqrt(valid / pointsPerCell))));
+		this.cols = side;
+		this.rows = side;
+		this.x0 = valid ? xMin : 0;
+		this.y0 = valid ? yMin : 0;
+		this.cellW = valid && xMax > xMin ? (xMax - xMin) / side : 1;
+		this.cellH = valid && yMax > yMin ? (yMax - yMin) / side : 1;
+		const cells = new Int32Array(count);
+		const counts = new Uint32Array(side * side + 1);
+		for (let i = 0; i < count; i++) {
+			const xi = x[i];
+			const yi = y[i];
+			if (!Number.isFinite(xi) || !Number.isFinite(yi)) {
+				cells[i] = -1;
+				continue;
+			}
+			const cell = this.cellOf(xi, yi);
+			cells[i] = cell;
+			counts[cell + 1]++;
+		}
+		for (let c = 1; c < counts.length; c++) counts[c] += counts[c - 1];
+		this.starts = counts.slice();
+		const cursor = counts;
+		this.order = new Uint32Array(valid);
+		for (let i = 0; i < count; i++) {
+			const cell = cells[i];
+			if (cell >= 0) this.order[cursor[cell]++] = i;
+		}
+	}
+	column(xi) {
+		const c = Math.floor((xi - this.x0) / this.cellW);
+		return c < 0 ? 0 : c >= this.cols ? this.cols - 1 : c;
+	}
+	row(yi) {
+		const r = Math.floor((yi - this.y0) / this.cellH);
+		return r < 0 ? 0 : r >= this.rows ? this.rows - 1 : r;
+	}
+	cellOf(xi, yi) {
+		return this.row(yi) * this.cols + this.column(xi);
+	}
+	/** Calls `visit` with every point that may lie inside the box */
+	query(xMin, xMax, yMin, yMax, visit) {
+		if (this.order.length === 0) return;
+		const c0 = this.column(Math.min(xMin, xMax));
+		const c1 = this.column(Math.max(xMin, xMax));
+		const r0 = this.row(Math.min(yMin, yMax));
+		const r1 = this.row(Math.max(yMin, yMax));
+		for (let r = r0; r <= r1; r++) for (let c = c0; c <= c1; c++) {
+			const cell = r * this.cols + c;
+			for (let k = this.starts[cell]; k < this.starts[cell + 1]; k++) visit(this.order[k]);
+		}
+	}
+};
+//#endregion
+//#region ../charts/src/engine/model.ts
+var firstX = (data) => {
+	if (typeof data === "object" && data !== null && !("length" in data)) {
+		const xs = data.x;
+		return xs && xs.length ? xs[0] : void 0;
+	}
+	const list = data;
+	for (let i = 0; i < Math.min(list.length, 8); i++) {
+		const item = list[i];
+		if (Array.isArray(item)) return item[0];
+		if (item && typeof item === "object") return item.x;
+	}
+};
+/** Axis type when not given: dates -> time, strings -> category */
+var detectXType = (datas) => {
+	for (const data of datas) {
+		const x = firstX(data);
+		if (x instanceof Date) return "time";
+		if (typeof x === "string") return "category";
+	}
+	return "linear";
+};
+var axisModel = (options, type, categories, gridDefault) => ({
+	type,
+	reverse: !!options?.reverse,
+	categories,
+	title: options?.title,
+	format: options?.format,
+	grid: options?.grid ?? gridDefault,
+	visible: options?.visible ?? true,
+	tickCount: options?.tickCount
+});
+var extent = (values) => {
+	let min = Infinity;
+	let max = -Infinity;
+	for (let i = 0; i < values.length; i++) {
+		const v = values[i];
+		if (!Number.isFinite(v)) continue;
+		if (v < min) min = v;
+		if (v > max) max = v;
+	}
+	return [min, max];
+};
+/** Smallest positive gap between consecutive x values (bar width on numeric axes) */
+var smallestStep = (cols) => {
+	let step = Infinity;
+	for (const c of cols) {
+		const xs = c.sorted ? c.x : Float64Array.from(c.x).sort();
+		for (let i = 1; i < c.count; i++) {
+			const d = xs[i] - xs[i - 1];
+			if (d > 0 && d < step) step = d;
+		}
+	}
+	return step;
+};
+var buildModel = (options, theme, hidden, cache, resolver = null) => {
+	const resolve = resolver ?? theme.resolve ?? ((value, fallback) => resolveStaticColor(value, {}, fallback));
+	const input = options.series;
+	const datas = input.map((s) => s.data);
+	const xType = options.xAxis?.type ?? detectXType(datas);
+	const categories = xType === "category" ? [...options.xAxis?.categories ?? collectCategories(datas)] : [];
+	const categoryMap = new Map(categories.map((c, i) => [c, i]));
+	const resolveX = xResolver(xType, (name) => categoryMap.get(name) ?? NaN);
+	const resolverKey = `${xType}|${categories.join("
")}`;
+	const usedKeys = /* @__PURE__ */ new Set();
+	const series = input.map((s, index) => {
+		let key = s.id ?? `#${index}`;
+		while (usedKeys.has(key)) key += "'";
+		usedKeys.add(key);
+		let entry = cache.get(key);
+		if (!entry || entry.data !== s.data || entry.resolverKey !== resolverKey) {
+			entry = {
+				data: s.data,
+				resolverKey,
+				cols: normalizeData(s.data, resolveX)
+			};
+			cache.set(key, entry);
+		}
+		const type = s.type ?? "line";
+		const color = s.color ? resolve(s.color, theme.palette[index % theme.palette.length]) : theme.palette[index % theme.palette.length];
+		const cols = entry.cols;
+		let pointColors = null;
+		if (type === "scatter" && cols.colors) {
+			const resolved = /* @__PURE__ */ new Map();
+			pointColors = cols.colors.map((c) => {
+				if (c === void 0) return void 0;
+				let rgba = resolved.get(c);
+				if (!rgba) resolved.set(c, rgba = resolve(c, color));
+				return rgba;
+			});
+		}
+		const id = s.id ?? String(index);
+		return {
+			index,
+			key,
+			id,
+			name: s.name ?? `Series ${index + 1}`,
+			type,
+			color,
+			colorCss: toCss(color),
+			lineWidth: s.lineWidth ?? 2,
+			pointSize: s.pointSize ?? 8,
+			opacity: s.opacity ?? (type === "area" ? .28 : type === "scatter" ? .78 : 1),
+			hidden: !!s.hidden || hidden.has(id),
+			showLabels: !!s.showLabels,
+			cols,
+			barOffset: 0,
+			barHalfWidth: 0,
+			barBase: null,
+			barTop: null,
+			pointColors
+		};
+	});
+	const visible = series.filter((s) => !s.hidden);
+	const allScatter = series.length > 0 && series.every((s) => s.type === "scatter");
+	const bars = visible.filter((s) => s.type === "bar");
+	const band = xType === "category" ? 1 : (() => {
+		const step = smallestStep(bars.map((s) => s.cols));
+		return Number.isFinite(step) ? step : 1;
+	})();
+	if (bars.length) {
+		const slots = /* @__PURE__ */ new Map();
+		for (const s of bars) {
+			const stack = input[s.index].stack ?? `\u0000${s.key}`;
+			if (!slots.has(stack)) slots.set(stack, slots.size);
+		}
+		const group = band * (slots.size > 1 ? .78 : .62);
+		const slotWidth = group / slots.size;
+		const sums = /* @__PURE__ */ new Map();
+		for (const s of bars) {
+			const stack = input[s.index].stack ?? `\u0000${s.key}`;
+			const slot = slots.get(stack) ?? 0;
+			s.barOffset = -group / 2 + slotWidth * (slot + .5);
+			s.barHalfWidth = slotWidth / 2 * (slots.size > 1 ? .86 : 1);
+			let totals = sums.get(stack);
+			if (!totals) sums.set(stack, totals = /* @__PURE__ */ new Map());
+			const { x, y, count } = s.cols;
+			s.barBase = new Float64Array(count);
+			s.barTop = new Float64Array(count);
+			for (let i = 0; i < count; i++) {
+				const v = y[i];
+				if (!Number.isFinite(v)) {
+					s.barBase[i] = NaN;
+					s.barTop[i] = NaN;
+					continue;
+				}
+				const t = totals.get(x[i]) ?? [0, 0];
+				const base = v >= 0 ? t[0] : t[1];
+				s.barBase[i] = base;
+				s.barTop[i] = base + v;
+				if (v >= 0) t[0] += v;
+				else t[1] += v;
+				totals.set(x[i], t);
+			}
+		}
+	}
+	const xOpts = options.xAxis;
+	let xRange;
+	if (xType === "category") xRange = [-.5, Math.max(1, categories.length) - .5];
+	else {
+		const values = [];
+		for (const s of visible) {
+			values.push(s.cols.xMin, s.cols.xMax);
+			if (s.type === "bar") values.push(s.cols.xMin - band / 2, s.cols.xMax + band / 2);
+		}
+		xRange = ensureSpan(...extent(values), xType === "time" ? [Date.now() - 864e5, Date.now()] : [0, 1]);
+		if (allScatter) {
+			const pad = (xRange[1] - xRange[0]) * .04;
+			xRange = [xRange[0] - pad, xRange[1] + pad];
+		}
+		if ((xOpts?.nice ?? (allScatter && xType === "linear")) && xType === "linear") xRange = niceDomain(xRange[0], xRange[1], xOpts?.tickCount ?? 6);
+	}
+	if (xOpts?.min !== void 0) xRange[0] = xOpts.min;
+	if (xOpts?.max !== void 0) xRange[1] = xOpts.max;
+	xRange = ensureSpan(xRange[0], xRange[1]);
+	const yOpts = options.yAxis;
+	const yValues = [];
+	for (const s of visible) if (s.type === "bar" && s.barBase && s.barTop) yValues.push(...extent(s.barBase), ...extent(s.barTop));
+	else yValues.push(s.cols.yMin, s.cols.yMax);
+	if (bars.length || yOpts?.zero) yValues.push(0);
+	let yRange = ensureSpan(...extent(yValues));
+	if (allScatter) {
+		const pad = (yRange[1] - yRange[0]) * .06;
+		yRange = [yRange[0] - pad, yRange[1] + pad];
+	}
+	if ((yOpts?.nice ?? true) && (yOpts?.type ?? "linear") === "linear") yRange = niceDomain(yRange[0], yRange[1], yOpts?.tickCount ?? 5);
+	if (bars.length && !yOpts?.zero) {
+		if (yRange[0] < 0 && extent(yValues)[0] >= 0) yRange[0] = 0;
+	}
+	if (yOpts?.min !== void 0) yRange[0] = yOpts.min;
+	if (yOpts?.max !== void 0) yRange[1] = yOpts.max;
+	yRange = ensureSpan(yRange[0], yRange[1]);
+	const zoomOption = options.interaction === false ? false : options.interaction === true || options.interaction === void 0 ? true : options.interaction.zoom ?? true;
+	const zoomAxes = zoomOption === false ? {
+		x: false,
+		y: false
+	} : zoomOption === true ? {
+		x: true,
+		y: allScatter
+	} : {
+		x: zoomOption.includes("x"),
+		y: zoomOption.includes("y")
+	};
+	const tooltip = typeof options.tooltip === "object" ? options.tooltip : void 0;
+	return {
+		series,
+		x: axisModel(xOpts, xType, categories, false),
+		y: axisModel(yOpts, yOpts?.type === "time" ? "time" : "linear", [], true),
+		base: {
+			x: xRange,
+			y: yRange
+		},
+		allScatter,
+		zoom: zoomAxes,
+		tooltipMode: tooltip?.mode ?? (allScatter ? "nearest" : "axis"),
+		baseline: Math.min(Math.max(0, yRange[0]), yRange[1]),
+		minSpan: {
+			x: xType === "category" ? 1 : (xRange[1] - xRange[0]) * 1e-7,
+			y: (yRange[1] - yRange[0]) * 1e-7
+		}
+	};
+};
+var grids = /* @__PURE__ */ new WeakMap();
+/** Spatial index of a scatter series, built on first use and kept with its data */
+var gridOf = (s) => {
+	let grid = grids.get(s.cols);
+	if (!grid) {
+		grid = new GridIndex(s.cols.x, s.cols.y, s.cols.count);
+		grids.set(s.cols, grid);
+	}
+	return grid;
+};
+//#endregion
+//#region ../charts/src/engine/overlay.ts
+var font = (theme, size = theme.fontSize, weight = 400) => `${weight} ${size}px ${theme.fontFamily}`;
+var crisp = (v) => Math.round(v) + .5;
+/** Box of a text annotation, kept inside the plot */
+var textBox = (a, s, width, height) => {
+	const { plot } = s;
+	const px = a.x === void 0 ? plot.x + plot.width / 2 : s.xToPx(a.x);
+	const py = a.y === void 0 ? plot.y + plot.height / 2 : s.yToPx(a.y);
+	const gap = 6;
+	let x = px - width / 2;
+	let y = py - height / 2;
+	if (a.anchor === "top") y = py + gap;
+	else if (a.anchor === "bottom") y = py - gap - height;
+	else if (a.anchor === "left") x = px + gap;
+	else if (a.anchor === "right") x = px - gap - width;
+	x = Math.max(plot.x + gap, Math.min(x, plot.x + plot.width - gap - width));
+	y = Math.max(plot.y + 2, Math.min(y, plot.y + plot.height - 2 - height));
+	return {
+		x,
+		y,
+		width,
+		height
+	};
+};
+var rectOf = (a, s) => {
+	const { plot } = s;
+	const xa = a.x0 === void 0 ? -Infinity : s.xToPx(a.x0);
+	const xb = a.x1 === void 0 ? Infinity : s.xToPx(a.x1);
+	const ya = a.y0 === void 0 ? Infinity : s.yToPx(a.y0);
+	const yb = a.y1 === void 0 ? -Infinity : s.yToPx(a.y1);
+	const left = Math.max(plot.x, Math.min(xa, xb));
+	const right = Math.min(plot.x + plot.width, Math.max(xa, xb));
+	const top = Math.max(plot.y, Math.min(ya, yb));
+	const bottom = Math.min(plot.y + plot.height, Math.max(ya, yb));
+	return {
+		x: left,
+		y: top,
+		width: right - left,
+		height: bottom - top
+	};
+};
+var drawBackground = (ctx, input) => {
+	const { scales, theme, x, y, xTicks, yTicks } = input;
+	const { plot } = scales;
+	ctx.clearRect(0, 0, input.width, input.height);
+	ctx.save();
+	ctx.beginPath();
+	ctx.rect(plot.x, plot.y, plot.width, plot.height);
+	ctx.clip();
+	for (const a of input.annotations) {
+		if (a.type !== "rect") continue;
+		const r = rectOf(a, scales);
+		if (r.width <= 0 || r.height <= 0) continue;
+		ctx.fillStyle = toCss(a.color, a.opacity);
+		ctx.fillRect(r.x, r.y, r.width, r.height);
+	}
+	ctx.restore();
+	ctx.lineWidth = 1;
+	ctx.strokeStyle = toCss(theme.grid);
+	ctx.beginPath();
+	if (y.grid) for (const v of yTicks.values) {
+		const py = crisp(scales.yToPx(v));
+		if (py < plot.y - 1 || py > plot.y + plot.height + 1) continue;
+		ctx.moveTo(plot.x, py);
+		ctx.lineTo(plot.x + plot.width, py);
+	}
+	if (x.grid) for (const v of xTicks.values) {
+		const px = crisp(scales.xToPx(v));
+		if (px < plot.x - 1 || px > plot.x + plot.width + 1) continue;
+		ctx.moveTo(px, plot.y);
+		ctx.lineTo(px, plot.y + plot.height);
+	}
+	ctx.stroke();
+	const line = Math.ceil(theme.fontSize * 1.4);
+	ctx.font = font(theme);
+	ctx.fillStyle = toCss(theme.textMuted);
+	if (x.visible) {
+		ctx.strokeStyle = toCss(theme.axis);
+		ctx.beginPath();
+		const base = crisp(plot.y + plot.height);
+		ctx.moveTo(plot.x, base);
+		ctx.lineTo(plot.x + plot.width, base);
+		ctx.stroke();
+		ctx.textBaseline = "top";
+		ctx.textAlign = "center";
+		let lastRight = -Infinity;
+		const order = xTicks.values.map((v, i) => ({
+			px: scales.xToPx(v),
+			text: xTicks.labels[i]
+		})).sort((a, b) => a.px - b.px);
+		for (const { px, text } of order) {
+			if (px < plot.x - .5 || px > plot.x + plot.width + .5) continue;
+			const w = ctx.measureText(text).width;
+			const left = Math.max(0, Math.min(input.width - w, px - w / 2));
+			if (left < lastRight + 6) continue;
+			lastRight = left + w;
+			ctx.fillText(text, left + w / 2, plot.y + plot.height + 7);
+		}
+		if (x.title) {
+			ctx.font = font(theme, theme.fontSize + 1, 500);
+			ctx.fillStyle = toCss(theme.text, .8);
+			ctx.fillText(x.title, plot.x + plot.width / 2, plot.y + plot.height + line + 10);
+		}
+	}
+	if (y.visible) {
+		ctx.font = font(theme);
+		ctx.fillStyle = toCss(theme.textMuted);
+		ctx.textAlign = "right";
+		ctx.textBaseline = "middle";
+		yTicks.values.forEach((v, i) => {
+			const py = scales.yToPx(v);
+			if (py < plot.y - .5 || py > plot.y + plot.height + .5) return;
+			ctx.fillText(yTicks.labels[i], plot.x - 8, py);
+		});
+		if (y.title) {
+			ctx.save();
+			ctx.font = font(theme, theme.fontSize + 1, 500);
+			ctx.fillStyle = toCss(theme.text, .8);
+			ctx.translate(line / 2 + 4, plot.y + plot.height / 2);
+			ctx.rotate(-Math.PI / 2);
+			ctx.textAlign = "center";
+			ctx.fillText(y.title, 0, 0);
+			ctx.restore();
+		}
+	}
+};
+var overlaps = (a, b) => a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height;
+var inside = (r, plot) => r.x >= plot.x && r.y >= plot.y && r.x + r.width <= plot.x + plot.width && r.y + r.height <= plot.y + plot.height;
+/** Text with a halo in the background color (readable over data) */
+var haloText = (ctx, text, x, y, color, halo) => {
+	ctx.lineWidth = 3;
+	ctx.lineJoin = "round";
+	ctx.strokeStyle = halo;
+	ctx.strokeText(text, x, y);
+	ctx.fillStyle = color;
+	ctx.fillText(text, x, y);
+};
+/** Greedy placement: right, left, above, below the dot; skipped when no slot is free */
+var placeLabels = (labels, plot, measure, height, occupied = []) => {
+	const placed = [];
+	for (const label of labels) {
+		const w = measure(label.text);
+		const gap = label.r + 4;
+		const box = [
+			{
+				x: label.x + gap,
+				y: label.y - height / 2,
+				width: w,
+				height
+			},
+			{
+				x: label.x - gap - w,
+				y: label.y - height / 2,
+				width: w,
+				height
+			},
+			{
+				x: label.x - w / 2,
+				y: label.y - gap - height,
+				width: w,
+				height
+			},
+			{
+				x: label.x - w / 2,
+				y: label.y + gap,
+				width: w,
+				height
+			}
+		].find((c) => inside(c, plot) && !occupied.some((o) => overlaps(o, c)));
+		if (!box) continue;
+		occupied.push(box);
+		placed.push({
+			label,
+			box
+		});
+	}
+	return placed;
+};
+var drawForeground = (ctx, input) => {
+	const { scales, theme } = input;
+	const { plot } = scales;
+	if (input.clear !== false) ctx.clearRect(0, 0, input.width, input.height);
+	ctx.save();
+	ctx.beginPath();
+	ctx.rect(plot.x, plot.y, plot.width, plot.height);
+	ctx.clip();
+	const halo = toCss(theme.background, .9);
+	const occupied = [];
+	const labelHeight = theme.fontSize + 4;
+	for (const a of input.annotations) {
+		if (a.type !== "line") continue;
+		const color = toCss(a.color);
+		ctx.strokeStyle = color;
+		ctx.lineWidth = a.width;
+		ctx.setLineDash(a.dash);
+		ctx.beginPath();
+		if (a.axis === "y") {
+			const py = crisp(scales.yToPx(a.value));
+			ctx.moveTo(plot.x, py);
+			ctx.lineTo(plot.x + plot.width, py);
+			ctx.stroke();
+			if (a.label) {
+				ctx.setLineDash([]);
+				ctx.font = font(theme, theme.fontSize, 500);
+				ctx.textAlign = "right";
+				ctx.textBaseline = "bottom";
+				haloText(ctx, a.label, plot.x + plot.width - 6, py - 3, color, halo);
+			}
+		} else {
+			const px = crisp(scales.xToPx(a.value));
+			ctx.moveTo(px, plot.y);
+			ctx.lineTo(px, plot.y + plot.height);
+			ctx.stroke();
+			if (a.label) {
+				ctx.setLineDash([]);
+				ctx.font = font(theme, theme.fontSize, 500);
+				ctx.textAlign = "left";
+				ctx.textBaseline = "top";
+				haloText(ctx, a.label, px + 5, plot.y + 5, color, halo);
+			}
+		}
+	}
+	ctx.setLineDash([]);
+	ctx.font = font(theme, theme.fontSize + 1, 600);
+	for (const a of input.annotations) {
+		if (a.type !== "rect" || !a.label) continue;
+		const r = rectOf(a, scales);
+		if (r.width <= 0 || r.height <= 0) continue;
+		const pad = 10;
+		const w = ctx.measureText(a.label).width;
+		const pos = a.labelPosition;
+		const tx = pos.endsWith("left") ? r.x + pad : pos.endsWith("right") ? r.x + r.width - pad - w : r.x + (r.width - w) / 2;
+		const ty = pos.startsWith("top") ? r.y + pad : pos.startsWith("bottom") ? r.y + r.height - pad - labelHeight : r.y + (r.height - labelHeight) / 2;
+		ctx.textAlign = "left";
+		ctx.textBaseline = "top";
+		ctx.fillStyle = toCss(a.labelColor);
+		ctx.fillText(a.label, tx, ty);
+		occupied.push({
+			x: tx,
+			y: ty,
+			width: w,
+			height: labelHeight
+		});
+	}
+	for (const a of input.annotations) {
+		if (a.type !== "text" || !a.text) continue;
+		ctx.font = font(theme, theme.fontSize, a.weight);
+		const box = textBox(a, scales, ctx.measureText(a.text).width, labelHeight);
+		ctx.textAlign = "left";
+		ctx.textBaseline = "middle";
+		haloText(ctx, a.text, box.x, box.y + box.height / 2, toCss(a.color), halo);
+		occupied.push(box);
+	}
+	if (input.pointLabels.length) {
+		ctx.font = font(theme);
+		ctx.textAlign = "left";
+		ctx.textBaseline = "middle";
+		const textColor = toCss(theme.text, .85);
+		const placed = placeLabels(input.pointLabels, plot, (t) => ctx.measureText(t).width, labelHeight - 2, occupied);
+		for (const { label, box } of placed) haloText(ctx, label.text, box.x, box.y + box.height / 2, textColor, halo);
+	}
+	ctx.restore();
+};
+//#endregion
+//#region ../charts/src/engine/format.ts
+var UNITS = [
+	[0xe8d4a51000, "T"],
+	[1e9, "B"],
+	[1e6, "M"],
+	[1e3, "k"]
+];
+var trim = (text) => text.includes(".") ? text.replace(/\.?0+$/, "") : text;
+/** `1234567` -> `1.23M`, `0.5` -> `0.5`; `-0` is printed as `0` */
+var formatCompact = (value, maxDecimals = 2) => {
+	if (!Number.isFinite(value)) return String(value);
+	if (Object.is(value, -0) || value === 0) return "0";
+	const abs = Math.abs(value);
+	for (const [unit, suffix] of UNITS) if (abs >= unit) return trim((value / unit).toFixed(maxDecimals)) + suffix;
+	if (abs < 1e-4) return value.toExponential(1);
+	const decimals = Math.min(6, Math.max(maxDecimals, stepDecimals(abs) + 2));
+	return trim(value.toFixed(decimals));
+};
+/**
+* Formatter of the ticks of a linear axis: enough decimals to tell the
+* ticks apart; compact units (k, M, ...) when the values are large.
+*/
+var tickFormatter = (step, maxAbs) => {
+	if (maxAbs >= 1e4) {
+		const unit = UNITS.find(([u]) => maxAbs >= u)?.[0] ?? 1;
+		const decimals = Math.min(3, stepDecimals(step / unit));
+		return (value) => formatCompact(value, decimals);
+	}
+	const decimals = stepDecimals(step);
+	return (value) => {
+		const text = value.toFixed(decimals);
+		return /^-0(\.0*)?$/.test(text) ? text.slice(1) : text;
+	};
+};
+/** Value of a tooltip: up to 4 significant decimals */
+var formatValue = (value) => {
+	if (!Number.isFinite(value)) return "–";
+	const abs = Math.abs(value);
+	if (abs >= 1e6) return formatCompact(value, 2);
+	if (Number.isInteger(value)) return value.toLocaleString("en-US");
+	return trim(value.toFixed(abs >= 100 ? 2 : abs >= 1 ? 3 : 4));
+};
+//#endregion
+//#region ../charts/src/engine/time.ts
+var SECOND = 1e3;
+var MINUTE = 60 * SECOND;
+var HOUR = 60 * MINUTE;
+var DAY = 24 * HOUR;
+var MONTH = 30 * DAY;
+var YEAR = 365 * DAY;
+var INTERVALS = [
+	{
+		unit: "second",
+		step: 1,
+		ms: SECOND
+	},
+	{
+		unit: "second",
+		step: 5,
+		ms: 5 * SECOND
+	},
+	{
+		unit: "second",
+		step: 15,
+		ms: 15 * SECOND
+	},
+	{
+		unit: "second",
+		step: 30,
+		ms: 30 * SECOND
+	},
+	{
+		unit: "minute",
+		step: 1,
+		ms: MINUTE
+	},
+	{
+		unit: "minute",
+		step: 5,
+		ms: 5 * MINUTE
+	},
+	{
+		unit: "minute",
+		step: 15,
+		ms: 15 * MINUTE
+	},
+	{
+		unit: "minute",
+		step: 30,
+		ms: 30 * MINUTE
+	},
+	{
+		unit: "hour",
+		step: 1,
+		ms: HOUR
+	},
+	{
+		unit: "hour",
+		step: 3,
+		ms: 3 * HOUR
+	},
+	{
+		unit: "hour",
+		step: 6,
+		ms: 6 * HOUR
+	},
+	{
+		unit: "hour",
+		step: 12,
+		ms: 12 * HOUR
+	},
+	{
+		unit: "day",
+		step: 1,
+		ms: DAY
+	},
+	{
+		unit: "day",
+		step: 2,
+		ms: 2 * DAY
+	},
+	{
+		unit: "day",
+		step: 7,
+		ms: 7 * DAY
+	},
+	{
+		unit: "month",
+		step: 1,
+		ms: MONTH
+	},
+	{
+		unit: "month",
+		step: 3,
+		ms: 3 * MONTH
+	},
+	{
+		unit: "month",
+		step: 6,
+		ms: 6 * MONTH
+	}
+];
+var pad = (n, width = 2) => String(n).padStart(width, "0");
+var chooseInterval = (span, count) => {
+	const target = span / Math.max(1, count);
+	if (target < SECOND * .75) return {
+		unit: "millisecond",
+		step: tickStep(0, span, count),
+		ms: 1
+	};
+	for (const interval of INTERVALS) if (interval.ms >= target * .75) return interval;
+	const years = Math.max(1, tickStep(0, span / YEAR, count));
+	return {
+		unit: "year",
+		step: Math.round(years),
+		ms: Math.round(years) * YEAR
+	};
+};
+/** Start of the tick sequence: `t` floored to the unit, aligned on the step */
+var floorTo = (t, { unit, step }) => {
+	const d = new Date(t);
+	switch (unit) {
+		case "second":
+			d.setMilliseconds(0);
+			d.setSeconds(d.getSeconds() - d.getSeconds() % step);
+			break;
+		case "minute":
+			d.setSeconds(0, 0);
+			d.setMinutes(d.getMinutes() - d.getMinutes() % step);
+			break;
+		case "hour":
+			d.setMinutes(0, 0, 0);
+			d.setHours(d.getHours() - d.getHours() % step);
+			break;
+		case "day":
+			d.setHours(0, 0, 0, 0);
+			if (step === 7) d.setDate(d.getDate() - (d.getDay() + 6) % 7);
+			break;
+		case "month":
+			d.setHours(0, 0, 0, 0);
+			d.setDate(1);
+			d.setMonth(d.getMonth() - d.getMonth() % step);
+			break;
+		case "year":
+			d.setHours(0, 0, 0, 0);
+			d.setMonth(0, 1);
+			d.setFullYear(d.getFullYear() - d.getFullYear() % step);
+	}
+	return d;
+};
+var advance = (d, { unit, step }) => {
+	switch (unit) {
+		case "second":
+			d.setSeconds(d.getSeconds() + step);
+			break;
+		case "minute":
+			d.setMinutes(d.getMinutes() + step);
+			break;
+		case "hour":
+			d.setHours(d.getHours() + step);
+			break;
+		case "day":
+			d.setDate(d.getDate() + step);
+			break;
+		case "month":
+			d.setMonth(d.getMonth() + step);
+			break;
+		case "year": d.setFullYear(d.getFullYear() + step);
+	}
+};
+/** Calendar-aligned ticks between two timestamps */
+var timeTicks = (min, max, count) => {
+	if (min > max) [min, max] = [max, min];
+	const interval = chooseInterval(max - min, count);
+	if (interval.unit === "millisecond") return {
+		values: linearTicks(min, max, count),
+		unit: "millisecond",
+		format: (v) => formatTime(v, "millisecond")
+	};
+	const values = [];
+	const d = floorTo(min, interval);
+	while (d.getTime() < min) advance(d, interval);
+	while (d.getTime() <= max && values.length < 500) {
+		values.push(d.getTime());
+		advance(d, interval);
+	}
+	const { unit } = interval;
+	return {
+		values,
+		unit,
+		format: (v) => formatTick(v, unit)
+	};
+};
+var ymd = (d) => `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+var hm = (d) => `${pad(d.getHours())}:${pad(d.getMinutes())}`;
+/** Short tick label; day boundaries show the date, year boundaries the year */
+var formatTick = (value, unit) => {
+	const d = new Date(value);
+	const midnight = d.getHours() === 0 && d.getMinutes() === 0 && d.getSeconds() === 0;
+	switch (unit) {
+		case "second": return `${hm(d)}:${pad(d.getSeconds())}`;
+		case "minute":
+		case "hour": return midnight ? `${pad(d.getMonth() + 1)}-${pad(d.getDate())}` : hm(d);
+		case "day": return d.getMonth() === 0 && d.getDate() === 1 ? String(d.getFullYear()) : `${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+		case "month": return d.getMonth() === 0 ? String(d.getFullYear()) : `${d.getFullYear()}-${pad(d.getMonth() + 1)}`;
+		default: return String(d.getFullYear());
+	}
+};
+/** Full label (tooltips): precision follows the unit of the ticks */
+var formatTime = (value, unit = "minute") => {
+	const d = new Date(value);
+	if (Number.isNaN(d.getTime())) return "–";
+	switch (unit) {
+		case "millisecond": return `${ymd(d)} ${hm(d)}:${pad(d.getSeconds())}.${pad(d.getMilliseconds(), 3)}`;
+		case "second": return `${ymd(d)} ${hm(d)}:${pad(d.getSeconds())}`;
+		case "minute":
+		case "hour": return `${ymd(d)} ${hm(d)}`;
+		default: return ymd(d);
+	}
+};
+//#endregion
+//#region ../charts/src/engine/axis.ts
+/**
+* @param count approximate number of ticks (numeric / time axes) or the
+*   maximum number of labels (category axes)
+*/
+var axisTicks = (axis, range, count) => {
+	const [min, max] = range[0] <= range[1] ? range : [range[1], range[0]];
+	if (axis.type === "category") {
+		const n = axis.categories.length;
+		const first = Math.max(0, Math.ceil(min - 1e-9));
+		const last = Math.min(n - 1, Math.floor(max + 1e-9));
+		const visible = Math.max(0, last - first + 1);
+		const step = Math.max(1, Math.ceil(visible / Math.max(1, count)));
+		const values = [];
+		for (let i = first - first % step; i <= last; i += step) if (i >= first) values.push(i);
+		const name = (v) => {
+			const i = Math.round(v);
+			return axis.format ? axis.format(i) : axis.categories[i] ?? String(i);
+		};
+		return {
+			values,
+			labels: values.map(name),
+			formatValue: name
+		};
+	}
+	if (axis.type === "time") {
+		const ticks = timeTicks(min, max, count);
+		const unit = ticks.unit === "day" || ticks.unit === "month" || ticks.unit === "year" ? "day" : ticks.unit;
+		const full = axis.format ?? ((v) => formatTime(v, unit));
+		return {
+			values: ticks.values,
+			labels: ticks.values.map(axis.format ?? ticks.format),
+			formatValue: full
+		};
+	}
+	const values = linearTicks(min, max, count);
+	const step = tickStep(min, max, count);
+	const tick = axis.format ?? tickFormatter(step, Math.max(Math.abs(min), Math.abs(max)));
+	return {
+		values,
+		labels: values.map(tick),
+		formatValue: axis.format ?? formatValue
+	};
+};
+var DEFAULT_PADDING = {
+	top: 12,
+	right: 16,
+	bottom: 4,
+	left: 4
+};
+var fallbackResolve = (_value, fallback) => fallback;
+/** Annotation colors resolved against the theme */
+var resolveAnnotations = (annotations, theme) => {
+	const resolve = theme.resolve ?? fallbackResolve;
+	return (annotations ?? []).map((a) => {
+		if (a.type === "rect") {
+			const color = a.color ? resolve(a.color, theme.primary) : theme.primary;
+			return {
+				type: "rect",
+				x0: a.x0,
+				x1: a.x1,
+				y0: a.y0,
+				y1: a.y1,
+				color,
+				opacity: a.opacity ?? .08,
+				label: a.label,
+				labelPosition: a.labelPosition ?? "top-left",
+				labelColor: a.labelColor ? resolve(a.labelColor, color) : mix(color, theme.text, .2)
+			};
+		}
+		if (a.type === "text") return {
+			type: "text",
+			x: a.x,
+			y: a.y,
+			text: a.text,
+			anchor: a.anchor ?? "center",
+			color: a.color ? resolve(a.color, theme.textMuted) : theme.textMuted,
+			weight: a.weight ?? 500
+		};
+		return {
+			type: "line",
+			axis: a.axis,
+			value: a.value,
+			color: a.color ? resolve(a.color, theme.textMuted) : theme.textMuted,
+			width: a.width ?? 1,
+			dash: [...a.dash ?? [4, 4]],
+			label: a.label
+		};
+	});
+};
+/** Ticks, room for the axes and the plot rectangle */
+var layoutChart = (input) => {
+	const { model, view, theme, width, height, measure } = input;
+	const yCount = model.y.tickCount ?? (height >= 220 ? 5 : Math.max(2, Math.round((height - 48) / 52)));
+	const yTicks = axisTicks(model.y, view.y, yCount);
+	let yLabelWidth = 0;
+	if (model.y.visible) for (const label of yTicks.labels) yLabelWidth = Math.max(yLabelWidth, measure(label));
+	let categoryWidth = 48;
+	if (model.x.type === "category") {
+		categoryWidth = 0;
+		const step = Math.max(1, Math.floor(model.x.categories.length / 200));
+		for (let i = 0; i < model.x.categories.length; i += step) categoryWidth = Math.max(categoryWidth, measure(model.x.categories[i]));
+	}
+	const plot = computePlot({
+		width,
+		height,
+		padding: {
+			...DEFAULT_PADDING,
+			...input.padding
+		},
+		yLabelWidth: model.y.visible ? Math.ceil(yLabelWidth) : 0,
+		xAxisVisible: model.x.visible,
+		xTitle: !!model.x.title && model.x.visible,
+		yTitle: !!model.y.title && model.y.visible,
+		fontSize: theme.fontSize
+	});
+	if (input.top) plot.y += input.top;
+	const xCount = model.x.type === "category" ? Math.max(1, Math.floor(plot.width / (categoryWidth + 14))) : model.x.tickCount ?? Math.max(2, Math.floor(plot.width / 96));
+	const xTicks = axisTicks(model.x, view.x, xCount);
+	return {
+		plot,
+		scales: createScales(plot, view, model.x.reverse, model.y.reverse),
+		xTicks,
+		yTicks
+	};
+};
+/** Labels of the visible scatter points (`showLabels`) */
+var collectPointLabels = (model, view, s) => {
+	const labels = [];
+	for (const series of model.series) {
+		if (series.hidden || series.type !== "scatter" || !series.showLabels) continue;
+		const { x, y, count, labels: texts, size } = series.cols;
+		if (!texts) continue;
+		for (let i = 0; i < count && labels.length < 300; i++) {
+			const text = texts[i];
+			if (!text) continue;
+			const xi = x[i];
+			const yi = y[i];
+			if (xi < view.x[0] || xi > view.x[1] || yi < view.y[0] || yi > view.y[1]) continue;
+			const d = size && size[i] > 0 ? size[i] : series.pointSize;
+			labels.push({
+				x: s.xToPx(xi),
+				y: s.yToPx(yi),
+				r: d / 2,
+				text
+			});
+		}
+	}
+	return labels;
+};
+/** Pixel position of a point (the top of a bar) */
+var pointOf = (s, i, sc) => {
+	const xv = s.cols.x[i] + (s.type === "bar" ? s.barOffset : 0);
+	const yv = s.type === "bar" && s.barTop ? s.barTop[i] : s.cols.y[i];
+	return {
+		px: sc.xToPx(xv),
+		py: sc.yToPx(yv)
+	};
+};
+var candidateOf = (s, i, px, py, sc) => {
+	const p = pointOf(s, i, sc);
+	let inside = false;
+	if (s.type === "bar" && s.barBase) {
+		const half = s.barHalfWidth / sc.xPerPx;
+		const base = sc.yToPx(s.barBase[i]);
+		inside = Math.abs(px - p.px) <= half && py >= Math.min(base, p.py) - 2 && py <= Math.max(base, p.py) + 2;
+	}
+	return {
+		series: s,
+		index: i,
+		px: p.px,
+		py: p.py,
+		dx: Math.abs(sc.xToPx(s.cols.x[i]) - px),
+		dist: inside ? 0 : Math.hypot(p.px - px, p.py - py),
+		inside
+	};
+};
+/** Diameter of a scatter dot */
+var dotSize = (s, i) => s.cols.size && s.cols.size[i] > 0 ? s.cols.size[i] : s.pointSize;
+var nearestScatter = (s, px, py, sc, slop) => {
+	const radius = Math.max(s.pointSize / 2 + 6, 10) + slop;
+	const xv = sc.pxToX(px);
+	const yv = sc.pxToY(py);
+	const rx = radius * sc.xPerPx;
+	const ry = radius * sc.yPerPx;
+	let best = -1;
+	let bestDist = Infinity;
+	const { x, y } = s.cols;
+	gridOf(s).query(xv - rx, xv + rx, yv - ry, yv + ry, (i) => {
+		const d = Math.hypot(sc.xToPx(x[i]) - px, sc.yToPx(y[i]) - py);
+		if (d <= Math.max(dotSize(s, i) / 2 + 4, 8) + slop && d <= bestDist) {
+			bestDist = d;
+			best = i;
+		}
+	});
+	return best;
+};
+var nearestX = (s, xv) => {
+	const { x, y, count, sorted } = s.cols;
+	if (sorted) return nearestIndex(x, y, count, xv);
+	let best = -1;
+	let bestD = Infinity;
+	for (let i = 0; i < count; i++) {
+		if (!Number.isFinite(y[i])) continue;
+		const d = Math.abs(x[i] - xv);
+		if (d < bestD) {
+			bestD = d;
+			best = i;
+		}
+	}
+	return best;
+};
+/** Hover payload item of a point */
+var hoverItemOf = (s, index) => {
+	const pc = s.pointColors?.[index];
+	const label = s.cols.labels?.[index];
+	return {
+		seriesIndex: s.index,
+		seriesId: s.id,
+		seriesName: s.name,
+		index,
+		x: s.cols.x[index],
+		y: s.cols.y[index],
+		color: pc ? toCss(pc) : s.colorCss,
+		...label !== void 0 ? { label } : {}
+	};
+};
+var eventOf = (candidates, xTicks) => {
+	if (!candidates.length) return null;
+	candidates.sort((a, b) => a.series.index - b.series.index);
+	const items = candidates.map((c) => hoverItemOf(c.series, c.index));
+	const x = items[0].x;
+	return {
+		items,
+		x,
+		xLabel: xTicks?.formatValue(x) ?? String(x)
+	};
+};
+/**
+* Points under a pixel of the stage: the nearest point (scatter / `nearest`
+* tooltips) or every series at the nearest x (`axis` tooltips).
+* `slop` widens the reach of the dots (touch screens).
+*/
+var hitTest = (model, sc, xTicks, px, py, slop = 0) => {
+	const { plot } = sc;
+	const margin = 6 + slop;
+	if (px < plot.x - margin || px > plot.x + plot.width + margin || py < plot.y - margin || py > plot.y + plot.height + margin) return null;
+	const xv = sc.pxToX(px);
+	const scatter = [];
+	const others = [];
+	for (const s of model.series) {
+		if (s.hidden || s.cols.count === 0) continue;
+		if (s.type === "scatter") {
+			const i = nearestScatter(s, px, py, sc, slop);
+			if (i >= 0) scatter.push(candidateOf(s, i, px, py, sc));
+		} else {
+			const i = nearestX(s, xv);
+			if (i >= 0) others.push(candidateOf(s, i, px, py, sc));
+		}
+	}
+	if (model.tooltipMode === "nearest") {
+		const all = [...scatter, ...others].filter((c) => c.inside || c.series.type === "scatter" || c.dist <= 32 + slop);
+		if (!all.length) return null;
+		return eventOf([all.reduce((a, b) => b.dist <= a.dist ? b : a)], xTicks);
+	}
+	if (!others.length) {
+		if (!scatter.length) return null;
+		return eventOf([scatter.reduce((a, b) => b.dist <= a.dist ? b : a)], xTicks);
+	}
+	const bestDx = Math.min(...others.map((c) => c.dx));
+	const bandPx = model.x.type === "category" ? .5 / sc.xPerPx : 0;
+	const aligned = others.filter((c) => c.dx <= bestDx + Math.max(1, bandPx));
+	const first = aligned.reduce((a, b) => b.dx < a.dx ? b : a);
+	const event = eventOf([
+		first,
+		...aligned.filter((c) => c !== first),
+		...scatter
+	], xTicks);
+	if (event) {
+		event.x = hoverItemOf(first.series, first.index).x;
+		event.xLabel = xTicks?.formatValue(event.x) ?? String(event.x);
+	}
+	return event;
+};
+/** Whether two hover payloads point at the same points */
+var sameHover = (a, b) => a === b || !!a && !!b && a.items.length === b.items.length && a.items.every((it, i) => it.index === b.items[i].index && it.seriesIndex === b.items[i].seriesIndex);
+/** Default tooltip content of a hover payload */
+var tooltipContent = (model, event, yTicks) => {
+	const yFormat = yTicks?.formatValue ?? String;
+	if (event.items.every((it) => model.series[it.seriesIndex].type === "scatter") && event.items.length === 1) {
+		const it = event.items[0];
+		const rows = [{
+			color: null,
+			name: model.x.title ?? "x",
+			value: event.xLabel
+		}, {
+			color: null,
+			name: model.y.title ?? "y",
+			value: yFormat(it.y)
+		}];
+		if (it.label !== void 0 && model.series.length > 1) rows.push({
+			color: null,
+			name: "",
+			value: it.seriesName
+		});
+		return {
+			title: it.label ?? it.seriesName,
+			titleColor: it.color,
+			rows
+		};
+	}
+	return {
+		title: event.xLabel,
+		titleColor: null,
+		rows: event.items.map((it) => ({
+			color: it.color,
+			name: it.label ? `${it.seriesName} · ${it.label}` : it.seriesName,
+			value: yFormat(it.y)
+		}))
+	};
+};
+/** Markers of the hovered points (pixels of the stage) */
+var hoverMarks = (model, sc, event) => {
+	const marks = [];
+	const { plot } = sc;
+	for (const it of event.items) {
+		const s = model.series[it.seriesIndex];
+		if (s.type === "bar" && s.barBase && s.barTop) {
+			const cx = sc.xToPx(it.x + s.barOffset);
+			const half = Math.max(s.barHalfWidth / sc.xPerPx, 1);
+			const a = sc.yToPx(s.barBase[it.index]);
+			const b = sc.yToPx(s.barTop[it.index]);
+			marks.push({
+				kind: "bar",
+				x: cx - half,
+				y: Math.min(a, b),
+				width: half * 2,
+				height: Math.max(1, Math.abs(a - b))
+			});
+			continue;
+		}
+		const px = sc.xToPx(it.x);
+		const py = sc.yToPx(it.y);
+		if (px < plot.x - 1 || px > plot.x + plot.width + 1 || py < plot.y - 1 || py > plot.y + plot.height + 1) continue;
+		const size = s.type === "scatter" ? dotSize(s, it.index) + 6 : Math.max(10, s.lineWidth * 2 + 6);
+		marks.push({
+			kind: "dot",
+			x: px,
+			y: py,
+			size,
+			color: it.color
+		});
+	}
+	return marks;
+};
+/** Whether the guide line follows the pointer */
+var showsCrosshair = (model, event, crosshair) => crosshair ?? (model.tooltipMode === "axis" && event.items.some((it) => model.series[it.seriesIndex].type !== "scatter"));
+//#endregion
+//#region ../charts/src/engine/theme.ts
+/** Used when no CSS variable is defined (e.g. without the Minerva stylesheet) */
+var DEFAULT_PALETTE = [
+	"#4f46e5",
+	"#10b981",
+	"#f59e0b",
+	"#ef4444",
+	"#0ea5e9",
+	"#8b5cf6",
+	"#14b8a6",
+	"#f97316"
+];
+/** Builds a theme from plain values (no DOM) */
+var createTheme = (input = {}, palette) => {
+	const variables = input.variables ?? {};
+	return {
+		...buildTheme((name) => variables[name]?.trim() ?? "", staticColorResolver(variables), palette?.length ? palette : input.palette, ""),
+		...input.fontFamily ? { fontFamily: input.fontFamily } : {},
+		...input.fontSize ? { fontSize: input.fontSize } : {}
+	};
+};
+/** Resolver of `var(--name, fallback)` colors against plain variables */
+var staticColorResolver = (variables) => (value, fallback) => resolveStaticColor(value, variables, fallback);
+var buildTheme = (readVariable, resolve, palette, inheritedFont) => {
+	const fallbackGray = [
+		.4,
+		.4,
+		.4,
+		1
+	];
+	const resolveColor = (value) => resolve(value, fallbackGray);
+	const color = (names, fallback) => {
+		for (const name of names) if (readVariable(name)) return resolveColor(`var(${name})`);
+		return resolveColor(fallback);
+	};
+	const background = color(["--surface-color", "--background-color"], "#ffffff");
+	const text = color(["--text-color"], "#1f2937");
+	const textMuted = color(["--text-secondary-color", "--text-muted-color"], "#6b7280");
+	const border = color(["--border-color"], "#e5e7eb");
+	let colors;
+	if (palette && palette.length) colors = palette.map((c) => resolveColor(c));
+	else {
+		const custom = [];
+		for (let i = 1; i <= 8; i++) {
+			const name = `--chart-series-${i}`;
+			if (readVariable(name)) custom.push(resolveColor(`var(${name})`));
+		}
+		if (custom.length) colors = custom;
+		else colors = [...[
+			"--primary-color",
+			"--success-color",
+			"--warning-color",
+			"--danger-color",
+			"--info-color"
+		].map((name, i) => readVariable(name) ? resolveColor(`var(${name})`) : resolveColor(DEFAULT_PALETTE[i])), ...DEFAULT_PALETTE.slice(5).map((c) => resolveColor(c))];
+	}
+	const fontFamily = readVariable("--font-family-sans") || inheritedFont || "system-ui, -apple-system, 'Segoe UI', sans-serif";
+	return {
+		palette: colors,
+		text,
+		textMuted,
+		grid: mix(background, border, .75),
+		axis: border,
+		background,
+		surface: background,
+		primary: colors[0],
+		fontFamily,
+		fontSize: 11,
+		resolve
+	};
+};
+//#endregion
+//#region ../charts/src/engine/viewport.ts
+/**
+* Keeps a range inside `bounds` with a span between `minSpan` and the
+* span of the bounds (shifts it back instead of shrinking it).
+*/
+var clampRange = (range, bounds, minSpan) => {
+	const maxSpan = bounds[1] - bounds[0];
+	const span = Math.min(Math.max(range[1] - range[0], minSpan), maxSpan);
+	let a = (range[0] + range[1]) / 2 - span / 2;
+	let b = a + span;
+	if (a < bounds[0]) {
+		a = bounds[0];
+		b = a + span;
+	}
+	if (b > bounds[1]) {
+		b = bounds[1];
+		a = b - span;
+	}
+	return [a, b];
+};
+/** Scales a range around `anchor` (factor < 1 zooms in) */
+var zoomRange = (range, anchor, factor) => [anchor - (anchor - range[0]) * factor, anchor + (range[1] - anchor) * factor];
+var panRange = (range, delta) => [range[0] + delta, range[1] + delta];
+var sameRange = (a, b, epsilon = 1e-9) => {
+	const span = Math.max(Math.abs(b[1] - b[0]), 1e-300);
+	return Math.abs(a[0] - b[0]) <= span * epsilon && Math.abs(a[1] - b[1]) <= span * epsilon;
+};
+//#endregion
+//#region ../charts/src/engine/controller.ts
+var copyView = (v) => ({
+	x: [v.x[0], v.x[1]],
+	y: [v.y[0], v.y[1]]
+});
+var TAP_SLOP = 6;
+var TOUCH_SLOP = 10;
+var DOUBLE_TAP_MS = 320;
+var LEGEND_ROW = 20;
+var createChartController = (config) => {
+	let options = config.options;
+	let themeInput = config.theme;
+	let theme = createTheme(themeInput, options.palette);
+	const cache = /* @__PURE__ */ new Map();
+	const hidden = /* @__PURE__ */ new Set();
+	const listeners = {};
+	let model;
+	let view = {
+		x: [0, 1],
+		y: [0, 1]
+	};
+	let zoomed = false;
+	let width = 0;
+	let height = 0;
+	let annotations = [];
+	let scene = null;
+	let sceneDirty = true;
+	let lastPlot = "";
+	let destroyed = false;
+	let hover = null;
+	const pointers = /* @__PURE__ */ new Map();
+	let gesture = null;
+	let lastTap = {
+		time: 0,
+		x: 0,
+		y: 0
+	};
+	const emit = (type, event) => {
+		listeners[type]?.forEach((listener) => listener(event));
+	};
+	const invalidate = () => {
+		sceneDirty = true;
+		if (!destroyed) config.onInvalidate?.();
+	};
+	const interaction = () => {
+		const value = options.interaction;
+		if (value === false) return null;
+		const o = typeof value === "object" ? value : {};
+		return {
+			pan: o.pan ?? true,
+			dragPoints: o.dragPoints ?? false
+		};
+	};
+	const measure = (text, size = theme.fontSize, weight = 400) => config.measureText(text, font(theme, size, weight));
+	const rebuild = () => {
+		model = buildModel(options, theme, hidden, cache);
+		const { base, minSpan } = model;
+		if (!zoomed) view = copyView(base);
+		else {
+			view = {
+				x: model.zoom.x ? clampRange(view.x, base.x, minSpan.x) : [...base.x],
+				y: model.zoom.y ? clampRange(view.y, base.y, minSpan.y) : [...base.y]
+			};
+			zoomed = !sameRange(view.x, base.x) || !sameRange(view.y, base.y);
+		}
+		annotations = resolveAnnotations(options.annotations, theme);
+		if (hover) {
+			if (!hover.event.items.every((it) => model.series[it.seriesIndex] && !model.series[it.seriesIndex].hidden && it.index < model.series[it.seriesIndex].cols.count)) setHover(null);
+		}
+		invalidate();
+	};
+	const legendLayout = () => {
+		const option = options.legend;
+		const named = options.series.filter((s) => s.name).length;
+		if (!(option === void 0 ? named > 1 : !!option)) return null;
+		const cfg = typeof option === "object" ? option : {};
+		const position = cfg.position === "bottom" ? "bottom" : "top";
+		const entries = [];
+		let x = 4;
+		let row = 0;
+		for (const s of model.series) {
+			const w = 14 + measure(s.name, 12) + 8;
+			if (x + w > width - 4 && x > 4) {
+				x = 4;
+				row++;
+			}
+			entries.push({
+				id: s.id,
+				name: s.name,
+				color: s.colorCss,
+				shape: s.type === "scatter" ? "dot" : s.type === "line" ? "line" : "square",
+				hidden: s.hidden,
+				box: {
+					x,
+					y: row * LEGEND_ROW,
+					width: w,
+					height: LEGEND_ROW
+				}
+			});
+			x += w + 10;
+		}
+		const legendHeight = (row + 1) * LEGEND_ROW + 6;
+		if (position === "bottom") for (const e of entries) e.box.y += height - legendHeight + 6;
+		return {
+			entries,
+			position,
+			toggle: cfg.toggle ?? true,
+			height: legendHeight
+		};
+	};
+	const tooltipLayout = (event, anchorX, anchorY) => {
+		const tooltip = options.tooltip;
+		if (tooltip === false) return null;
+		const custom = typeof tooltip === "object" ? tooltip.render : void 0;
+		let text = null;
+		if (custom) {
+			const result = custom(event);
+			if (result === null || result === "") return null;
+			if (typeof result === "string") text = result.split("\n");
+		}
+		const content = tooltipContent(model, event, scene?.layout.yTicks ?? null);
+		const lineHeight = 18;
+		const padding = 8;
+		let w = 0;
+		let lines;
+		if (text) {
+			for (const line of text) w = Math.max(w, measure(line, 12));
+			lines = text.length;
+		} else {
+			w = measure(content.title, 12, 600) + (content.titleColor ? 14 : 0);
+			for (const row of content.rows) w = Math.max(w, (row.color ? 14 : 0) + measure(row.name, 12) + 16 + measure(row.value, 12, 600));
+			lines = 1 + content.rows.length;
+		}
+		const boxW = Math.ceil(Math.max(w, 96) + 16 + 4);
+		const boxH = lines * lineHeight + 16;
+		let left = anchorX + 14;
+		if (left + boxW > width - 4) left = anchorX - 14 - boxW;
+		left = Math.max(4, Math.min(left, width - boxW - 4));
+		const top = Math.max(4, Math.min(anchorY - boxH / 2, height - boxH - 4));
+		return {
+			content,
+			text,
+			box: {
+				x: left,
+				y: top,
+				width: boxW,
+				height: boxH
+			},
+			lineHeight,
+			padding
+		};
+	};
+	const computeScene = () => {
+		if (width <= 0 || height <= 0) return null;
+		const legend = legendLayout();
+		const legendTop = legend?.position === "top" ? legend.height : 0;
+		const layout = layoutChart({
+			model,
+			view,
+			theme,
+			width,
+			height: height - (legend?.height ?? 0),
+			padding: options.padding,
+			top: legendTop,
+			measure: (text) => measure(text)
+		});
+		const labels = collectPointLabels(model, view, layout.scales);
+		const occupied = [];
+		const labelHeight = theme.fontSize + 4;
+		for (const a of annotations) {
+			if (a.type === "text" && a.text) {
+				occupied.push(textBox(a, layout.scales, measure(a.text, theme.fontSize, a.weight), labelHeight));
+				continue;
+			}
+			if (a.type !== "rect" || !a.label) continue;
+			const s = layout.scales;
+			const x0 = a.x0 === void 0 ? layout.plot.x : s.xToPx(a.x0);
+			const x1 = a.x1 === void 0 ? layout.plot.x + layout.plot.width : s.xToPx(a.x1);
+			const y0 = a.y0 === void 0 ? layout.plot.y + layout.plot.height : s.yToPx(a.y0);
+			const y1 = a.y1 === void 0 ? layout.plot.y : s.yToPx(a.y1);
+			const w = measure(a.label, theme.fontSize + 1, 600);
+			const left = Math.min(x0, x1);
+			const right = Math.max(x0, x1);
+			const top = Math.min(y0, y1);
+			const bottom = Math.max(y0, y1);
+			const pos = a.labelPosition;
+			occupied.push({
+				x: pos.endsWith("left") ? left + 10 : pos.endsWith("right") ? right - 10 - w : (left + right - w) / 2,
+				y: pos.startsWith("top") ? top + 10 : pos.startsWith("bottom") ? bottom - 10 - labelHeight : (top + bottom - labelHeight) / 2,
+				width: w,
+				height: labelHeight
+			});
+		}
+		const pointLabels = placeLabels(labels, layout.plot, (t) => measure(t), labelHeight - 2, occupied);
+		const next = {
+			width,
+			height,
+			theme,
+			model,
+			view: copyView(view),
+			layout,
+			annotations,
+			pointLabels,
+			legend,
+			hover: null,
+			dragging: null
+		};
+		scene = next;
+		if (hover) {
+			const crosshair = showsCrosshair(model, hover.event, options.crosshair);
+			const cx = layout.scales.xToPx(hover.event.items[0].x);
+			next.hover = {
+				event: hover.event,
+				marks: hoverMarks(model, layout.scales, hover.event),
+				crosshairX: crosshair && cx >= layout.plot.x && cx <= layout.plot.x + layout.plot.width ? cx : null,
+				tooltip: gesture?.kind === "pan" || gesture?.kind === "point" ? null : tooltipLayout(hover.event, hover.x, hover.y)
+			};
+		}
+		if (gesture?.kind === "point") {
+			const s = model.series[gesture.item.seriesIndex];
+			next.dragging = {
+				x: gesture.x,
+				y: gesture.y,
+				color: gesture.item.color,
+				size: (s ? dotSize(s, gesture.item.index) : 8) + 6
+			};
+		}
+		const rect = layout.plot;
+		const key = `${rect.x},${rect.y},${rect.width},${rect.height}`;
+		if (key !== lastPlot) {
+			lastPlot = key;
+			emit("layout", { ...rect });
+		}
+		return next;
+	};
+	const getScene = () => {
+		if (sceneDirty || !scene) {
+			sceneDirty = false;
+			scene = computeScene();
+		}
+		return scene;
+	};
+	const scales = () => getScene()?.layout.scales ?? null;
+	const setHover = (next) => {
+		const changed = !sameHover(hover?.event ?? null, next?.event ?? null);
+		hover = next;
+		invalidate();
+		if (changed) emit("hover", next ? next.event : null);
+	};
+	const hitAt = (x, y, touch) => {
+		const sc = scales();
+		return sc ? hitTest(model, sc, scene?.layout.xTicks ?? null, x, y, touch ? 8 : 0) : null;
+	};
+	const inPlot = (x, y) => {
+		const p = scales()?.plot;
+		return !!p && x >= p.x && x <= p.x + p.width && y >= p.y && y <= p.y + p.height;
+	};
+	const dataAt = (x, y) => {
+		const sc = scales();
+		if (!sc) return null;
+		const { plot } = sc;
+		const cx = Math.max(plot.x, Math.min(plot.x + plot.width, x));
+		const cy = Math.max(plot.y, Math.min(plot.y + plot.height, y));
+		return {
+			x: sc.pxToX(cx),
+			y: sc.pxToY(cy)
+		};
+	};
+	const setViewInternal = (next, notify) => {
+		const { base, minSpan } = model;
+		view = {
+			x: clampRange(next.x, base.x, minSpan.x),
+			y: clampRange(next.y, base.y, minSpan.y)
+		};
+		zoomed = !sameRange(view.x, base.x) || !sameRange(view.y, base.y);
+		if (notify) emit("zoom", copyView(view));
+		invalidate();
+	};
+	const zoomAt = (x, y, factor) => {
+		const sc = scales();
+		if (!sc || !model.zoom.x && !model.zoom.y) return;
+		const next = copyView(view);
+		if (model.zoom.x) next.x = zoomRange(view.x, sc.pxToX(x), factor);
+		if (model.zoom.y) next.y = zoomRange(view.y, sc.pxToY(y), factor);
+		setViewInternal(next, true);
+	};
+	const resetZoom = () => {
+		if (!zoomed) return;
+		setViewInternal(copyView(model.base), true);
+	};
+	const legendAt = (x, y) => getScene()?.legend?.entries.find((e) => x >= e.box.x && x <= e.box.x + e.box.width && y >= e.box.y && y <= e.box.y + e.box.height) ?? null;
+	const toggleSeries = (id) => {
+		if (hidden.has(id)) hidden.delete(id);
+		else hidden.add(id);
+		rebuild();
+	};
+	const startPinch = () => {
+		const [a, b] = [...pointers.values()];
+		gesture = {
+			kind: "pinch",
+			view: copyView(view),
+			distance: Math.max(1, Math.hypot(a.x - b.x, a.y - b.y)),
+			midX: (a.x + b.x) / 2,
+			midY: (a.y + b.y) / 2
+		};
+		setHover(null);
+	};
+	const pointerDown = (x, y, o = {}) => {
+		if (destroyed) return;
+		const id = o.id ?? 0;
+		const touch = !!o.touch;
+		pointers.set(id, {
+			x,
+			y,
+			startX: x,
+			startY: y,
+			touch,
+			moved: false
+		});
+		const it = interaction();
+		if (pointers.size === 2) {
+			if (it && (model.zoom.x || model.zoom.y) && gesture?.kind !== "point") startPinch();
+			return;
+		}
+		if (pointers.size > 2 || !it) {
+			if (!it && touch) {
+				const event = hitAt(x, y, true);
+				setHover(event ? {
+					event,
+					x,
+					y
+				} : null);
+			}
+			return;
+		}
+		if (it.dragPoints) {
+			const item = hitAt(x, y, touch)?.items.find((i) => model.series[i.seriesIndex].type === "scatter");
+			if (item) {
+				gesture = {
+					kind: "point",
+					item,
+					x,
+					y
+				};
+				return;
+			}
+		}
+		if (zoomed && it.pan && inPlot(x, y)) {
+			gesture = {
+				kind: "pan",
+				view: copyView(view),
+				x,
+				y
+			};
+			return;
+		}
+		gesture = null;
+		if (touch) {
+			const event = hitAt(x, y, true);
+			setHover(event ? {
+				event,
+				x,
+				y
+			} : null);
+		}
+	};
+	const pointerMove = (x, y, o = {}) => {
+		if (destroyed) return;
+		const id = o.id ?? 0;
+		const p = pointers.get(id);
+		if (p) {
+			p.x = x;
+			p.y = y;
+			if (!p.moved && Math.hypot(x - p.startX, y - p.startY) > (p.touch ? TOUCH_SLOP : TAP_SLOP)) p.moved = true;
+		}
+		if (gesture?.kind === "pinch" && pointers.size >= 2) {
+			const [a, b] = [...pointers.values()];
+			const distance = Math.max(1, Math.hypot(a.x - b.x, a.y - b.y));
+			const midX = (a.x + b.x) / 2;
+			const midY = (a.y + b.y) / 2;
+			const sc = scales();
+			if (!sc) return;
+			const start = createScales(sc.plot, gesture.view, model.x.reverse, model.y.reverse);
+			const factor = gesture.distance / distance;
+			const next = copyView(gesture.view);
+			if (model.zoom.x) {
+				next.x = zoomRange(gesture.view.x, start.pxToX(gesture.midX), factor);
+				const shift = (midX - gesture.midX) * start.xPerPx * factor;
+				next.x = panRange(next.x, model.x.reverse ? shift : -shift);
+			}
+			if (model.zoom.y) {
+				next.y = zoomRange(gesture.view.y, start.pxToY(gesture.midY), factor);
+				const shift = (midY - gesture.midY) * start.yPerPx * factor;
+				next.y = panRange(next.y, model.y.reverse ? -shift : shift);
+			}
+			setViewInternal(next, true);
+			return;
+		}
+		if (gesture?.kind === "point" && p) {
+			if (!p.moved) return;
+			gesture.x = x;
+			gesture.y = y;
+			const at = dataAt(x, y);
+			invalidate();
+			if (at) emit("drag", {
+				item: gesture.item,
+				x: at.x,
+				y: at.y
+			});
+			return;
+		}
+		if (gesture?.kind === "pan" && p) {
+			if (!p.moved) return;
+			const sc = scales();
+			if (!sc) return;
+			const dx = x - gesture.x;
+			const dy = y - gesture.y;
+			const next = copyView(gesture.view);
+			if (model.zoom.x) next.x = panRange(gesture.view.x, -dx * sc.xPerPx * (model.x.reverse ? -1 : 1));
+			if (model.zoom.y) next.y = panRange(gesture.view.y, dy * sc.yPerPx * (model.y.reverse ? -1 : 1));
+			setViewInternal(next, true);
+			return;
+		}
+		if (pointers.size > 1) return;
+		if (!p || p.touch || !o.touch) {
+			const event = hitAt(x, y, !!p?.touch || !!o.touch);
+			if (event || !p?.touch) setHover(event ? {
+				event,
+				x,
+				y
+			} : null);
+		}
+	};
+	const pointerUp = (x, y, o = {}) => {
+		if (destroyed) return;
+		const id = o.id ?? 0;
+		const p = pointers.get(id);
+		pointers.delete(id);
+		const current = gesture;
+		if (current?.kind === "pinch") {
+			if (pointers.size < 2) gesture = null;
+			return;
+		}
+		gesture = null;
+		if (!p) return;
+		if (current?.kind === "point") {
+			if (p.moved) {
+				const at = dataAt(x, y);
+				invalidate();
+				if (at) emit("drop", {
+					item: current.item,
+					x: at.x,
+					y: at.y
+				});
+				return;
+			}
+		} else if (current?.kind === "pan" && p.moved) {
+			invalidate();
+			return;
+		}
+		if (p.moved) {
+			if (p.touch) invalidate();
+			return;
+		}
+		const now = Date.now();
+		if (p.touch && now - lastTap.time < DOUBLE_TAP_MS && Math.hypot(x - lastTap.x, y - lastTap.y) < 24 && zoomed) {
+			lastTap = {
+				time: 0,
+				x,
+				y
+			};
+			resetZoom();
+			return;
+		}
+		lastTap = {
+			time: now,
+			x,
+			y
+		};
+		const legend = legendAt(x, y);
+		if (legend) {
+			if (getScene()?.legend?.toggle) toggleSeries(legend.id);
+			return;
+		}
+		const hit = hitAt(x, y, p.touch);
+		if (hit) {
+			if (p.touch) setHover({
+				event: hit,
+				x,
+				y
+			});
+			emit("click", hit);
+			return;
+		}
+		if (p.touch) setHover(null);
+		if (inPlot(x, y)) {
+			const at = dataAt(x, y);
+			if (at) emit("plotClick", at);
+		}
+	};
+	const pointerCancel = (o = {}) => {
+		pointers.delete(o.id ?? 0);
+		if (gesture?.kind === "point" || pointers.size < 2) gesture = null;
+		invalidate();
+	};
+	model = buildModel(options, theme, hidden, cache);
+	rebuild();
+	return {
+		setOptions(next) {
+			if (destroyed) return;
+			const paletteChanged = (next.palette ?? []).join() !== (options.palette ?? []).join();
+			options = next;
+			if (paletteChanged) theme = createTheme(themeInput, options.palette);
+			rebuild();
+		},
+		setTheme(next) {
+			if (destroyed) return;
+			themeInput = next;
+			theme = createTheme(themeInput, options.palette);
+			rebuild();
+		},
+		setSize(w, h) {
+			if (w === width && h === height) return;
+			width = Math.max(0, w);
+			height = Math.max(0, h);
+			invalidate();
+		},
+		getScene,
+		pointerDown,
+		pointerMove,
+		pointerUp,
+		pointerCancel,
+		pointerLeave() {
+			if (!gesture && hover) setHover(null);
+		},
+		zoomAt,
+		resetZoom,
+		getView: () => copyView(view),
+		setView(next) {
+			if (destroyed) return;
+			setViewInternal({
+				x: next.x ?? view.x,
+				y: next.y ?? view.y
+			}, false);
+		},
+		toggleSeries,
+		clearHover() {
+			if (hover) setHover(null);
+		},
+		getPlotRect() {
+			const p = getScene()?.layout.plot;
+			return p ? { ...p } : null;
+		},
+		toPixel(x, y) {
+			const sc = scales();
+			return sc ? {
+				x: sc.xToPx(x),
+				y: sc.yToPx(y)
+			} : null;
+		},
+		fromPixel(x, y) {
+			const sc = scales();
+			return sc ? {
+				x: sc.pxToX(x),
+				y: sc.pxToY(y)
+			} : null;
+		},
+		on(type, listener) {
+			let set = listeners[type];
+			if (!set) {
+				set = /* @__PURE__ */ new Set();
+				listeners[type] = set;
+			}
+			set.add(listener);
+			return () => {
+				set.delete(listener);
+			};
+		},
+		destroy() {
+			destroyed = true;
+			pointers.clear();
+			for (const key of Object.keys(listeners)) delete listeners[key];
+		}
+	};
+};
+//#endregion
+//#region ../charts/src/engine/renderers/types.ts
+/** Missing values are written as this sentinel (NaN is unreliable in shaders) */
+var GAP = 3e38;
+//#endregion
+//#region ../charts/src/engine/items.ts
+var rel = (value, origin) => Number.isFinite(value) ? value - origin : GAP;
+var points = (x, y, count, o) => {
+	const out = new Float32Array(count * 2);
+	for (let i = 0; i < count; i++) {
+		out[i * 2] = rel(x[i], o.x);
+		out[i * 2 + 1] = Number.isFinite(y[i]) ? y[i] - o.y : GAP;
+	}
+	return out;
+};
+var DRAW_ORDER = {
+	area: 0,
+	bar: 1,
+	line: 2,
+	scatter: 3
+};
+/** Render items of the visible series, back to front */
+var buildItems = (model, origin, version) => {
+	const items = [];
+	/** Outlines of the areas are drawn with the lines, above the bars */
+	const outlines = [];
+	const ordered = model.series.filter((s) => !s.hidden).sort((a, b) => DRAW_ORDER[a.type] - DRAW_ORDER[b.type] || a.index - b.index);
+	for (const s of ordered) {
+		const { x, y, count, sorted } = s.cols;
+		if ((s.type === "line" || s.type === "scatter") && outlines.length) items.push(...outlines.splice(0));
+		switch (s.type) {
+			case "line":
+			case "area": {
+				const pts = points(x, y, count, origin);
+				if (s.type === "area") items.push({
+					kind: "area",
+					key: `${s.key}:area`,
+					version,
+					color: s.color,
+					points: pts,
+					count,
+					baseline: model.baseline - origin.y,
+					opacity: s.opacity,
+					sorted
+				});
+				(s.type === "area" ? outlines : items).push({
+					kind: "line",
+					key: `${s.key}:line`,
+					version,
+					color: s.color,
+					points: pts,
+					count,
+					width: s.lineWidth,
+					sorted
+				});
+				break;
+			}
+			case "bar": {
+				const base = s.barBase ?? new Float64Array(count);
+				const top = s.barTop ?? y;
+				const instances = new Float32Array(count * 3);
+				for (let i = 0; i < count; i++) {
+					const valid = Number.isFinite(top[i]) && Number.isFinite(base[i]);
+					instances[i * 3] = rel(x[i] + s.barOffset, origin.x);
+					instances[i * 3 + 1] = valid ? base[i] - origin.y : GAP;
+					instances[i * 3 + 2] = valid ? top[i] - origin.y : GAP;
+				}
+				items.push({
+					kind: "bar",
+					key: `${s.key}:bar`,
+					version,
+					color: s.color,
+					instances,
+					count,
+					halfWidth: s.barHalfWidth,
+					sorted,
+					radius: model.series.some((o) => o !== s && !o.hidden && o.type === "bar" && o.barOffset === s.barOffset) ? 0 : 3
+				});
+				break;
+			}
+			default: {
+				const buffer = /* @__PURE__ */ new ArrayBuffer(count * 16);
+				const f = new Float32Array(buffer);
+				const u = new Uint32Array(buffer);
+				const seriesColor = packColor(s.color);
+				const sizes = s.cols.size;
+				for (let i = 0; i < count; i++) {
+					const valid = Number.isFinite(y[i]) && Number.isFinite(x[i]);
+					f[i * 4] = valid ? x[i] - origin.x : GAP;
+					f[i * 4 + 1] = valid ? y[i] - origin.y : GAP;
+					const size = sizes ? sizes[i] : NaN;
+					f[i * 4 + 2] = Number.isFinite(size) && size > 0 ? size : s.pointSize;
+					const pc = s.pointColors?.[i];
+					u[i * 4 + 3] = pc ? packColor(pc) : seriesColor;
+				}
+				items.push({
+					kind: "scatter",
+					key: `${s.key}:scatter`,
+					version,
+					color: s.color,
+					instances: buffer,
+					count,
+					opacity: s.opacity,
+					stroke: count <= 5e3 ? 1.25 : 0
+				});
+				break;
+			}
+		}
+	}
+	items.push(...outlines);
+	return items;
+};
+var rgba = (c, alpha) => `rgba(${Math.round(c[0] * 255)},${Math.round(c[1] * 255)},${Math.round(c[2] * 255)},${c[3] * alpha})`;
+var unpack = (packed) => [
+	(packed & 255) / 255,
+	(packed >>> 8 & 255) / 255,
+	(packed >>> 16 & 255) / 255,
+	(packed >>> 24 & 255) / 255
+];
+var isGap = (v) => !Number.isFinite(v) || Math.abs(v) >= 15e37;
+/** First point index whose relative x is >= value (sorted, interleaved) */
+var lowerBoundX = (points, count, value) => {
+	let lo = 0;
+	let hi = count;
+	while (lo < hi) {
+		const mid = lo + hi >>> 1;
+		if (points[mid * 2] < value) lo = mid + 1;
+		else hi = mid;
+	}
+	return lo;
+};
+/**
+* Data layer drawn with any 2D context (browser canvases, mini-program
+* canvases, OffscreenCanvas). `scratchCanvas` creates the canvas used to
+* rasterize very large scatter sets; without it they are drawn as one
+* square per occupied pixel cell.
+*/
+var createCanvas2dPainter = (ctx, scratchCanvas) => {
+	let scratch = null;
+	const mapper = (frame) => {
+		const { xScale, xOffset, yScale, yOffset } = frame.transform;
+		const w = frame.width;
+		const h = frame.height;
+		return {
+			px: (x) => ((x * xScale + xOffset) * .5 + .5) * w,
+			py: (y) => (1 - ((y * yScale + yOffset) * .5 + .5)) * h,
+			/** Visible relative x range */
+			xRange: () => {
+				const a = (-1 - xOffset) / xScale;
+				const b = (1 - xOffset) / xScale;
+				return a < b ? [a, b] : [b, a];
+			}
+		};
+	};
+	/** Points actually drawn: decimated when there are many per pixel */
+	const visiblePoints = (item, frame) => {
+		if (!item.sorted || item.count <= frame.width * 2) return {
+			points: item.points,
+			length: item.count
+		};
+		const m = mapper(frame);
+		const [x0, x1] = m.xRange();
+		const start = Math.max(0, lowerBoundX(item.points, item.count, x0) - 1);
+		const end = Math.min(item.count, lowerBoundX(item.points, item.count, x1) + 1);
+		const result = decimateMinMax(item.points, start, end, m.px, GAP * .5);
+		return {
+			points: result.points,
+			length: result.length
+		};
+	};
+	const drawLine = (item, frame) => {
+		const m = mapper(frame);
+		const { points, length } = visiblePoints(item, frame);
+		ctx.beginPath();
+		let pen = false;
+		for (let i = 0; i < length; i++) {
+			const x = points[i * 2];
+			const y = points[i * 2 + 1];
+			if (isGap(x) || isGap(y)) {
+				pen = false;
+				continue;
+			}
+			if (pen) ctx.lineTo(m.px(x), m.py(y));
+			else ctx.moveTo(m.px(x), m.py(y));
+			pen = true;
+		}
+		ctx.lineWidth = item.width * frame.dpr;
+		ctx.lineJoin = "round";
+		ctx.lineCap = "round";
+		ctx.strokeStyle = rgba(item.color, 1);
+		ctx.stroke();
+	};
+	const drawArea = (item, frame) => {
+		const m = mapper(frame);
+		const { points, length } = visiblePoints(item, frame);
+		const base = m.py(item.baseline);
+		const gradient = ctx.createLinearGradient(0, 0, 0, base);
+		gradient.addColorStop(0, rgba(item.color, item.opacity));
+		gradient.addColorStop(1, rgba(item.color, item.opacity * .3));
+		ctx.fillStyle = gradient;
+		ctx.beginPath();
+		let runStart = -1;
+		let lastX = 0;
+		const close = () => {
+			if (runStart < 0) return;
+			ctx.lineTo(lastX, base);
+			ctx.closePath();
+			runStart = -1;
+		};
+		for (let i = 0; i < length; i++) {
+			const x = points[i * 2];
+			const y = points[i * 2 + 1];
+			if (isGap(x) || isGap(y)) {
+				close();
+				continue;
+			}
+			const px = m.px(x);
+			if (runStart < 0) {
+				runStart = i;
+				ctx.moveTo(px, base);
+			}
+			ctx.lineTo(px, m.py(y));
+			lastX = px;
+		}
+		close();
+		ctx.fill();
+	};
+	const drawBars = (item, frame) => {
+		const m = mapper(frame);
+		const half = Math.max(Math.abs(item.halfWidth * frame.transform.xScale) * .5 * frame.width, .5);
+		const r = item.radius * frame.dpr;
+		ctx.fillStyle = rgba(item.color, 1);
+		ctx.beginPath();
+		const v = item.instances;
+		for (let i = 0; i < item.count; i++) {
+			const x = v[i * 3];
+			const y0 = v[i * 3 + 1];
+			const y1 = v[i * 3 + 2];
+			if (isGap(x) || isGap(y0) || isGap(y1)) continue;
+			const cx = m.px(x);
+			const a = m.py(y0);
+			const b = m.py(y1);
+			const top = Math.min(a, b);
+			const height = Math.abs(a - b);
+			const radius = Math.min(r, half, height / 2);
+			if (radius > .5 && typeof ctx.roundRect === "function") ctx.roundRect(cx - half, top, half * 2, height, radius);
+			else ctx.rect(cx - half, top, half * 2, height);
+		}
+		ctx.fill();
+	};
+	/** One square per occupied cell (the last point of a cell wins, like the GPU) */
+	const drawScatterCells = (item, frame) => {
+		const m = mapper(frame);
+		const w = frame.width;
+		const h = frame.height;
+		const f = new Float32Array(item.instances, 0, item.count * 4);
+		const u = new Uint32Array(item.instances, 0, item.count * 4);
+		let cell = 0;
+		for (let i = 0; i < Math.min(item.count, 64); i++) cell = Math.max(cell, f[i * 4 + 2]);
+		cell = Math.max(1, Math.round((cell || 2) * frame.dpr * .8));
+		const cols = Math.ceil(w / cell);
+		const rows = Math.ceil(h / cell);
+		const owner = new Int32Array(cols * rows).fill(-1);
+		for (let i = 0; i < item.count; i++) {
+			const x = f[i * 4];
+			const y = f[i * 4 + 1];
+			if (isGap(x) || isGap(y) || !(f[i * 4 + 2] > 0)) continue;
+			const cx = Math.floor(m.px(x) / cell);
+			const cy = Math.floor(m.py(y) / cell);
+			if (cx < 0 || cy < 0 || cx >= cols || cy >= rows) continue;
+			owner[cy * cols + cx] = i;
+		}
+		const groups = /* @__PURE__ */ new Map();
+		for (let c = 0; c < owner.length; c++) {
+			const i = owner[c];
+			if (i < 0) continue;
+			const packed = u[i * 4 + 3];
+			let list = groups.get(packed);
+			if (!list) groups.set(packed, list = []);
+			list.push(c);
+		}
+		for (const [packed, cells] of groups) {
+			ctx.fillStyle = rgba(unpack(packed), Math.max(item.opacity, .6));
+			for (const c of cells) ctx.fillRect(c % cols * cell, Math.floor(c / cols) * cell, cell, cell);
+		}
+	};
+	const drawScatterPixels = (item, frame) => {
+		const m = mapper(frame);
+		const w = frame.width;
+		const h = frame.height;
+		scratch ??= scratchCanvas?.() ?? null;
+		if (!scratch) {
+			drawScatterCells(item, frame);
+			return;
+		}
+		scratch.width = w;
+		scratch.height = h;
+		const sctx = scratch.getContext("2d");
+		if (!sctx) return;
+		const image = sctx.createImageData(w, h);
+		const data = image.data;
+		const f = new Float32Array(item.instances, 0, item.count * 4);
+		const u = new Uint32Array(item.instances, 0, item.count * 4);
+		for (let i = 0; i < item.count; i++) {
+			const x = f[i * 4];
+			const y = f[i * 4 + 1];
+			const size = f[i * 4 + 2];
+			if (isGap(x) || isGap(y) || !(size > 0)) continue;
+			const cx = m.px(x);
+			const cy = m.py(y);
+			const s = Math.max(1, Math.round(size * frame.dpr * .8));
+			const x0 = Math.round(cx - s / 2);
+			const y0 = Math.round(cy - s / 2);
+			const packed = u[i * 4 + 3];
+			const alpha = (packed >>> 24 & 255) / 255 * Math.max(item.opacity, .6);
+			const r = packed & 255;
+			const g = packed >>> 8 & 255;
+			const b = packed >>> 16 & 255;
+			for (let py = Math.max(0, y0); py < Math.min(h, y0 + s); py++) for (let px = Math.max(0, x0); px < Math.min(w, x0 + s); px++) {
+				const o = (py * w + px) * 4;
+				const da = data[o + 3] / 255;
+				const outA = alpha + da * (1 - alpha);
+				data[o] = (r * alpha + data[o] * da * (1 - alpha)) / outA;
+				data[o + 1] = (g * alpha + data[o + 1] * da * (1 - alpha)) / outA;
+				data[o + 2] = (b * alpha + data[o + 2] * da * (1 - alpha)) / outA;
+				data[o + 3] = outA * 255;
+			}
+		}
+		sctx.putImageData(image, 0, 0);
+		ctx.drawImage(scratch, 0, 0);
+	};
+	const drawScatter = (item, frame) => {
+		if (item.count > 2e4) {
+			drawScatterPixels(item, frame);
+			return;
+		}
+		const m = mapper(frame);
+		const f = new Float32Array(item.instances, 0, item.count * 4);
+		const u = new Uint32Array(item.instances, 0, item.count * 4);
+		const groups = /* @__PURE__ */ new Map();
+		for (let i = 0; i < item.count; i++) {
+			const packed = u[i * 4 + 3];
+			let list = groups.get(packed);
+			if (!list) groups.set(packed, list = []);
+			list.push(i);
+		}
+		const stroke = item.stroke * frame.dpr;
+		for (const [packed, list] of groups) {
+			const color = unpack(packed);
+			ctx.beginPath();
+			for (const i of list) {
+				const x = f[i * 4];
+				const y = f[i * 4 + 1];
+				const size = f[i * 4 + 2];
+				if (isGap(x) || isGap(y) || !(size > 0)) continue;
+				const cx = m.px(x);
+				const cy = m.py(y);
+				const r = size * frame.dpr / 2;
+				ctx.moveTo(cx + r, cy);
+				ctx.arc(cx, cy, r, 0, Math.PI * 2);
+			}
+			ctx.fillStyle = rgba(color, item.opacity);
+			ctx.fill();
+			if (stroke > 0) {
+				ctx.beginPath();
+				for (const i of list) {
+					const x = f[i * 4];
+					const y = f[i * 4 + 1];
+					const size = f[i * 4 + 2];
+					if (isGap(x) || isGap(y) || !(size > 0)) continue;
+					const r = Math.max(0, size * frame.dpr / 2 - stroke / 2);
+					const cx = m.px(x);
+					const cy = m.py(y);
+					ctx.moveTo(cx + r, cy);
+					ctx.arc(cx, cy, r, 0, Math.PI * 2);
+				}
+				ctx.lineWidth = stroke;
+				ctx.strokeStyle = rgba(color, 1);
+				ctx.stroke();
+			}
+		}
+	};
+	return {
+		paint(items, frame, left = 0, top = 0) {
+			ctx.save();
+			ctx.setTransform(1, 0, 0, 1, left, top);
+			ctx.beginPath();
+			ctx.rect(0, 0, frame.width, frame.height);
+			ctx.clip();
+			for (const item of items) switch (item.kind) {
+				case "line":
+					if (item.count > 1) drawLine(item, frame);
+					break;
+				case "area":
+					if (item.count > 1) drawArea(item, frame);
+					break;
+				case "bar":
+					drawBars(item, frame);
+					break;
+				default: drawScatter(item, frame);
+			}
+			ctx.restore();
+		},
+		destroy() {
+			scratch = null;
+		}
+	};
+};
+//#endregion
+//#region ../charts/src/engine/canvas.ts
+var mid = (r) => (r[0] + r[1]) / 2;
+var roundedRect = (ctx, x, y, w, h, r) => {
+	ctx.beginPath();
+	ctx.moveTo(x + r, y);
+	ctx.lineTo(x + w - r, y);
+	ctx.arcTo(x + w, y, x + w, y + r, r);
+	ctx.lineTo(x + w, y + h - r);
+	ctx.arcTo(x + w, y + h, x + w - r, y + h, r);
+	ctx.lineTo(x + r, y + h);
+	ctx.arcTo(x, y + h, x, y + h - r, r);
+	ctx.lineTo(x, y + r);
+	ctx.arcTo(x, y, x + r, y, r);
+	ctx.closePath();
+};
+/** Draws a scene (legend, axes, data, labels, hover) on a 2D context */
+var drawScene = (ctx, scene, items, origin, pixelRatio, painter = createCanvas2dPainter(ctx)) => {
+	const { width, height, theme, model, view, layout } = scene;
+	const { plot, scales } = layout;
+	const dpr = pixelRatio;
+	ctx.setTransform(1, 0, 0, 1, 0, 0);
+	ctx.clearRect(0, 0, Math.ceil(width * dpr), Math.ceil(height * dpr));
+	ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+	drawBackground(ctx, {
+		width,
+		height,
+		scales,
+		x: model.x,
+		y: model.y,
+		xTicks: layout.xTicks,
+		yTicks: layout.yTicks,
+		theme,
+		annotations: scene.annotations
+	});
+	if (scene.legend) {
+		ctx.font = font(theme, 12);
+		ctx.textBaseline = "middle";
+		ctx.textAlign = "left";
+		for (const e of scene.legend.entries) {
+			const cy = e.box.y + e.box.height / 2;
+			ctx.globalAlpha = e.hidden ? .45 : 1;
+			ctx.fillStyle = e.color;
+			if (e.shape === "dot") {
+				ctx.beginPath();
+				ctx.arc(e.box.x + 5, cy, 4, 0, Math.PI * 2);
+				ctx.fill();
+			} else if (e.shape === "line") ctx.fillRect(e.box.x, cy - 1, 10, 2);
+			else ctx.fillRect(e.box.x + 1, cy - 4, 8, 8);
+			ctx.fillStyle = toCss(theme.textMuted);
+			ctx.fillText(e.name, e.box.x + 14, cy);
+			if (e.hidden) {
+				const w = e.box.width - 22;
+				ctx.fillRect(e.box.x + 14, cy, w, 1);
+			}
+		}
+		ctx.globalAlpha = 1;
+	}
+	const scale = (range, o, reverse) => {
+		const s = 2 / (range[1] - range[0]);
+		const offset = (o - range[0]) * s - 1;
+		return reverse ? [-s, -offset] : [s, offset];
+	};
+	const [xScale, xOffset] = scale(view.x, origin.x, model.x.reverse);
+	const [yScale, yOffset] = scale(view.y, origin.y, model.y.reverse);
+	painter.paint(items, {
+		transform: {
+			xScale,
+			xOffset,
+			yScale,
+			yOffset
+		},
+		width: Math.max(1, Math.round(plot.width * dpr)),
+		height: Math.max(1, Math.round(plot.height * dpr)),
+		dpr
+	}, Math.round(plot.x * dpr), Math.round(plot.y * dpr));
+	ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+	drawForeground(ctx, {
+		width,
+		height,
+		scales,
+		theme,
+		annotations: scene.annotations,
+		pointLabels: [],
+		clear: false
+	});
+	if (scene.pointLabels.length) {
+		ctx.save();
+		ctx.font = font(theme);
+		ctx.textAlign = "left";
+		ctx.textBaseline = "middle";
+		ctx.lineWidth = 3;
+		ctx.lineJoin = "round";
+		ctx.strokeStyle = toCss(theme.background, .9);
+		ctx.fillStyle = toCss(theme.text, .85);
+		for (const { label, box } of scene.pointLabels) {
+			ctx.strokeText(label.text, box.x, box.y + box.height / 2);
+			ctx.fillText(label.text, box.x, box.y + box.height / 2);
+		}
+		ctx.restore();
+	}
+	const hover = scene.hover;
+	if (hover) {
+		if (hover.crosshairX !== null) {
+			ctx.save();
+			ctx.strokeStyle = toCss(theme.textMuted, .55);
+			ctx.lineWidth = 1;
+			ctx.setLineDash([3, 3]);
+			ctx.beginPath();
+			const cx = Math.round(hover.crosshairX) + .5;
+			ctx.moveTo(cx, plot.y);
+			ctx.lineTo(cx, plot.y + plot.height);
+			ctx.stroke();
+			ctx.restore();
+		}
+		for (const mark of hover.marks) {
+			if (mark.kind === "bar") {
+				ctx.fillStyle = toCss(theme.text, .08);
+				ctx.fillRect(mark.x - 2, mark.y - 2, mark.width + 4, mark.height + 2);
+				continue;
+			}
+			ctx.beginPath();
+			ctx.arc(mark.x, mark.y, mark.size / 2, 0, Math.PI * 2);
+			ctx.fillStyle = mark.color;
+			ctx.fill();
+			ctx.lineWidth = 2;
+			ctx.strokeStyle = toCss(theme.background);
+			ctx.stroke();
+		}
+	}
+	if (scene.dragging) {
+		const d = scene.dragging;
+		ctx.beginPath();
+		ctx.arc(d.x, d.y, d.size / 2, 0, Math.PI * 2);
+		ctx.fillStyle = d.color;
+		ctx.globalAlpha = .85;
+		ctx.fill();
+		ctx.globalAlpha = 1;
+		ctx.lineWidth = 2;
+		ctx.strokeStyle = toCss(theme.background);
+		ctx.stroke();
+	}
+	const tip = hover?.tooltip;
+	if (tip) {
+		const { box, lineHeight, padding } = tip;
+		ctx.save();
+		ctx.shadowColor = "rgba(15, 23, 42, 0.18)";
+		ctx.shadowBlur = 16;
+		ctx.shadowOffsetY = 6;
+		roundedRect(ctx, box.x, box.y, box.width, box.height, 8);
+		ctx.fillStyle = toCss(theme.background);
+		ctx.fill();
+		ctx.restore();
+		roundedRect(ctx, box.x + .5, box.y + .5, box.width - 1, box.height - 1, 8);
+		ctx.strokeStyle = toCss(theme.axis);
+		ctx.lineWidth = 1;
+		ctx.stroke();
+		ctx.textBaseline = "middle";
+		let y = box.y + padding + lineHeight / 2;
+		const left = box.x + padding + 2;
+		const right = box.x + box.width - padding - 2;
+		if (tip.text) {
+			ctx.font = font(theme, 12);
+			ctx.fillStyle = toCss(theme.text);
+			ctx.textAlign = "left";
+			for (const line of tip.text) {
+				ctx.fillText(line, left, y);
+				y += lineHeight;
+			}
+		} else {
+			const { content } = tip;
+			let x = left;
+			if (content.titleColor) {
+				ctx.fillStyle = content.titleColor;
+				ctx.beginPath();
+				ctx.arc(x + 4, y, 4, 0, Math.PI * 2);
+				ctx.fill();
+				x += 14;
+			}
+			ctx.font = font(theme, 12, 600);
+			ctx.fillStyle = toCss(theme.text);
+			ctx.textAlign = "left";
+			ctx.fillText(content.title, x, y);
+			y += lineHeight;
+			for (const row of content.rows) {
+				x = left;
+				if (row.color) {
+					ctx.fillStyle = row.color;
+					ctx.beginPath();
+					ctx.arc(x + 4, y, 4, 0, Math.PI * 2);
+					ctx.fill();
+					x += 14;
+				}
+				ctx.font = font(theme, 12);
+				ctx.textAlign = "left";
+				ctx.fillStyle = toCss(theme.textMuted);
+				ctx.fillText(row.name, x, y);
+				ctx.font = font(theme, 12, 600);
+				ctx.textAlign = "right";
+				ctx.fillStyle = toCss(theme.text);
+				ctx.fillText(row.value, right, y);
+				y += lineHeight;
+			}
+		}
+	}
+};
+/**
+* Creates a chart drawn on a 2D canvas: line, area, bar and scatter series,
+* annotations, legend and tooltip, tap / drag / pinch gestures. Works
+* without a DOM (mini-programs); see `createChart` for the GPU version of
+* the web.
+*/
+var createCanvasChart = (config) => {
+	const { canvas } = config;
+	const ctx = canvas.getContext("2d");
+	let width = config.width;
+	let height = config.height;
+	let dpr = config.pixelRatio ?? 1;
+	let destroyed = false;
+	let frameId = null;
+	let items = [];
+	let itemsModel = null;
+	let origin = {
+		x: 0,
+		y: 0
+	};
+	let version = 0;
+	let fontSet = "";
+	const measureText = (text, f) => {
+		if (!ctx) return text.length * 6.5;
+		if (f !== fontSet) {
+			ctx.font = f;
+			fontSet = f;
+		}
+		return ctx.measureText(text).width;
+	};
+	const painter = ctx ? createCanvas2dPainter(ctx) : null;
+	const g = globalThis;
+	const render = () => {
+		frameId = null;
+		if (destroyed || !ctx || !painter) return;
+		const scene = controller.getScene();
+		if (!scene) return;
+		const pw = Math.max(1, Math.round(width * dpr));
+		const ph = Math.max(1, Math.round(height * dpr));
+		if (canvas.width !== pw) canvas.width = pw;
+		if (canvas.height !== ph) canvas.height = ph;
+		fontSet = "";
+		if (itemsModel !== scene.model) {
+			itemsModel = scene.model;
+			origin = {
+				x: mid(scene.model.base.x),
+				y: mid(scene.model.base.y)
+			};
+			items = buildItems(scene.model, origin, ++version);
+		}
+		drawScene(ctx, scene, items, origin, dpr, painter);
+		fontSet = "";
+	};
+	const schedule = () => {
+		if (destroyed || frameId !== null) return;
+		if (canvas.requestAnimationFrame) frameId = canvas.requestAnimationFrame(render);
+		else if (g.requestAnimationFrame) frameId = g.requestAnimationFrame(render);
+		else frameId = setTimeout(render, 16);
+	};
+	const controller = createChartController({
+		options: config.options,
+		theme: config.theme,
+		measureText,
+		onInvalidate: schedule
+	});
+	controller.setSize(width, height);
+	const touchOptions = (t, i) => ({
+		id: t.identifier ?? i,
+		touch: true
+	});
+	return {
+		setOptions: (o) => controller.setOptions(o),
+		setTheme: (t) => controller.setTheme(t),
+		resize(w, h, ratio) {
+			width = w;
+			height = h;
+			if (ratio) dpr = ratio;
+			controller.setSize(w, h);
+			schedule();
+		},
+		render() {
+			if (frameId !== null) {
+				if (canvas.cancelAnimationFrame) canvas.cancelAnimationFrame(frameId);
+				else if (g.cancelAnimationFrame) g.cancelAnimationFrame(frameId);
+				else clearTimeout(frameId);
+			}
+			render();
+		},
+		touchStart(touches) {
+			touches.forEach((t, i) => controller.pointerDown(t.x, t.y, touchOptions(t, i)));
+		},
+		touchMove(touches) {
+			touches.forEach((t, i) => controller.pointerMove(t.x, t.y, touchOptions(t, i)));
+		},
+		touchEnd(touches) {
+			touches.forEach((t, i) => controller.pointerUp(t.x, t.y, touchOptions(t, i)));
+		},
+		touchCancel(touches = [{
+			x: 0,
+			y: 0
+		}]) {
+			touches.forEach((t, i) => controller.pointerCancel(touchOptions(t, i)));
+		},
+		pointerDown: (x, y, o) => controller.pointerDown(x, y, o),
+		pointerMove: (x, y, o) => controller.pointerMove(x, y, o),
+		pointerUp: (x, y, o) => controller.pointerUp(x, y, o),
+		pointerLeave: () => controller.pointerLeave(),
+		zoomAt: (x, y, f) => controller.zoomAt(x, y, f),
+		resetZoom: () => controller.resetZoom(),
+		getView: () => controller.getView(),
+		setView: (v) => controller.setView(v),
+		toggleSeries: (id) => controller.toggleSeries(id),
+		clearHover: () => controller.clearHover(),
+		getPlotRect: () => controller.getPlotRect(),
+		toPixel: (x, y) => controller.toPixel(x, y),
+		fromPixel: (x, y) => controller.fromPixel(x, y),
+		getController: () => controller,
+		on: (type, listener) => controller.on(type, listener),
+		destroy() {
+			if (destroyed) return;
+			destroyed = true;
+			if (frameId !== null) {
+				if (canvas.cancelAnimationFrame) canvas.cancelAnimationFrame(frameId);
+				else if (g.cancelAnimationFrame) g.cancelAnimationFrame(frameId);
+				else clearTimeout(frameId);
+			}
+			painter?.destroy();
+			controller.destroy();
+		}
+	};
+};
+//#endregion
+//#region ../charts/src/engine/presets.ts
+/** Gives the series without a `type` the type of the component */
+var withSeriesType = (series, type, stack) => series.map((s) => ({
+	...s,
+	type: s.type ?? type,
+	...stack !== void 0 && (s.type ?? type) === "bar" ? { stack: s.stack ?? stack } : {}
+}));
+/** Series of a LineChart (`area` fills them) */
+var lineSeries = (series, area = false) => withSeriesType(series, area ? "area" : "line");
+/** Series of a BarChart (`stacked` stacks them) */
+var barSeries = (series, stacked = false) => withSeriesType(series, "bar", stacked ? "stack" : void 0);
+/** Series of a ScatterChart */
+var scatterSeries = (series) => withSeriesType(series, "scatter");
+var DEFAULT_QUADRANT_COLORS = {
+	topLeft: "var(--danger-color, #ef4444)",
+	topRight: "var(--primary-color, #4f46e5)",
+	bottomLeft: "var(--warning-color, #f59e0b)",
+	bottomRight: "var(--text-secondary-color, #64748b)"
+};
+var DIVIDER = "var(--border-strong-color, var(--border-color, #cbd5e1))";
+var splits = (config) => {
+	const [x0, x1] = config.xDomain ?? [0, 10];
+	const [y0, y1] = config.yDomain ?? [0, 10];
+	return {
+		x0,
+		x1,
+		y0,
+		y1,
+		xs: config.xSplit ?? (x0 + x1) / 2,
+		ys: config.ySplit ?? (y0 + y1) / 2
+	};
+};
+/** Quadrant of a data position, as seen on screen */
+var quadrantOf = (config, x, y) => {
+	const { xs, ys } = splits(config);
+	const right = config.reverseX ? x < xs : x >= xs;
+	return y >= ys ? right ? "topRight" : "topLeft" : right ? "bottomRight" : "bottomLeft";
+};
+/** Engine options of a quadrant matrix */
+var quadrantChartOptions = (config, base = {}) => {
+	const { x0, x1, y0, y1, xs, ys } = splits(config);
+	const reverseX = !!config.reverseX;
+	const color = (corner) => config.quadrants?.[corner]?.color ?? DEFAULT_QUADRANT_COLORS[corner];
+	const series = [{
+		type: "scatter",
+		name: config.name ?? "",
+		pointSize: config.pointSize ?? 12,
+		showLabels: config.showLabels ?? true,
+		opacity: .9,
+		data: config.points.map((p) => ({
+			x: p.x,
+			y: p.y,
+			label: p.label,
+			size: p.size,
+			color: p.color ?? color(quadrantOf(config, p.x, p.y))
+		}))
+	}];
+	const left = reverseX ? [xs, x1] : [x0, xs];
+	const right = reverseX ? [x0, xs] : [xs, x1];
+	const rect = (corner, [xa, xb], [ya, yb], position) => ({
+		type: "rect",
+		x0: xa,
+		x1: xb,
+		y0: ya,
+		y1: yb,
+		color: color(corner),
+		opacity: .07,
+		label: config.quadrants?.[corner]?.label,
+		labelPosition: position
+	});
+	const ends = config.axisLabels ?? {};
+	const visualLeft = reverseX ? x1 : x0;
+	const visualRight = reverseX ? x0 : x1;
+	const texts = [
+		...ends.top ? [{
+			type: "text",
+			x: xs,
+			y: y1,
+			text: ends.top,
+			anchor: "top"
+		}] : [],
+		...ends.bottom ? [{
+			type: "text",
+			x: xs,
+			y: y0,
+			text: ends.bottom,
+			anchor: "bottom"
+		}] : [],
+		...ends.left ? [{
+			type: "text",
+			x: visualLeft,
+			y: ys,
+			text: ends.left,
+			anchor: "left"
+		}] : [],
+		...ends.right ? [{
+			type: "text",
+			x: visualRight,
+			y: ys,
+			text: ends.right,
+			anchor: "right"
+		}] : []
+	];
+	const annotations = [
+		rect("topLeft", left, [ys, y1], "top-left"),
+		rect("topRight", right, [ys, y1], "top-right"),
+		rect("bottomLeft", left, [y0, ys], "bottom-left"),
+		rect("bottomRight", right, [y0, ys], "bottom-right"),
+		{
+			type: "line",
+			axis: "x",
+			value: xs,
+			dash: [],
+			color: DIVIDER
+		},
+		{
+			type: "line",
+			axis: "y",
+			value: ys,
+			dash: [],
+			color: DIVIDER
+		},
+		...texts,
+		...base.annotations ?? []
+	];
+	const showTicks = config.showTicks ?? true;
+	const interaction = base.interaction === false ? false : {
+		zoom: false,
+		...typeof base.interaction === "object" ? base.interaction : {},
+		...config.draggable ? { dragPoints: true } : {}
+	};
+	return {
+		...base,
+		series,
+		annotations,
+		tooltip: base.tooltip ?? (showTicks ? void 0 : { render: (event) => {
+			const item = event.items[0];
+			if (!item) return null;
+			const region = config.quadrants?.[quadrantOf(config, item.x, item.y)]?.label;
+			return [item.label ?? config.name ?? "", region ?? ""].filter(Boolean).join("\n");
+		} }),
+		xAxis: {
+			min: x0,
+			max: x1,
+			title: config.xLabel,
+			reverse: reverseX,
+			nice: false,
+			grid: false,
+			tickCount: 4,
+			visible: showTicks || !!config.xLabel,
+			...showTicks ? {} : { format: () => "" }
+		},
+		yAxis: {
+			min: y0,
+			max: y1,
+			title: config.yLabel,
+			nice: false,
+			grid: false,
+			tickCount: 4,
+			visible: showTicks || !!config.yLabel,
+			...showTicks ? {} : { format: () => "" }
+		},
+		legend: base.legend ?? false,
+		padding: base.padding ?? (showTicks ? void 0 : {
+			top: 4,
+			right: 4,
+			bottom: 4,
+			left: 4
+		}),
+		interaction
+	};
+};
+//#endregion
+//#region src/charts.ts
+var states = /* @__PURE__ */ new WeakMap();
+var optional$4 = () => ({
+	type: null,
+	value: null
+});
+var flag$6 = (value = false) => ({
+	type: Boolean,
+	value
+});
+var text$4 = (value = "") => ({
+	type: String,
+	value
+});
+var list$2 = () => ({
+	type: Array,
+	value: []
+});
+/** `null` / `""` properties mean "not set" (engine default) */
+var unset = (value) => value === null || value === "" ? void 0 : value;
+var nonEmpty = (value) => value && value.length ? value : void 0;
+/** Numbers and digit strings are px, other strings are CSS lengths */
+var cssSize = (value, fallback) => typeof value === "number" && Number.isFinite(value) ? `${value}px` : typeof value === "string" && value.trim() ? /^\d+(\.\d+)?$/.test(value.trim()) ? `${value.trim()}px` : value.trim() : fallback;
+var pixelRatio = () => {
+	try {
+		const ratio = Number(windowInfo().pixelRatio);
+		return ratio > 0 ? ratio : 1;
+	} catch {
+		return 1;
+	}
+};
+var isRecord = (value) => typeof value === "object" && value !== null;
+var themeCache = /* @__PURE__ */ new Map();
+/**
+* Chart theme of a configuration: the resolved Minerva token values of its
+* mode, palette, design and custom theme as `--name` variables (the engine
+* resolves `var(--name, fallback)` colors of the options against them).
+*/
+function chartTheme(config) {
+	const mode = config?.resolvedMode === "dark" ? "dark" : "light";
+	const theme = config?.theme;
+	const custom = theme === "github-dark" ? githubDark : isRecord(theme) ? "light" in theme && "dark" in theme ? theme[mode] : theme : void 0;
+	const options = {
+		mode,
+		palette: config?.palette ?? null,
+		design: config?.design ?? {},
+		...isRecord(custom) ? { overrides: custom } : {}
+	};
+	const key = JSON.stringify(options);
+	const cached = themeCache.get(key);
+	if (cached) return cached;
+	const css = resolveTokens(options).css;
+	const variables = {};
+	for (const [name, value] of Object.entries(css)) variables[`--${name}`] = String(value);
+	const result = {
+		variables,
+		...css["font-family-sans"] ? { fontFamily: String(css["font-family-sans"]) } : {}
+	};
+	if (themeCache.size > 32) themeCache.clear();
+	themeCache.set(key, result);
+	return result;
+}
+var stateOf = (self, kind) => {
+	let state = states.get(self);
+	if (!state) {
+		state = {
+			kind,
+			chart: null,
+			config: {},
+			theme: void 0,
+			themeKey: "",
+			ready: false
+		};
+		states.set(self, state);
+	}
+	return state;
+};
+var configOf = (self) => typeof self.getConfig === "function" ? self.getConfig() : void 0;
+var tooltipOption = (value, render) => !render || value === false ? value : {
+	...isRecord(value) ? value : {},
+	render
+};
+var axisOption = (value, format) => format ? {
+	...value,
+	format
+} : value;
+/** Options shared by every chart (everything but the series and axes) */
+var baseOptions = (self, render) => {
+	const d = self.data;
+	return {
+		legend: unset(d.legend),
+		tooltip: tooltipOption(unset(d.tooltip), render),
+		crosshair: unset(d.crosshair),
+		annotations: nonEmpty(d.annotations),
+		interaction: unset(d.interaction),
+		padding: unset(d.padding),
+		palette: nonEmpty(d.palette),
+		ariaLabel: d.ariaLabel || void 0
+	};
+};
+var quadrantConfig = (self) => {
+	const d = self.data;
+	return {
+		points: d.points ?? [],
+		xDomain: unset(d.xDomain),
+		yDomain: unset(d.yDomain),
+		xSplit: unset(d.xSplit),
+		ySplit: unset(d.ySplit),
+		quadrants: unset(d.quadrants),
+		xLabel: d.xLabel || void 0,
+		yLabel: d.yLabel || void 0,
+		axisLabels: unset(d.axisLabels),
+		showTicks: d.showTicks,
+		reverseX: d.reverseX,
+		showLabels: d.showLabels,
+		pointSize: d.pointSize,
+		name: d.name || void 0,
+		draggable: d.draggable
+	};
+};
+/** Engine options of the current properties, like the web components */
+var chartOptions = (self, state) => {
+	const d = self.data;
+	const { config } = state;
+	if (state.kind === "quadrant") {
+		const points = d.points ?? [];
+		const render = config.renderTooltip;
+		return quadrantChartOptions(quadrantConfig(self), baseOptions(self, render ? (event) => {
+			const index = event.items[0]?.index;
+			return index !== void 0 && points[index] ? render(points[index], index) : null;
+		} : void 0));
+	}
+	const { renderTooltip, xAxis, yAxis } = config;
+	const input = d.series ?? [];
+	const series = state.kind === "line" ? lineSeries(input, !!d.area) : state.kind === "bar" ? barSeries(input, !!d.stacked) : state.kind === "scatter" ? scatterSeries(input) : input;
+	return {
+		...baseOptions(self, renderTooltip),
+		series,
+		xAxis: axisOption(unset(d.xAxis), xAxis?.format),
+		yAxis: axisOption(unset(d.yAxis), yAxis?.format)
+	};
+};
+var applyOptions = (self) => {
+	const state = states.get(self);
+	state?.chart?.setOptions(chartOptions(self, state));
+};
+var applyTheme = (self) => {
+	const state = states.get(self);
+	if (!state) return;
+	const theme = chartTheme(configOf(self));
+	if (theme === state.theme) return;
+	state.theme = theme;
+	state.chart?.setTheme(theme);
+};
+var emptyHover = {
+	items: [],
+	x: null,
+	xLabel: ""
+};
+var bindEvents = (self, state, chart) => {
+	chart.on("hover", (event) => self.triggerEvent("hover", event ?? emptyHover));
+	chart.on("zoom", (view) => self.triggerEvent("zoom", view));
+	chart.on("layout", (rect) => self.triggerEvent("layout", rect));
+	if (state.kind !== "quadrant") {
+		chart.on("click", (event) => self.triggerEvent("pointclick", event));
+		chart.on("plotClick", (at) => self.triggerEvent("plotclick", at));
+		chart.on("drag", (event) => self.triggerEvent("pointdrag", event));
+		chart.on("drop", (event) => self.triggerEvent("pointdrop", event));
+		return;
+	}
+	const point = (index) => (self.data.points ?? [])[index];
+	const target = (x, y) => ({
+		x,
+		y,
+		quadrant: quadrantOf(quadrantConfig(self), x, y)
+	});
+	chart.on("click", (event) => {
+		const index = event.items[0]?.index;
+		if (index !== void 0 && point(index)) self.triggerEvent("pointclick", {
+			point: point(index),
+			index
+		});
+	});
+	chart.on("plotClick", (at) => self.triggerEvent("quadrantclick", {
+		quadrant: quadrantOf(quadrantConfig(self), at.x, at.y),
+		x: at.x,
+		y: at.y
+	}));
+	for (const [source, name] of [["drag", "pointdrag"], ["drop", "pointdrop"]]) chart.on(source, (event) => {
+		const index = event.item.index;
+		if (point(index)) self.triggerEvent(name, {
+			point: point(index),
+			index,
+			target: target(event.x, event.y)
+		});
+	});
+};
+/** Measures the canvas node, then creates (or resizes) the chart */
+var measure$1 = (self) => {
+	const state = states.get(self);
+	if (!state) return;
+	self.createSelectorQuery().select(".mn-chart-canvas").fields({
+		node: true,
+		size: true
+	}).exec((result) => {
+		if (states.get(self) !== state) return;
+		const hit = result?.[0];
+		const width = Number(hit?.width), height = Number(hit?.height);
+		if (!hit?.node || !(width > 0) || !(height > 0)) return;
+		const ratio = pixelRatio();
+		if (state.chart) {
+			state.chart.resize(width, height, ratio);
+			return;
+		}
+		if (!state.theme) state.theme = chartTheme(configOf(self));
+		const chart = createCanvasChart({
+			canvas: hit.node,
+			width,
+			height,
+			pixelRatio: ratio,
+			options: chartOptions(self, state),
+			theme: state.theme
+		});
+		state.chart = chart;
+		bindEvents(self, state, chart);
+	});
+};
+var touches = (input) => Array.from(input ?? []).filter((t) => t && Number.isFinite(Number(t.x)) && Number.isFinite(Number(t.y))).map((t, i) => ({
+	x: Number(t.x),
+	y: Number(t.y),
+	identifier: t.identifier ?? i
+}));
+var COMMON_OPTIONS = [
+	"legend",
+	"tooltip",
+	"crosshair",
+	"annotations",
+	"interaction",
+	"padding",
+	"palette",
+	"ariaLabel"
+];
+var SERIES_OPTIONS = [
+	"series",
+	"xAxis",
+	"yAxis"
+];
+var QUADRANT_OPTIONS = [
+	"points",
+	"xDomain",
+	"yDomain",
+	"xSplit",
+	"ySplit",
+	"quadrants",
+	"xLabel",
+	"yLabel",
+	"axisLabels",
+	"showTicks",
+	"reverseX",
+	"showLabels",
+	"pointSize",
+	"name",
+	"draggable"
+];
+function defineChart(kind) {
+	const kindProperties = kind === "quadrant" ? {
+		points: list$2(),
+		xDomain: optional$4(),
+		yDomain: optional$4(),
+		xSplit: optional$4(),
+		ySplit: optional$4(),
+		quadrants: optional$4(),
+		xLabel: text$4(),
+		yLabel: text$4(),
+		axisLabels: optional$4(),
+		showTicks: flag$6(true),
+		reverseX: flag$6(),
+		showLabels: flag$6(true),
+		pointSize: {
+			type: Number,
+			value: 12
+		},
+		name: text$4(),
+		draggable: flag$6()
+	} : {
+		series: list$2(),
+		xAxis: optional$4(),
+		yAxis: optional$4(),
+		...kind === "line" ? { area: flag$6() } : {},
+		...kind === "bar" ? { stacked: flag$6() } : {}
+	};
+	const optionNames = [
+		...COMMON_OPTIONS,
+		...kind === "quadrant" ? QUADRANT_OPTIONS : SERIES_OPTIONS,
+		...kind === "line" ? ["area"] : kind === "bar" ? ["stacked"] : []
+	];
+	return {
+		template: `<view class="mn-chart" style="display:block;position:relative;width:{{chartWidth}};height:{{chartHeight}}"><canvas type="2d" class="mn-chart-canvas" style="display:block;width:100%;height:100%" disable-scroll="{{disableScroll}}" aria-role="img" aria-label="{{ariaLabel}}" bindtouchstart="onTouchStart" bindtouchmove="onTouchMove" bindtouchend="onTouchEnd" bindtouchcancel="onTouchCancel"></canvas></view>`,
+		definition: {
+			properties: {
+				width: {
+					type: null,
+					value: "100%"
+				},
+				height: {
+					type: null,
+					value: 320
+				},
+				legend: optional$4(),
+				tooltip: optional$4(),
+				crosshair: optional$4(),
+				annotations: list$2(),
+				interaction: optional$4(),
+				padding: optional$4(),
+				palette: list$2(),
+				ariaLabel: text$4(),
+				disableScroll: flag$6(),
+				...kindProperties
+			},
+			data: {
+				chartWidth: "100%",
+				chartHeight: "320px"
+			},
+			observers: {
+				[optionNames.join(",")]: function() {
+					applyOptions(this);
+				},
+				"width,height": function() {
+					const width = cssSize(this.data.width, "100%"), height = cssSize(this.data.height, "320px");
+					if (width === this.data.chartWidth && height === this.data.chartHeight) return;
+					this.setData({
+						chartWidth: width,
+						chartHeight: height
+					}, () => {
+						if (states.get(this)?.ready) measure$1(this);
+					});
+				},
+				"inheritedTheme,inheritedMode,inheritedPalette": function() {
+					applyTheme(this);
+				}
+			},
+			lifetimes: {
+				attached() {
+					stateOf(this, kind);
+					this.setData({
+						chartWidth: cssSize(this.data.width, "100%"),
+						chartHeight: cssSize(this.data.height, "320px")
+					});
+				},
+				ready() {
+					stateOf(this, kind).ready = true;
+					measure$1(this);
+				},
+				detached() {
+					states.get(this)?.chart?.destroy();
+					states.delete(this);
+				}
+			},
+			methods: {
+				configure(config) {
+					stateOf(this, kind).config = { ...config };
+					applyOptions(this);
+				},
+				resize() {
+					measure$1(this);
+				},
+				resetZoom() {
+					states.get(this)?.chart?.resetZoom();
+				},
+				getView() {
+					return states.get(this)?.chart?.getView() ?? null;
+				},
+				setView(view) {
+					states.get(this)?.chart?.setView(view);
+				},
+				getPlotRect() {
+					return states.get(this)?.chart?.getPlotRect() ?? null;
+				},
+				toPixel(x, y) {
+					return states.get(this)?.chart?.toPixel(x, y) ?? null;
+				},
+				fromPixel(x, y) {
+					return states.get(this)?.chart?.fromPixel(x, y) ?? null;
+				},
+				onTouchStart(event) {
+					const changed = touches(event.changedTouches);
+					states.get(this)?.chart?.touchStart(changed.length ? changed : touches(event.touches));
+				},
+				onTouchMove(event) {
+					const current = touches(event.touches);
+					states.get(this)?.chart?.touchMove(current.length ? current : touches(event.changedTouches));
+				},
+				onTouchEnd(event) {
+					states.get(this)?.chart?.touchEnd(touches(event.changedTouches));
+				},
+				onTouchCancel(event) {
+					const changed = touches(event.changedTouches);
+					states.get(this)?.chart?.touchCancel(changed.length ? changed : void 0);
+				}
+			}
+		}
+	};
+}
+/** Any mix of line, area, bar and scatter series (each sets its `type`) */
+var chart = defineChart("chart");
+/** Line chart (`area` fills the lines) */
+var lineChart = defineChart("line");
+/** Bar chart, grouped or `stacked` */
+var barChart = defineChart("bar");
+/** Scatter chart, zooming on both axes */
+var scatterChart = defineChart("scatter");
+/** Four-quadrant matrix with labelled, optionally draggable dots */
+var quadrantChart = defineChart("quadrant");
+//#endregion
 //#region src/interactions.ts
 var flag$5 = (value = false) => ({
 	type: Boolean,
@@ -6241,7 +9979,7 @@ function timeSync(self, preserveDraft = false) {
 			disabled: false
 		}]
 	});
-	const displayValue = current ? formatTime(current, format) : "";
+	const displayValue = current ? formatTime$1(current, format) : "";
 	self.setData({
 		effectiveFormat: format,
 		hasSeconds: formatHasSeconds(format),
@@ -10281,7 +14019,12 @@ enhanceConfiguration({
 	button,
 	input,
 	toggle,
-	...nativeControls
+	...nativeControls,
+	chart,
+	lineChart,
+	barChart,
+	scatterChart,
+	quadrantChart
 ]);
 annotateNativeApi({
 	button,
@@ -10357,7 +14100,12 @@ annotateNativeApi({
 	confirmDialog,
 	confirmProvider,
 	toastProvider,
-	gridItem
+	gridItem,
+	chart,
+	lineChart,
+	barChart,
+	scatterChart,
+	quadrantChart
 });
 //#endregion
 exports.alert = alert;
@@ -10366,10 +14114,12 @@ exports.autoComplete = autoComplete;
 exports.avatar = avatar;
 exports.avatarGroup = avatarGroup;
 exports.badge = badge;
+exports.barChart = barChart;
 exports.box = box;
 exports.button = button;
 exports.card = card;
 exports.cascader = cascader;
+exports.chart = chart;
 exports.checkbox = checkbox;
 exports.codeBlock = codeBlock;
 exports.commandDialog = commandDialog;
@@ -10393,6 +14143,7 @@ exports.iconButton = iconButton;
 exports.input = input;
 exports.jsonField = jsonField;
 exports.keyValueEditor = keyValueEditor;
+exports.lineChart = lineChart;
 exports.list = list;
 exports.loadingState = loadingState;
 exports.menu = menu;
@@ -10407,12 +14158,14 @@ exports.paletteToggle = paletteToggle;
 exports.popover = popover;
 exports.progressIndicator = progressIndicator;
 exports.prose = prose;
+exports.quadrantChart = quadrantChart;
 exports.radio = radio;
 exports.radioGroup = radioGroup;
 exports.rating = rating;
 exports.ratingScale = ratingScale;
 exports.requestConfirm = requestConfirm;
 exports.responsiveGrid = responsiveGrid;
+exports.scatterChart = scatterChart;
 exports.select = select;
 exports.skeleton = skeleton;
 exports.skeletonText = skeletonText;