@astrato-io/visualizations 0.0.0-stage → 0.6.5

package/chunks/shared-CBvcC5YV.js

@@ -0,0 +1,1218 @@
+import { Mo as e, No as t, Wc as n, a as r, bs as i, ms as a, ps as o, rs as s, us as c, xs as l } from "./isEqual-BDxAhUo8.js";
+import { Df as u, Gp as ee, Jd as d, Kd as f, Pm as te, Qd as ne, Sm as re, Tm as ie, Ud as p, Vm as ae, Yd as oe, Zd as se, ep as ce, fp as le, jm as m, mp as ue, np as de, op as fe, pf as h, pm as pe, pp as me, rm as he, sm as ge, tp as _e, um as ve, zf as g } from "./handlers-VTBfIZYZ.js";
+import { T as _, d as ye, t as v, y } from "./operations-CTNUX6Sy.js";
+import { z as b } from "zod";
+var x = n(), be = b.object({
+	orientation: b.enum(["horizontal", "vertical"]).optional(),
+	selectionMode: b.enum([
+		"inherit",
+		"auto",
+		"manual"
+	]).optional(),
+	enableAddingNewFilters: b.boolean().optional(),
+	enableAssociativeFilter: b.boolean().optional(),
+	showClearAll: b.boolean().optional(),
+	showChartBreakdown: b.boolean().optional(),
+	selectableFieldKeys: b.array(b.string()).optional()
+}).strict(), xe = b.object({
+	settings: be.optional(),
+	type: b.literal("astrato-app-filter-bar"),
+	version: b.literal(1)
+}).strict(), S = (e) => e, C = b.string().trim().min(1).max(100), w = b.string().min(1).refine((e) => e.trim().length > 0, "Field key cannot be blank."), Se = S(ie.shape.dataType), Ce = S(re.shape.formatType), we = b.object({
+	distinct: b.boolean().optional(),
+	name: b.string().trim().min(1),
+	resultType: b.string().optional()
+}).strict(), Te = b.object({
+	aggregations: b.array(we).default([]),
+	dataType: Se,
+	fieldKey: w,
+	isManualData: b.boolean().optional(),
+	kind: b.literal("field").default("field"),
+	name: b.string().min(1),
+	view: b.string().min(1)
+}).strict(), T = b.object({
+	description: b.string().optional(),
+	id: b.string().min(1).optional(),
+	key: w,
+	name: b.string().min(1),
+	views: b.array(b.string()).optional()
+}).passthrough(), Ee = T.extend({
+	dimension: b.record(b.string(), b.unknown()),
+	type: b.literal("dimension")
+}), De = T.extend({
+	measure: b.object({ aggregation: b.string().min(1) }).passthrough(),
+	type: b.literal("measure")
+}), Oe = T.extend({
+	calculation: b.record(b.string(), b.unknown()),
+	type: b.literal("calculation")
+}), ke = b.object({
+	fieldKey: w,
+	item: Ee,
+	kind: b.literal("dimension"),
+	name: b.string().min(1)
+}).strict(), Ae = b.object({
+	fieldKey: w,
+	item: De,
+	kind: b.literal("measure"),
+	name: b.string().min(1)
+}).strict(), je = b.object({
+	fieldKey: w,
+	item: Oe,
+	kind: b.literal("calculation"),
+	name: b.string().min(1)
+}).strict(), E = b.union([
+	Te,
+	ke,
+	Ae,
+	je
+]).superRefine((e, t) => {
+	e.kind !== "field" && e.item.key !== e.fieldKey && t.addIssue({
+		code: "custom",
+		message: "Semantic item key must match fieldKey.",
+		path: ["item", "key"]
+	});
+}), Me = b.object({
+	currency: b.string().min(1).optional(),
+	currencyIsPrefix: b.boolean().optional(),
+	formatString: b.string().optional(),
+	formatType: Ce.optional(),
+	negativeType: S(re.shape.negativeType.unwrap()).optional()
+}).strict(), Ne = b.discriminatedUnion("mode", [b.object({
+	dateLevel: S(b.enum(x.DateLevel)).describe("Year-aware bucket, such as month over time."),
+	mode: b.literal("level")
+}).strict(), b.object({
+	datePart: S(b.enum(x.DatePart)).describe("Date part, such as month of year."),
+	mode: b.literal("part")
+}).strict()]), D = b.object({
+	fieldKey: w,
+	format: Me.pick({
+		formatString: !0,
+		formatType: !0
+	}).optional(),
+	ref: C,
+	showNullValues: b.boolean().optional(),
+	temporalGrouping: Ne.describe("Groups a date dimension. Applied before format; format must then suit the grouping.").optional()
+}).strict(), Pe = b.object({
+	placements: b.array(S(b.enum(te))).min(1).optional(),
+	visible: b.boolean()
+}).strict(), O = b.object({
+	aggregation: b.string().trim().min(1).describe("Required for a raw field measure; omit for a predefined measure or calculation.").optional(),
+	dataLabels: Pe.optional(),
+	fieldKey: w,
+	format: Me.optional(),
+	ref: C
+}).strict(), Fe = b.object({
+	fieldKey: w,
+	operator: S(b.enum(fe)),
+	value: b.string()
+}).strict(), Ie = b.object({
+	fieldKey: w,
+	operator: S(b.enum(de)),
+	valueFrom: b.string(),
+	valueTo: b.string()
+}).strict(), Le = b.object({
+	fieldKey: w,
+	operator: S(b.enum(ce)),
+	values: b.array(b.string()).min(1)
+}).strict(), Re = b.object({
+	fieldKey: w,
+	operator: S(b.enum(_e))
+}).strict(), ze = b.union([
+	Fe,
+	Ie,
+	Le,
+	Re
+]), k = b.lazy(() => b.object({
+	filters: b.array(b.union([ze, k])),
+	operator: b.enum(["and", "or"])
+}).strict()), A = b.object({
+	by: C,
+	direction: S(he.shape.sortDirection),
+	enabled: b.boolean().optional()
+}).strict(), Be = b.object({
+	by: C,
+	count: b.number().int().positive(),
+	direction: S(he.shape.sortDirection),
+	showOthers: b.boolean().optional()
+}).strict(), Ve = b.object({
+	queryLimit: b.number().int().positive().optional(),
+	topN: Be.optional()
+}).strict(), j = b.object({
+	position: S(pe.shape.position).optional(),
+	title: b.string().optional(),
+	visible: b.boolean().optional()
+}).strict(), M = b.object({
+	labelsVisible: b.boolean().optional(),
+	lineVisible: b.boolean().optional(),
+	ticksVisible: b.boolean().optional(),
+	title: b.string().optional(),
+	titleVisible: b.boolean().optional()
+}).strict(), He = b.union([b.object({
+	max: b.number().optional(),
+	min: b.number().optional().describe("Must be less than max when both are set")
+}).strict(), b.object({ startsAtZero: b.boolean() }).strict()]).describe("Fix min, max or both, or set startsAtZero on an axis fitted to the data"), Ue = b.array(ee).optional().describe("Shaded ranges drawn across the plot between two primary measure axis values"), We = le({}), Ge = le({ dimension: C.describe(`Alias of a dimension in data.dimensions. ${ue}`) }), Ke = me({ measure: C.describe("Alias of the measure in data.measures whose value is compared") }), qe = "Colors bound to dimension values, eg. \"Happy\" is dark teal. The first matching entry wins, ahead of rules and the palette. For ordered bands, add one entry per band with colors taken along a ramp.", Je = b.array(Ke).min(1).describe("Colors bound to measure thresholds, eg. red when sales is below 100. The first matching rule wins."), N = (e) => b.object({
+	overwrites: b.array(e.requiresOverwriteDimension ? Ge : We).min(1).describe(qe).optional(),
+	...e.rules ? { rules: Je.optional() } : {}
+}).strict(), Ye = {
+	inverted: b.boolean().optional().describe("Reverse the direction of the axis values, eg. to put rank 1 at the top"),
+	range: He.optional()
+}, Xe = { bands: Ue }, Ze = { scale: S(b.enum(ae)).optional() };
+M.extend({
+	...Ye,
+	...Xe,
+	...Ze
+}).strict();
+var P = ({ logScale: e = !1, primaryMeasureBands: t = !1, rangedMeasureAxes: n = [] } = {}) => {
+	let r = (t, r) => M.extend({
+		...n.includes(t) ? Ye : {},
+		...r ? Xe : {},
+		...e ? Ze : {}
+	}).strict();
+	return b.object({
+		dimension: M.optional(),
+		primaryMeasure: r("primaryMeasure", t).optional(),
+		secondaryMeasure: r("secondaryMeasure", !1).optional()
+	}).strict();
+};
+P();
+var Qe = b.object({
+	axes: P({
+		logScale: !0,
+		primaryMeasureBands: !0,
+		rangedMeasureAxes: ["primaryMeasure", "secondaryMeasure"]
+	}).optional(),
+	legend: j.optional(),
+	orientation: S(b.enum(t)).optional()
+}).strict(), $e = O.extend({ axis: b.enum(["primary", "secondary"]).optional() }), et = b.object({
+	data: b.object({
+		dimensions: b.array(D).min(1),
+		measures: b.array($e).min(1)
+	}).strict(),
+	filterGroup: k.optional(),
+	limiting: Ve.optional(),
+	presentation: Qe.extend({ coloring: N({ rules: !0 }).optional() }).optional(),
+	sorting: b.array(A).optional(),
+	type: b.literal("bar"),
+	version: b.literal(1)
+}).strict(), tt = b.object({ visible: b.boolean() }).strict(), nt = (e, t) => b.array(e).min(t.min).max(t.max), F = (e, n) => {
+	let r = {};
+	if (n.dimensions.max > 0) {
+		let e = nt(D, n.dimensions);
+		r.dimensions = n.dimensions.min === 0 ? e.optional() : e;
+	}
+	if (n.measures.max > 0) {
+		let e = n.dataLabels ? O.omit({ dataLabels: !0 }).extend({ dataLabels: tt.optional() }) : O.omit({ dataLabels: !0 }), t = n.comboSeriesTypes ? e.extend({ seriesType: b.enum([
+			"bar",
+			"line",
+			"point"
+		]).optional() }) : e, i = nt(n.measureAxis ? t.extend({ axis: b.enum(["primary", "secondary"]).optional() }) : t, n.measures);
+		r.measures = n.measures.min === 0 ? i.optional() : i;
+	}
+	let i = {};
+	if (n.axes) {
+		let e = P({
+			logScale: n.measureAxisScale,
+			primaryMeasureBands: n.measureAxisBands,
+			rangedMeasureAxes: n.rangedMeasureAxes
+		});
+		i.axes = (n.secondaryDimensionAxis ? e.extend({ secondaryDimension: M.optional() }) : e).optional();
+	}
+	n.conditionalColoring && (i.coloring = N(n.conditionalColoring).optional()), n.dataLabels && (i.dataLabels = tt.optional()), n.gaugeDisplayMode && (i.displayMode = b.enum(["bar", "radial"]).optional()), n.legend && (i.legend = j.optional()), n.orientation && (i.orientation = S(b.enum(t)).optional()), n.treeLayout && (i.layout = b.object({
+		compact: b.boolean().optional(),
+		direction: b.enum([
+			"bottom",
+			"left",
+			"right",
+			"top"
+		]).optional(),
+		forceAutoFit: b.boolean().optional(),
+		initialExpandedLevels: b.number().int().min(0).optional()
+	}).strict().optional());
+	let a = {
+		data: b.object(r).strict(),
+		filterGroup: k.optional(),
+		type: b.literal(e),
+		version: b.literal(1)
+	};
+	return n.queryLimit && (a.limiting = b.object({ queryLimit: b.number().int().positive().optional() }).strict().optional()), Object.keys(i).length > 0 && (a.presentation = b.object(i).strict().optional()), n.sorting && (a.sorting = b.array(A).optional()), b.object(a).strict().superRefine((t, r) => {
+		let i = t.data, a = n.validateCounts?.(i.dimensions?.length ?? 0, i.measures?.length ?? 0);
+		a && r.addIssue({
+			code: "custom",
+			message: a,
+			path: ["data"]
+		});
+		let o = n.conditionalColoring?.minDimensions ?? 0;
+		t.presentation?.coloring && (i.dimensions?.length ?? 0) < o && r.addIssue({
+			code: "custom",
+			message: `${e} value colors require at least ${o} dimensions.`,
+			path: ["presentation", "coloring"]
+		}), n.validateDefinition?.(t, r);
+	});
+}, rt = F("combo", {
+	axes: !0,
+	comboSeriesTypes: !0,
+	dataLabels: !0,
+	dimensions: {
+		min: 1,
+		max: 1
+	},
+	legend: !0,
+	measureAxis: !0,
+	measureAxisBands: !0,
+	measureAxisScale: !0,
+	measures: {
+		min: 1,
+		max: 10
+	},
+	orientation: !0,
+	queryLimit: !0,
+	sorting: !0,
+	rangedMeasureAxes: ["primaryMeasure", "secondaryMeasure"],
+	validateDefinition: (e, t) => {
+		let n = e.data.measures ?? [];
+		n.forEach((e, n) => {
+			e.dataLabels?.visible && e.seriesType !== "bar" && t.addIssue({
+				code: "custom",
+				message: "Combo data labels are supported only for bar series.",
+				path: [
+					"data",
+					"measures",
+					n,
+					"dataLabels"
+				]
+			});
+		}), e.presentation?.dataLabels?.visible && !n.some((e) => e.seriesType === "bar") && t.addIssue({
+			code: "custom",
+			message: "Visible combo data labels require at least one bar series.",
+			path: ["presentation", "dataLabels"]
+		}), new Set(n.filter((e) => e.seriesType === "bar" && e.axis).map((e) => e.axis)).size > 1 && n.forEach((e, n) => {
+			e.seriesType === "bar" && e.axis && t.addIssue({
+				code: "custom",
+				message: "Combo bar series share one measure axis, so every bar measure must name the same axis.",
+				path: [
+					"data",
+					"measures",
+					n,
+					"axis"
+				]
+			});
+		});
+	}
+}), it = F("dot", {
+	conditionalColoring: { rules: !0 },
+	axes: !0,
+	dimensions: {
+		min: 2,
+		max: 2
+	},
+	legend: !0,
+	measures: {
+		min: 1,
+		max: 1
+	},
+	orientation: !0,
+	rangedMeasureAxes: ["primaryMeasure"]
+}), at = F("scatter", {
+	conditionalColoring: { rules: !0 },
+	axes: !0,
+	dimensions: {
+		min: 1,
+		max: 2
+	},
+	legend: !0,
+	measures: {
+		min: 2,
+		max: 3
+	},
+	queryLimit: !0,
+	rangedMeasureAxes: ["primaryMeasure", "secondaryMeasure"],
+	sorting: !0
+}), ot = F("histogram", {
+	axes: !0,
+	dimensions: {
+		min: 1,
+		max: 1
+	},
+	legend: !0,
+	measureAxisBands: !0,
+	measures: {
+		min: 0,
+		max: 0
+	},
+	orientation: !0,
+	rangedMeasureAxes: ["primaryMeasure"]
+}), st = F("heatMap", {
+	conditionalColoring: { rules: !0 },
+	axes: !0,
+	dimensions: {
+		min: 2,
+		max: 2
+	},
+	legend: !0,
+	measures: {
+		min: 1,
+		max: 2
+	},
+	queryLimit: !0,
+	secondaryDimensionAxis: !0,
+	sorting: !0
+}), ct = F("radar", {
+	conditionalColoring: {
+		minDimensions: 2,
+		rules: !1
+	},
+	dimensions: {
+		min: 0,
+		max: 2
+	},
+	legend: !0,
+	measures: {
+		min: 1,
+		max: 5
+	},
+	validateCounts: (e, t) => {
+		if (e === 0 && t < 2) return "Radar charts without dimensions require at least two measures.";
+		if (e > 0 && t > 1) return "Radar charts with dimensions support exactly one measure.";
+	}
+}), lt = F("gauge", {
+	conditionalColoring: { rules: !0 },
+	dimensions: {
+		min: 0,
+		max: 1
+	},
+	gaugeDisplayMode: !0,
+	legend: !0,
+	measures: {
+		min: 1,
+		max: 20
+	},
+	validateCounts: (e, t) => e === 1 && t > 2 ? "Gauge charts with a dimension support at most two measures." : void 0
+}), ut = F("distribution-gauge", {
+	conditionalColoring: { rules: !0 },
+	dimensions: {
+		min: 0,
+		max: 1
+	},
+	gaugeDisplayMode: !0,
+	legend: !0,
+	measures: {
+		min: 1,
+		max: 20
+	}
+}), dt = F("pie", {
+	conditionalColoring: { rules: !0 },
+	dimensions: {
+		min: 1,
+		max: 1
+	},
+	legend: !0,
+	measures: {
+		min: 1,
+		max: 2
+	},
+	queryLimit: !0,
+	sorting: !0
+}), ft = F("tree", {
+	dimensions: {
+		min: 0,
+		max: 10
+	},
+	measures: {
+		min: 0,
+		max: 100
+	},
+	queryLimit: !0,
+	sorting: !0,
+	treeLayout: !0,
+	validateCounts: (e, t) => e + t === 0 ? "Tree charts require at least one dimension or measure." : e > 0 && t > 1 ? "Tree charts with dimensions support at most one measure." : void 0
+}), pt = F("treemap", {
+	conditionalColoring: { rules: !0 },
+	dimensions: {
+		min: 1,
+		max: 10
+	},
+	legend: !0,
+	measures: {
+		min: 1,
+		max: 1
+	}
+}), mt = F("sankey", {
+	conditionalColoring: {
+		requiresOverwriteDimension: !0,
+		rules: !0
+	},
+	dimensions: {
+		min: 2,
+		max: 15
+	},
+	measures: {
+		min: 1,
+		max: 1
+	}
+}), ht = F("waterfall", {
+	axes: !0,
+	dataLabels: !0,
+	dimensions: {
+		min: 0,
+		max: 0
+	},
+	measureAxisBands: !0,
+	measures: {
+		min: 1,
+		max: 100
+	},
+	orientation: !0,
+	rangedMeasureAxes: ["primaryMeasure"]
+}), gt = F("word-cloud", {
+	conditionalColoring: { rules: !0 },
+	dimensions: {
+		min: 1,
+		max: 1
+	},
+	measures: {
+		min: 1,
+		max: 1
+	}
+}), _t = b.enum(["dropdown", "listbox"]), vt = b.object({
+	mode: _t.optional(),
+	quickSelect: b.boolean().optional(),
+	responsive: b.boolean().optional(),
+	searchable: b.boolean().optional(),
+	showProgressBar: b.boolean().optional()
+}).strict(), yt = b.object({
+	data: b.object({ field: D.omit({
+		format: !0,
+		showNullValues: !0,
+		temporalGrouping: !0
+	}) }).strict(),
+	presentation: vt.optional(),
+	type: b.literal("filter"),
+	version: b.literal(1)
+}).strict(), bt = O.omit({ dataLabels: !0 }).extend({
+	axis: b.enum(["primary", "secondary"]).optional(),
+	dataPointShape: S(ve.shape.dataPointShape)
+}), xt = b.object({
+	density: ge.optional(),
+	visible: b.boolean()
+}).strict(), St = Qe.extend({
+	coloring: N({ rules: !1 }).optional(),
+	dataLabels: xt.optional()
+}), Ct = b.object({
+	data: b.object({
+		dimensions: b.array(D).min(1),
+		measures: b.array(bt).min(1)
+	}).strict(),
+	filterGroup: k.optional(),
+	limiting: b.object({ queryLimit: b.number().int().positive().optional() }).strict().optional(),
+	presentation: St.optional(),
+	sorting: b.array(A).optional(),
+	type: b.literal("line"),
+	version: b.literal(1)
+}).strict().superRefine((e, t) => {
+	e.presentation?.coloring && e.data.dimensions.length < 2 && t.addIssue({
+		code: "custom",
+		message: "Line value colors require at least two dimensions.",
+		path: ["presentation", "coloring"]
+	}), e.presentation?.dataLabels?.visible && e.data.measures.forEach((e, n) => {
+		e.dataPointShape || t.addIssue({
+			code: "custom",
+			message: "Visible line data labels require a data-point shape for every measure.",
+			path: [
+				"data",
+				"measures",
+				n,
+				"dataPointShape"
+			]
+		});
+	});
+}), wt = b.object({
+	data: b.object({ measure: O.omit({ dataLabels: !0 }) }).strict(),
+	filterGroup: k.optional(),
+	type: b.literal("number"),
+	version: b.literal(1)
+}).strict(), Tt = S(u.pick({
+	endDateLabel: !0,
+	pickerState: !0,
+	pickerType: !0,
+	quickSelect: !0,
+	responsive: !0,
+	startDateLabel: !0,
+	timePickerVisibility: !0,
+	weekStart: !0
+}).partial()), Et = b.object({
+	data: b.object({ field: D.omit({
+		format: !0,
+		showNullValues: !0,
+		temporalGrouping: !0
+	}) }).strict(),
+	settings: Tt.optional(),
+	type: b.literal("date-picker"),
+	version: b.literal(1)
+}).strict(), Dt = b.object({
+	settings: b.object({ url: b.string().url().nullable() }).strict(),
+	type: b.literal("iframe"),
+	version: b.literal(1)
+}).strict(), Ot = b.object({
+	settings: S(b.object({
+		blur: h.shape.blur.optional(),
+		fit: h.shape.image.unwrap().shape.imageFit.optional(),
+		opacity: h.shape.opacity.optional(),
+		saturation: h.shape.saturation.optional(),
+		shadow: h.shape.shadow.optional(),
+		source: ye.optional()
+	}).strict()),
+	type: b.literal("image"),
+	version: b.literal(1)
+}).strict(), kt = b.object({
+	settings: S(ne.pick({
+		backgroundColor: !0,
+		backgroundType: !0,
+		borderEnabled: !0,
+		borderRadius: !0,
+		heightBasedSize: !0,
+		imageFit: !0,
+		imageURL: !0,
+		lineThickness: !0,
+		preserveAspectRatio: !0,
+		rotate: !0,
+		scale: !0,
+		shape: !0,
+		strokeColor: !0
+	}).partial().strict()),
+	type: b.literal("shape"),
+	version: b.literal(1)
+}).strict(), I = se.shape.simpleTextObjectSettings, At = b.object({
+	settings: S(b.object({
+		align: I.shape.align.optional(),
+		content: b.string().optional(),
+		fontFamily: I.shape.fontFamily.optional(),
+		fontSize: I.shape.fontSize.optional(),
+		position: I.shape.position.optional(),
+		representation: I.shape.representation.optional(),
+		responsive: I.shape.responsive.optional(),
+		textColor: I.shape.textColor.optional(),
+		wordWrap: I.shape.wordWrap.optional()
+	}).strict()),
+	type: b.literal("simpleTextObject"),
+	version: b.literal(1)
+}).strict(), jt = b.object({
+	settings: S(b.object({
+		customLabel: g.shape.commonSettings.shape.customLabel.optional(),
+		hideLabel: g.shape.commonSettings.shape.hideLabel.optional(),
+		inputType: g.shape.type.optional(),
+		placeholder: g.shape.commonSettings.shape.placeholder.optional(),
+		responsive: g.shape.commonSettings.shape.responsive.optional(),
+		variableId: g.shape.commonSettings.shape.variableId.optional()
+	}).strict()),
+	type: b.literal("atomic-input"),
+	version: b.literal(1)
+}).strict(), Mt = b.object({
+	data: b.object({ field: D.omit({
+		format: !0,
+		showNullValues: !0,
+		temporalGrouping: !0
+	}) }).strict(),
+	settings: S(oe.pick({
+		layout: !0,
+		quickSelect: !0,
+		range: !0,
+		step: !0
+	}).partial()).optional(),
+	type: b.literal("slider"),
+	version: b.literal(1)
+}).strict(), Nt = D.extend({ role: b.literal("dimension") }), L = O.omit({ dataLabels: !0 }), Pt = L.extend({ role: b.literal("measure") }), Ft = b.object({
+	columns: b.array(b.discriminatedUnion("role", [Nt, Pt])).min(1),
+	structure: b.literal("normal").optional()
+}).strict(), It = b.object({
+	dimensions: b.array(D).min(1),
+	measures: b.array(L).min(1),
+	structure: b.literal("expandable")
+}).strict(), Lt = b.object({
+	columnDimensions: b.array(D).min(1),
+	measures: b.array(L).min(1),
+	rowDimensions: b.array(D).min(1),
+	structure: b.literal("pivot")
+}).strict(), Rt = b.union([
+	Ft,
+	It,
+	Lt
+]), zt = b.object({
+	applyTo: p.shape.applyTo,
+	enabled: p.shape.enabled,
+	showRecordsCount: p.shape.showRecordsCount,
+	style: b.object({
+		backgroundColor: d.shape.backgroundColor.optional(),
+		fontColor: d.shape.fontColor.optional(),
+		fontStyle: f.optional(),
+		position: d.shape.position.optional(),
+		responsiveHeight: d.shape.responsive
+	}).strict().optional()
+}).strict(), Bt = b.object({
+	background: b.object({
+		color: m.optional(),
+		evenColor: m.optional(),
+		oddColor: m.optional(),
+		type: b.enum([
+			"none",
+			"single",
+			"zebra"
+		])
+	}).strict().optional(),
+	body: b.object({
+		fontColor: m.optional(),
+		fontFamily: b.string().trim().min(1).optional(),
+		fontSize: b.number().positive().optional(),
+		fontStyle: f.optional(),
+		horizontalAlign: b.enum([
+			"auto",
+			"center",
+			"left",
+			"right"
+		]).optional(),
+		verticalAlign: b.enum([
+			"auto",
+			"bottom",
+			"middle",
+			"top"
+		]).optional()
+	}).strict().optional(),
+	borders: b.object({
+		color: m.optional(),
+		dividerColor: m.optional(),
+		dividers: b.enum([
+			"all",
+			"auto",
+			"horizontal",
+			"none",
+			"vertical"
+		]).optional(),
+		enabled: b.boolean(),
+		lineStyle: b.enum([
+			"dashed",
+			"dotted",
+			"line"
+		]).optional(),
+		radius: b.number().nonnegative().optional(),
+		strokeWidth: b.number().nonnegative().optional()
+	}).strict().optional(),
+	header: b.object({
+		backgroundColor: m.optional(),
+		borderColor: m.optional(),
+		fontColor: m.optional(),
+		fontFamily: b.string().trim().min(1).optional(),
+		fontSize: b.number().positive().optional(),
+		fontStyle: f.optional(),
+		responsiveHeight: b.boolean().optional()
+	}).strict().optional(),
+	highlight: b.object({
+		backgroundColor: m.optional(),
+		mode: b.enum([
+			"column",
+			"none",
+			"row",
+			"row-and-column"
+		]),
+		textColor: m.optional()
+	}).strict().optional(),
+	layout: b.object({
+		columnWidthBehavior: b.enum(["responsive", "static"]).optional(),
+		rowHeight: b.number().positive().optional()
+	}).strict().optional()
+}).strict(), Vt = b.object({
+	data: Rt,
+	filterGroup: k.optional(),
+	limiting: b.object({ queryLimit: b.number().int().positive().optional() }).strict().optional(),
+	presentation: Bt.optional(),
+	sorting: b.array(A).optional(),
+	totals: zt.optional(),
+	type: b.literal("table"),
+	version: b.literal(1)
+}).strict(), R = (e) => typeof e == "object" && !!e && !Array.isArray(e), Ht = (e) => {
+	let t = e.fieldKey ?? e.key;
+	return typeof t == "string" ? t : void 0;
+}, Ut = (e) => {
+	if (Array.isArray(e)) return e;
+	if (!R(e)) throw Error("Available field metadata must be an array or an object.");
+	return [
+		"fields",
+		"dimensions",
+		"measures"
+	].flatMap((t) => {
+		let n = e[t];
+		if (n === void 0) return [];
+		if (!Array.isArray(n)) throw Error(`Available field metadata "${t}" must be an array.`);
+		return n;
+	});
+}, Wt = (e, t) => {
+	let n = e.type;
+	if (!(n === "dimension" && R(e.dimension) || n === "measure" && R(e.measure) || n === "calculation" && R(e.calculation))) return;
+	let r = E.safeParse({
+		fieldKey: e.key,
+		item: e,
+		kind: n,
+		name: e.name
+	});
+	if (!r.success) throw Error(`Invalid available semantic item at index ${t}: ${r.error.message}`);
+	return r.data;
+}, Gt = (e, t) => {
+	if (!R(e)) throw Error(`Available field at index ${t} must be an object.`);
+	let n = E.safeParse(e);
+	if (n.success) return n.data;
+	let r = Wt(e, t);
+	if (r) return r;
+	let i = Array.isArray(e.aggregations) ? e.aggregations : Array.isArray(e.aggregators) ? e.aggregators : [], a = E.safeParse({
+		aggregations: i.map((e) => R(e) ? {
+			distinct: e.distinct,
+			name: e.name ?? e.funcName,
+			resultType: e.resultType
+		} : e),
+		dataType: e.dataType,
+		fieldKey: Ht(e),
+		isManualData: e.isManualData,
+		kind: "field",
+		name: e.name,
+		view: e.view
+	});
+	if (!a.success) throw Error(`Invalid available field at index ${t}: ${a.error.message}`);
+	return a.data;
+}, Kt = (e) => {
+	let t = Ut(e).map(Gt), n = /* @__PURE__ */ new Map();
+	return t.forEach((e, t) => {
+		let r = n.get(e.fieldKey);
+		if (r !== void 0) throw Error(`Duplicate available field key "${e.fieldKey}" at indexes ${r} and ${t}.`);
+		n.set(e.fieldKey, t);
+	}), t;
+}, qt = (e) => e.kind === "field" ? [...new Set(e.aggregations.flatMap((e) => [e.name, ...e.distinct ? [`${e.name}_DISTINCT`] : []]))] : [], Jt = (e, t) => e.kind === "field" || t === "dimension" && e.kind === "dimension" || t === "measure" && (e.kind === "measure" || e.kind === "calculation"), Yt = (e) => {
+	if (e.kind !== "dimension") return e.kind;
+}, z = (e) => ({
+	...c(e.item),
+	id: e.item.id ?? e.fieldKey
+}), B = (e) => e.map((e) => e.kind === "dimension" ? a(z(e)) : e.kind === "measure" || e.kind === "calculation" ? o(z(e)) : {
+	aggregators: i(e.aggregations.map((e) => ({
+		distinct: e.distinct ?? !1,
+		name: e.name,
+		resultType: e.resultType
+	}))),
+	dataType: e.dataType,
+	isManualData: e.isManualData,
+	key: e.fieldKey,
+	name: e.name,
+	view: e.view,
+	views: [e.view]
+}), V = (e, t) => {
+	let n = Math.min(e.length, t.length), r = 0;
+	for (; r < n && e[r].toLocaleLowerCase() === t[r].toLocaleLowerCase();) r += 1;
+	return r;
+}, Xt = (e, t) => [...t].sort((t, n) => V(e, n.fieldKey) - V(e, t.fieldKey) || t.fieldKey.localeCompare(n.fieldKey)).slice(0, 5).map((e) => e.fieldKey), Zt = [
+	x.FieldType.DATE,
+	x.FieldType.TIME,
+	x.FieldType.TIMESTAMP,
+	x.FieldType.TIMESTAMP_TZ
+], H = (e, t, n, r) => ({
+	...r ? { allowedValues: r } : {},
+	code: e,
+	message: n,
+	path: t
+}), U = (e) => qt(e).filter((e) => !!l(e)), Qt = (e, t) => {
+	let n = t.find((t) => t.fieldKey === e.fieldKey);
+	return n?.kind === "field" ? U(n).find((t) => t.toLocaleUpperCase() === e.aggregation?.toLocaleUpperCase()) : void 0;
+}, $t = (e, t) => {
+	let n = t.find((t) => t.fieldKey === e.fieldKey);
+	return n?.kind === "measure" ? n.item.measure.aggregation : Qt(e, t);
+}, en = (e, t, n = {}) => {
+	let r = t.find((t) => t.fieldKey === e.fieldKey), i = r ? Yt(r) : void 0, a = Qt(e, t);
+	return {
+		...n,
+		key: e.fieldKey,
+		...i ? { sourceKind: i } : {},
+		...a ? { aggregation: a } : {}
+	};
+}, W = (e, t, n, r) => {
+	let i = t.find((t) => t.fieldKey === e.fieldKey);
+	if (!i) return [H("unknown_field_key", [...n, "fieldKey"], `Field key "${e.fieldKey}" is not available.`, Xt(e.fieldKey, t))];
+	if (!Jt(i, r)) return [H("invalid_field_role", [...n, "fieldKey"], `Available item "${e.fieldKey}" of kind "${i.kind}" cannot be used as a ${r}.`)];
+	if (r !== "measure") return e.temporalGrouping ? nn(e, t, n, Zt, "a temporally grouped dimension") : [];
+	if (i.kind !== "field") return e.aggregation === void 0 ? [] : [H("invalid_aggregation", [...n, "aggregation"], `Aggregation must be omitted for semantic ${i.kind} "${e.fieldKey}".`)];
+	let a = U(i);
+	return e.aggregation ? a.some((t) => t.toLocaleUpperCase() === e.aggregation?.toLocaleUpperCase()) ? [] : [H("invalid_aggregation", [...n, "aggregation"], `Aggregation "${e.aggregation}" is not available for field key "${e.fieldKey}".`, a)] : [H("invalid_aggregation", [...n, "aggregation"], `Aggregation is required for raw field "${e.fieldKey}" when it is used as a measure.`, a)];
+}, tn = (e, t, n, r) => e.flatMap((e, i) => W(e, t, [...n, i], r)), nn = (e, t, n, r, i) => {
+	let a = t.find((t) => t.fieldKey === e.fieldKey);
+	return a?.kind !== "field" || r.includes(a.dataType) ? [] : [H("invalid_field_role", [...n, "fieldKey"], `Raw field "${e.fieldKey}" has data type "${a.dataType}" and cannot be used as ${i}.`, [...r])];
+}, rn = (e, t, n = ["filterGroup"]) => e ? e.filters.flatMap((e, r) => {
+	let i = [
+		...n,
+		"filters",
+		r
+	];
+	return "filters" in e ? rn(e, t, i) : W({
+		fieldKey: e.fieldKey,
+		ref: `filter:${r}`
+	}, t, i, "dimension");
+}) : [], G = (e) => e.reduce((e, t) => typeof t == "number" ? `${e}[${t}]` : /^[A-Za-z_$][\w$]*$/.test(t) ? e ? `${e}.${t}` : t : `${e}[${JSON.stringify(t)}]`, "") || "definition", K = (e) => {
+	if (typeof e == "number" && !Number.isFinite(e)) return String(e);
+	try {
+		return JSON.stringify(e) ?? String(e);
+	} catch {
+		return String(e);
+	}
+}, an = (e, t) => t.reduce((e, t) => typeof e == "object" && e && Object.prototype.hasOwnProperty.call(e, t) ? e[t] : void 0, e), on = (e) => {
+	if (e.code === "invalid_value") return e.values;
+	if (e.code !== "invalid_union" || e.errors.length === 0) return;
+	let t = e.errors.map((e) => e.length === 1 && e[0].path.length === 0 ? on(e[0]) : void 0);
+	return t.every((e) => e !== void 0) ? [...new Set(t.flat())] : void 0;
+}, sn = (e, t, n = []) => {
+	let r = (e, i) => {
+		let a = [...i, ...e.path.filter((e) => typeof e != "symbol")];
+		if (e.code === "unrecognized_keys") return e.keys.map((r) => {
+			let i = [
+				...n,
+				...a,
+				r
+			];
+			return {
+				code: "invalid_structure",
+				path: i,
+				message: `${G(i)}: Unrecognized key.`,
+				details: {
+					received: an(t, [...a, r]),
+					zodCode: e.code
+				}
+			};
+		});
+		let o = [...n, ...a], s = an(t, a), c = on(e), l = {
+			received: s,
+			zodCode: e.code
+		}, u = c ? `Unsupported value ${K(s)}. Allowed values: ${c.map(K).join(", ")}.` : `${e.message}. Received: ${K(s)}.`;
+		if (e.code === "invalid_union" && !c && e.errors.length > 0) {
+			let t = e.errors.filter((e) => !e.some((e) => e.code === "unrecognized_keys"));
+			if (t.length === 1) return t[0].flatMap((e) => r(e, a));
+			let n = e.errors.map((e) => e.flatMap((e) => r(e, a)));
+			l.alternatives = n, u = `Value does not match any allowed shape. ${n.map((e, t) => `Alternative ${t + 1}: ${e.map((e) => e.message).join(" ")}`).join(" ")}`;
+		}
+		return [{
+			code: "invalid_structure",
+			path: o,
+			message: `${G(o)}: ${u}`,
+			details: l,
+			...c ? { allowedValues: c } : {}
+		}];
+	};
+	return e.issues.flatMap((e) => r(e, []));
+};
+r();
+var cn = (t, n) => {
+	let r = "legend" in t && !!t.legend, i = n.position !== void 0 || n.title !== void 0, a = [];
+	return n.visible !== void 0 && (n.visible || i || r) ? a.push({
+		name: "setLegendEnabled",
+		payload: n.visible
+	}) : n.visible === void 0 && i && !r && a.push({
+		name: "setLegendEnabled",
+		payload: !0
+	}), n.position === void 0 ? (n.visible === !0 || i && !r) && a.push({
+		name: "setLegendPosition",
+		payload: e.Right
+	}) : a.push({
+		name: "setLegendPosition",
+		payload: n.position
+	}), n.title !== void 0 && a.push({
+		name: "setLegendTitle",
+		payload: n.title
+	}), a;
+}, q = (e, t, n, r = {}) => ({
+	code: e,
+	message: n,
+	path: t,
+	...r
+}), ln = (e, t, n, r, i, a) => ({
+	name: e,
+	payload: {
+		...J(t),
+		[i]: a
+	},
+	definitionContext: {
+		path: [
+			...r,
+			"format",
+			i
+		],
+		received: a,
+		ref: n,
+		kind: t.kind
+	}
+}), un = (e, t, n, r, i, a, o) => ({
+	name: e,
+	payload: {
+		name: t,
+		[i]: a
+	},
+	definitionContext: {
+		path: [
+			...r,
+			"format",
+			i
+		],
+		received: a,
+		ref: n,
+		kind: o
+	}
+}), J = (e) => ({
+	dataItemInternalKey: e.dataItemInternalKey,
+	dataItemUniqueSignature: e.dataItemUniqueSignature
+}), dn = (e) => {
+	let t = [], n = /* @__PURE__ */ new Set();
+	return e.forEach(({ items: e, path: r }) => {
+		e.forEach((e, i) => {
+			n.has(e.ref) && t.push(q("duplicate_alias", [
+				...r,
+				i,
+				"ref"
+			], `Reference "${e.ref}" is duplicated.`)), n.add(e.ref);
+		});
+	}), t;
+}, fn = (e, t) => {
+	let n = e, r = n.referencedData;
+	return t.every((e) => !Array.isArray(n[e]) || n[e].length === 0) && (typeof r != "object" || !r || Object.keys(r).length === 0);
+}, pn = (e, t) => ({
+	availableFields: B(e.availableFields),
+	input: e,
+	resolvedRefs: {},
+	vSpec: t
+}), mn = (e, t, n, r, i) => ({
+	name: e,
+	payload: {
+		...J(t),
+		...i
+	},
+	definitionContext: {
+		path: [...r, "temporalGrouping"],
+		received: i,
+		ref: n,
+		kind: t.kind
+	}
+}), hn = (e) => "value" in e ? { value: e.value } : "values" in e ? {
+	secondValue: e.values.join(","),
+	value: ","
+} : "valueFrom" in e ? {
+	valueFrom: e.valueFrom,
+	valueTo: e.valueTo
+} : {}, Y = (e) => ({
+	filters: e.filters.map((e) => "filters" in e ? Y(e) : {
+		fieldKey: e.fieldKey,
+		operator: e.operator,
+		values: hn(e)
+	}),
+	operator: e.operator
+}), gn = (e, t) => (e ?? []).flatMap((e, n) => t.includes(e.by) ? [] : [q("unknown_alias", [
+	"sorting",
+	n,
+	"by"
+], `Reference "${e.by}" does not exist.`, { allowedValues: t })]), X = ["presentation", "coloring"], _n = (e, t, n) => [...(e?.overwrites ?? []).flatMap(({ dimension: e }, n) => e === void 0 || t.includes(e) ? [] : [q("unknown_alias", [
+	...X,
+	"overwrites",
+	n,
+	"dimension"
+], `Dimension reference "${e}" does not exist.`, { allowedValues: t })]), ...(e?.rules ?? []).flatMap(({ measure: e }, t) => n.includes(e) ? [] : [q("unknown_alias", [
+	...X,
+	"rules",
+	t,
+	"measure"
+], `Measure reference "${e}" does not exist.`, { allowedValues: n })])], vn = (e, t) => {
+	let n = t.safeParse(e.vSpec);
+	return n.success ? {
+		resolvedRefs: e.resolvedRefs,
+		success: !0,
+		vSpec: n.data
+	} : {
+		issues: [q("invalid_compiled_vspec", [], "Compiled vSpec failed final validation.", { details: { issues: n.error.issues } })],
+		success: !1
+	};
+}, Z = (e) => "startsAtZero" in e ? {} : e, yn = (e) => {
+	let { max: t, min: n } = Z(e);
+	return n !== void 0 && t !== void 0 ? s.MinMax : n === void 0 ? t === void 0 ? s.Auto : s.Max : s.Min;
+}, bn = (e) => {
+	for (let [t, n] of Object.entries(e ?? {})) {
+		let { max: e, min: r } = n?.range ? Z(n.range) : {};
+		if (r !== void 0 && e !== void 0 && r >= e) return q("invalid_structure", [
+			"presentation",
+			"axes",
+			t,
+			"range",
+			"min"
+		], `Axis range min (${r}) must be less than max (${e}).`);
+	}
+}, xn = (e, t) => {
+	let n = [];
+	t.inverted !== void 0 && n.push({
+		name: y.SET_INVERT_AXIS,
+		payload: {
+			axisName: e,
+			invertAxis: t.inverted
+		}
+	});
+	let { range: r } = t;
+	if (r) {
+		n.push({
+			name: y.SET_AXIS_RANGE_OPTION,
+			payload: {
+				axisName: e,
+				axisRangeOption: yn(r)
+			}
+		});
+		let { max: t, min: i } = Z(r);
+		i !== void 0 && n.push({
+			name: y.SET_AXIS_RANGE_MIN,
+			payload: {
+				axisName: e,
+				minValue: i
+			}
+		}), t !== void 0 && n.push({
+			name: y.SET_AXIS_RANGE_MAX,
+			payload: {
+				axisName: e,
+				maxValue: t
+			}
+		}), "startsAtZero" in r && n.push({
+			name: y.SET_AXIS_STARTS_AT_ZERO,
+			payload: {
+				axisName: e,
+				startsAtZero: r.startsAtZero
+			}
+		});
+	}
+	return n;
+}, Q = (e) => {
+	let t = Object.entries(e).find(([, e]) => e.success === !1);
+	return t ? {
+		id: t[0],
+		result: t[1]
+	} : void 0;
+}, $ = async (e, t, n) => {
+	let r = t.map((e, t) => ({
+		...e,
+		id: e.id ?? `definition:${t}`
+	})), i = await v(e.vSpec, e.availableFields, r.map(({ id: e, name: t, payload: n }) => ({
+		id: e,
+		name: t,
+		payload: n
+	})), e.input.variables ?? [], [], e.input.theme), a = Q(i.results);
+	if (!a) return {
+		state: {
+			...e,
+			vSpec: i.vSpec
+		},
+		success: !0
+	};
+	let o = r.find((e) => e.id === a.id), s = o?.definitionContext, c = s?.path ?? n, l = o?.name ?? a.id, u = a.result.error ?? "Operation failed.", ee = s ? `Cannot apply ${K(s.received)} to ${s.kind} ${K(s.ref)}` : "Operation failed";
+	return {
+		issue: q("operation_failed", c, `${G(c)}: ${ee} (operation "${l}"): ${u}`, { details: {
+			error: a.result.error,
+			operationId: a.id,
+			operationName: l,
+			...s ? {
+				received: s.received,
+				ref: s.ref,
+				role: s.kind
+			} : {}
+		} }),
+		success: !1
+	};
+}, Sn = (e, t) => {
+	if (!e || typeof e.data != "object" || e.data === null || !("dataItem" in e.data)) return;
+	let n = e.data.dataItem;
+	if (!(typeof n != "object" || !n || !("internalKey" in n) || typeof n.internalKey != "string" || !("uniqueSignature" in n) || typeof n.uniqueSignature != "string")) return {
+		dataItemInternalKey: n.internalKey,
+		dataItemUniqueSignature: n.uniqueSignature,
+		kind: t
+	};
+}, Cn = async (e, t, n, r, i, a) => {
+	let o = `${n}:${t.ref}`, s = await v(e.vSpec, e.availableFields, [{
+		id: o,
+		name: r,
+		payload: i
+	}], e.input.variables ?? [], [], e.input.theme), c = Q(s.results), l = Sn(s.results[o], n);
+	return c || !l ? {
+		issue: q("operation_failed", a, c?.result.error ?? `${n} operation did not return the created data-item identity.`),
+		success: !1
+	} : {
+		state: {
+			...e,
+			resolvedRefs: {
+				...e.resolvedRefs,
+				[t.ref]: l
+			},
+			vSpec: s.vSpec
+		},
+		success: !0
+	};
+}, wn = (e, t, n, r) => {
+	let i = [
+		"formatType",
+		"formatString",
+		"currency",
+		"currencyIsPrefix",
+		"negativeType"
+	];
+	return $(e, t.flatMap((t, a) => {
+		let o = e.resolvedRefs[t.ref];
+		return i.flatMap((e) => {
+			let i = t.format?.[e], s = n[e];
+			return i !== void 0 && s ? [ln(s, o, t.ref, t.path ?? [...r, a], e, i)] : [];
+		});
+	}), r);
+}, Tn = (e, t, n, r) => $(e, t.flatMap((t, i) => t.temporalGrouping ? [mn(n, e.resolvedRefs[t.ref], t.ref, t.path ?? [...r, i], t.temporalGrouping)] : []), r), En = (e, t, n, r) => $(e, t.flatMap((t) => t.showNullValues === void 0 ? [] : [{
+	name: n,
+	payload: {
+		...J(e.resolvedRefs[t.ref]),
+		changes: { showNullValues: t.showNullValues }
+	}
+}]), r), Dn = (e, t) => t ? $(e, [{
+	id: "filterGroup",
+	name: "setStaticFilterGroup",
+	payload: Y(t)
+}], ["filterGroup"]) : Promise.resolve({
+	state: e,
+	success: !0
+}), On = (e, t, n, r) => {
+	if (!t?.length) return Promise.resolve({
+		state: e,
+		success: !0
+	});
+	let i = e.vSpec.querySettings?.sortingOrder ?? [], a = new Map(t.map((e) => [e.by, e])), o = new Map(Object.entries(e.resolvedRefs).map(([e, t]) => [`${t.dataItemInternalKey}:${t.dataItemUniqueSignature}`, e])), s = t.map((t) => e.resolvedRefs[t.by]), c = new Set(s.map((e) => `${e.dataItemInternalKey}:${e.dataItemUniqueSignature}`));
+	return $(e, [{
+		name: n,
+		payload: { changeRequests: [...s, ...i.filter((e) => !c.has(`${e.dataItem.internalKey}:${e.dataItem.uniqueSignature}`)).map((e) => ({
+			dataItemInternalKey: e.dataItem.internalKey,
+			dataItemUniqueSignature: e.dataItem.uniqueSignature,
+			kind: "dimension"
+		}))].map((e, t) => {
+			let n = `${e.dataItemInternalKey}:${e.dataItemUniqueSignature}`, r = o.get(n), s = i.find((e) => `${e.dataItem.internalKey}:${e.dataItem.uniqueSignature}` === n);
+			return {
+				...J(e),
+				newIndex: t,
+				sortDirection: (r ? a.get(r)?.direction : void 0) ?? s?.sortDirection ?? "asc"
+			};
+		}) }
+	}, ...t.map((t) => ({
+		name: r,
+		payload: {
+			...J(e.resolvedRefs[t.by]),
+			enabled: t.enabled ?? !0
+		}
+	}))], ["sorting"]);
+}, kn = (e, t) => {
+	let n = [];
+	return t?.overwrites && n.push({
+		name: _.SET_COLORING_OVERWRITES,
+		payload: { overwrites: t.overwrites.map(({ dimension: t, ...n }) => t === void 0 ? n : {
+			...n,
+			dimension: J(e.resolvedRefs[t])
+		}) }
+	}), t?.rules && n.push({
+		name: _.SET_COLORING_RULES,
+		payload: { rules: t.rules.map(({ measure: t, ...n }) => ({
+			...n,
+			measure: J(e.resolvedRefs[t])
+		})) }
+	}), $(e, n, X);
+};
+export { at as $, nn as A, At as B, dn as C, W as D, $t as E, Et as F, ut as G, Ct as H, Dt as I, st as J, it as K, Ot as L, B as M, Vt as N, tn as O, jt as P, mt as Q, kt as R, _n as S, en as T, yt as U, wt as V, rt as W, dt as X, ot as Y, ct as Z, bn as _, wn as a, E as at, Y as b, xn as c, q as d, ft as et, cn as f, vn as g, $ as h, Dn as i, et as it, Kt as j, rn as k, ln as l, mn as m, kn as n, ht as nt, On as o, xe as ot, un as p, lt as q, En as r, gt as rt, Tn as s, Cn as t, pt as tt, pn as u, fn as v, sn as w, gn as x, J as y, Mt as z };