@astrato-io/visualizations 0.0.0-stage → 0.6.4

package/chunks/event-bus-KiSiCJrC.js

@@ -0,0 +1,2683 @@
+import { o as e } from "./rolldown-runtime-DleVn1XH.js";
+import { $s as t, Cs as n, D as r, Da as i, Dc as a, Do as o, Ds as s, Eo as c, Es as l, Fn as u, Gc as d, Ia as f, Io as p, J as m, Jo as h, Ki as g, La as _, Lo as v, Ma as y, Mn as b, Mo as x, Mr as S, Ns as C, Oo as ee, Rn as w, Ro as te, Ti as T, To as ne, Ts as E, Wc as D, Wn as O, X as k, Xo as re, Xs as ie, Y as ae, Ya as oe, Yo as se, Ys as ce, _o as le, as as ue, bo as de, cs as fe, ct as pe, d as me, ds as he, ec as ge, ei as A, es as _e, ft as ve, go as ye, ho as be, is as xe, js as Se, la as j, mo as Ce, mt as we, nc as Te, ni as M, oc as N, os as Ee, ot as De, pc as P, ps as Oe, qa as ke, qo as Ae, qs as je, si as Me, st as Ne, tc as Pe, u as Fe, ui as Ie, us as Le, xs as Re, yn as ze, yo as Be, zi as Ve, zn as He } from "./interfaces-VUY4_yVO.js";
+import { a as Ue, i as We, t as Ge } from "./color-settings-ZIvgNTq1.js";
+import { z as F } from "zod";
+import { Subject as Ke } from "rxjs";
+var qe = /* @__PURE__ */ function(e) {
+	return e.Linear = "linear", e.Log = "log", e;
+}({}), Je = /* @__PURE__ */ function(e) {
+	return e.None = "none", e.Diverging = "diverging", e.Silhouette = "silhouette", e.Expand = "expand", e.Wiggle = "wiggle", e;
+}({}), Ye = /* @__PURE__ */ function(e) {
+	return e.Measure = "measure", e.Dimension = "dimension", e.DimensionAndMeasure = "dimensionAndMeasure", e;
+}({}), Xe = /* @__PURE__ */ function(e) {
+	return e.Value = "value", e.Percentage = "percentage", e.ValueAndPercentage = "valueAndPercentage", e;
+}({}), Ze = /* @__PURE__ */ function(e) {
+	return e.Default = "default", e.First = "first", e.Last = "last", e;
+}({}), Qe = /* @__PURE__ */ function(e) {
+	return e.Dimension = "dimension", e.Measure = "measure", e;
+}({}), $e = /* @__PURE__ */ function(e) {
+	return e.Inside = "inside", e.Outside = "outside", e.Opposite = "opposite", e;
+}({}), I = d(), et = F.object({
+	label: F.string(),
+	funcName: F.string(),
+	requiredExtraParams: F.boolean(),
+	disabled: F.boolean().optional(),
+	resultType: F.union([F.enum(I.FieldType), F.literal("incoming")]).optional()
+}), tt = F.object({
+	enableMeasureLimit: F.boolean(),
+	measureLimitType: F.enum(Le),
+	minMeasureLimit: F.number().optional(),
+	maxMeasureLimit: F.number().optional()
+}), nt = F.object({
+	type: F.literal(fe.VARIABLE),
+	variableName: F.string()
+}), L = F.union([F.string(), nt]), R = F.union([F.number(), nt]), rt = F.union([F.boolean(), nt]), it = F.union([
+	L,
+	R,
+	rt
+]), z = (e = (e) => e) => F.union([e(F.number()), nt]), at = (e = (e) => e) => F.union([e(F.string()), nt]), B = F.string().regex(/^#([0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/), ot = F.object({ value: it }), st = F.object({
+	type: F.literal(Ge.SUPPORTING_MEASURE),
+	dataItemId: F.string()
+}), ct = F.union([L, st]), lt = F.union([R, st]), ut = F.object({
+	id: F.string().describe("Palette identifier"),
+	name: F.string().optional().describe("Palette name"),
+	colors: F.array(F.string()).describe("Palette colors")
+}), dt = F.object({
+	type: F.enum(Ue),
+	color: B.nullable().describe("Color code (hex, with optional alpha)"),
+	dataItemId: F.string(),
+	operator: F.enum(We).describe("Operator (equals, less etc.)"),
+	delimiter: L.optional().describe("Delimiter for list operators"),
+	value: ct.or(lt),
+	secondValue: ct.or(lt),
+	highlightedColumnIds: F.array(F.string()).optional().nullable().describe("Column ids to highlight when rule condition is met"),
+	backgroundColor: B.nullable().describe("Background color code (hex, with optional alpha)").optional(),
+	customGradient: ut.optional().describe("Custom gradient"),
+	usedGradientId: F.string().optional().describe("Used gradient identifier"),
+	applyToTotalRow: F.boolean().optional().describe("Apply rule to the table total row"),
+	skipColoringZeroValues: F.boolean().optional().describe("Skip coloring zero values")
+}), ft = F.object({
+	color: B.nullable().describe("Color code (hex, with optional alpha)"),
+	value: ct.or(lt),
+	delimiter: L.optional().nullable().describe("Delimiter for list operators"),
+	secondValue: ct.or(lt).optional().nullable(),
+	highlightedColumnIds: F.array(F.string()).optional().nullable().describe("Column ids to highlight when rule condition is met"),
+	backgroundColor: B.nullable().describe("Background color code (hex, with optional alpha)"),
+	dataItemId: F.string().optional().describe("Data item identifier"),
+	operator: F.enum([
+		"equals",
+		"contains",
+		"startsWith",
+		"endsWith",
+		"greater",
+		"less",
+		"greater-equals",
+		"less-equals",
+		"between",
+		"not-equals",
+		"inList",
+		"notInList"
+	]).nullable().optional()
+}), pt = F.object({
+	type: F.enum(ie),
+	palette: F.string().optional().nullable().describe("Palette identifier"),
+	customPalette: ut.optional().describe("Custom palette"),
+	customGradient: ut.optional().describe("Custom gradient"),
+	gradientMin: F.number().optional().describe("Minimum value for gradient"),
+	gradientMax: F.number().optional().describe("Maximum value for gradient"),
+	color: B.optional().nullable().describe("Color code (hex, with optional alpha)"),
+	fieldId: F.string().optional().nullable().describe("Field identifier for coloring"),
+	measureAggregation: F.string().optional().nullable().describe("Measure aggregation for coloring"),
+	rules: F.array(dt).optional(),
+	overwrites: F.array(ft).optional(),
+	persistentColors: F.boolean().optional().describe("Enable persistent colors"),
+	categoricalColorTransparency: F.number().optional().describe("Categorical color transparency"),
+	parameters: F.record(F.string(), ot).optional().nullable(),
+	sortOrder: F.enum(["alpha-asc", "data"]).optional().describe("Coloring sort order")
+}), mt = F.enum([
+	"primaryMeasure",
+	"secondaryMeasure",
+	"dimension"
+]), ht = F.enum(["primaryMeasure", "secondaryMeasure"]), gt = F.enum([
+	"primaryMeasure",
+	"secondaryMeasure",
+	"dimension",
+	"secondaryDimension"
+]), _t = F.object({
+	start: R.optional(),
+	end: R.optional(),
+	color: B,
+	label: F.string().optional()
+}), vt = F.object({
+	disabled: F.boolean().optional(),
+	showAxisName: F.boolean().optional(),
+	showLabels: F.boolean().optional(),
+	showLine: F.boolean().optional(),
+	showTicks: F.boolean().optional(),
+	showAxisTooltip: F.boolean().optional(),
+	continuousAxis: F.boolean().optional(),
+	invertAxis: F.boolean().optional(),
+	labelOverlap: F.enum(re).optional(),
+	labels: F.object({
+		tiltAngle: F.number().min(-90).max(90).optional(),
+		tiltThreshold: F.number().min(0).max(1).optional()
+	}).optional(),
+	labelFontSize: z((e) => e.min(0).max(50)).nullable().optional(),
+	labelWrap: F.boolean().optional(),
+	labelWrapLines: F.number().min(1).max(10).optional(),
+	titleFontSize: z((e) => e.min(0).max(50)).nullable().optional(),
+	axisRange: F.object({
+		axisRangeOption: F.enum(xe).optional(),
+		startsAtZero: F.boolean().optional(),
+		minValue: R.optional(),
+		maxValue: R.optional()
+	}).optional(),
+	scale: F.enum(qe).optional(),
+	axisTitle: F.string().optional(),
+	colors: F.object({
+		title: B.optional().nullable(),
+		tick: B.optional().nullable(),
+		label: B.optional().nullable(),
+		line: B.optional().nullable()
+	}).optional(),
+	axisBands: F.array(_t).optional(),
+	maxGlyphCount: F.number().min(0).max(50).optional(),
+	axisLabelDisplay: F.enum(ue).optional()
+}), yt = vt.extend({ secondaryAxis: F.boolean().optional() }), bt = F.object({
+	dimension: yt.optional(),
+	primaryMeasure: vt.optional(),
+	secondaryMeasure: vt.optional(),
+	secondaryDimension: yt.optional()
+}), xt = F.object({
+	showTotal: F.boolean().optional(),
+	stacked: F.boolean().optional(),
+	grouped: F.boolean().optional(),
+	offset: F.object({
+		enabled: F.boolean().optional(),
+		showTotal: F.boolean().optional(),
+		totalLabel: F.string().optional(),
+		showLine: F.boolean().optional(),
+		lineColor: B.nullable().optional()
+	}).optional(),
+	barPadding: F.number().min(0).max(1).step(.01).optional(),
+	groupPadding: F.number().min(0).max(1).optional(),
+	translucentBars: F.boolean().optional(),
+	barRadius: z((e) => e.min(0).max(20)).optional(),
+	strokeEnabled: F.boolean().optional(),
+	strokeWidth: F.number().min(1).max(20).optional(),
+	strokeColor: B.optional(),
+	stackedOffset: F.enum(Je).nullable().optional(),
+	roundAllEdges: F.boolean().optional(),
+	useCustomBoxRounding: F.boolean().optional(),
+	ignoreOutOfBounds: F.boolean().optional()
+}), V = F.string().nonempty(), St = F.object({
+	schema: F.string().optional(),
+	view: F.string(),
+	name: F.string()
+}), H = F.object({
+	value: F.string(),
+	name: F.string(),
+	dataType: F.enum([
+		"string",
+		"int",
+		"float",
+		"boolean",
+		"date",
+		"millisec",
+		"millisec_tz",
+		"timestamp",
+		"timestamp_tz"
+	])
+}), Ct = F.object({
+	formula: F.record(F.string(), F.union([
+		F.string(),
+		F.number(),
+		F.boolean()
+	])),
+	filter: F.record(F.string(), F.union([
+		F.string(),
+		F.number(),
+		F.boolean()
+	]))
+}), wt = F.object({
+	internalKey: F.string(),
+	uniqueSignature: F.string(),
+	type: F.enum(D),
+	name: F.string(),
+	aggregation: et.optional()
+}), Tt = wt.extend({
+	schema: F.string().optional(),
+	view: F.string(),
+	dataType: F.enum(I.FieldType),
+	isManualData: F.boolean().optional()
+}), Et = wt.extend({
+	id: F.string(),
+	dimension: F.object({
+		itemName: F.string().optional(),
+		label: F.string().optional(),
+		resultType: F.enum(I.ResultType).optional(),
+		group: F.object({ fieldKeys: F.array(F.string()) }).optional()
+	}).passthrough().optional(),
+	measure: F.object({
+		aggregation: F.string(),
+		fieldKeys: F.array(F.string()).optional(),
+		fields: F.array(St.extend({ fieldKey: F.string() })).optional(),
+		itemName: F.string().optional(),
+		label: F.string().optional(),
+		resultType: F.enum(I.ResultType).optional(),
+		params: F.array(H).optional()
+	}).passthrough().optional(),
+	calculation: F.object({
+		calculation: F.string().optional(),
+		itemName: F.string().optional(),
+		label: F.string().optional(),
+		resultType: F.enum(I.ResultType).optional(),
+		namedParameters: Ct.optional(),
+		params: F.array(H).optional(),
+		filterParams: F.array(H).optional()
+	}).passthrough().optional(),
+	itemName: F.string().optional()
+}), Dt = F.union([Tt, Et]), Ot = F.object({
+	key: F.string(),
+	name: F.string(),
+	disabled: F.boolean().optional(),
+	aggregators: F.array(et),
+	itemName: F.string().optional(),
+	predefinedLabel: F.string().optional(),
+	inheritFormatting: F.boolean().optional()
+}), kt = Ot.extend({
+	schema: F.string().optional(),
+	view: F.string(),
+	dataType: F.enum(I.FieldType),
+	isManualData: F.boolean().optional(),
+	type: F.enum(Qe).optional()
+}), At = Ot.extend({
+	id: F.string(),
+	type: F.enum(I.DatabaseItemType),
+	dimension: F.object({
+		itemName: F.string().optional(),
+		label: F.string().optional(),
+		resultType: F.enum(I.ResultType).optional(),
+		group: F.object({ fieldKeys: F.array(F.string()) }).optional()
+	}).passthrough().optional(),
+	measure: F.object({
+		aggregation: F.string(),
+		fieldKeys: F.array(F.string()).optional(),
+		fields: F.array(St.extend({ fieldKey: F.string() })).optional(),
+		itemName: F.string().optional(),
+		label: F.string().optional(),
+		resultType: F.enum(I.ResultType).optional(),
+		params: F.array(H).optional()
+	}).passthrough().optional(),
+	calculation: F.object({
+		calculation: F.string().optional(),
+		itemName: F.string().optional(),
+		label: F.string().optional(),
+		resultType: F.enum(I.ResultType).optional(),
+		namedParameters: Ct.optional(),
+		params: F.array(H).optional(),
+		filterParams: F.array(H).optional()
+	}).passthrough().optional(),
+	format: F.string().optional(),
+	description: F.string().optional()
+}), jt = F.union([kt, At]), Mt = F.object({ handling: F.enum(_e) }), Nt = F.object({
+	formatString: L.optional(),
+	formatType: F.enum(v).or(F.enum(p)),
+	isDateTime: F.boolean().optional(),
+	thousandSeparator: F.string().optional(),
+	decimalSeparator: F.string().optional(),
+	currency: F.string().optional(),
+	negativeType: F.enum(te).optional(),
+	currencyIsPrefix: F.boolean().optional(),
+	numAbbreviations: F.record(F.string(), F.string()).optional(),
+	timezone: F.string().optional()
+}), Pt = F.object({
+	type: F.enum([
+		"d3-time",
+		"d3-number",
+		"excel-format",
+		"string",
+		"referenced-field"
+	]),
+	format: Nt,
+	dataItemId: F.string().optional()
+}), Ft = {
+	pointPxSizeMinLowerLimit: 1,
+	pointPxSizeMinUpperLimit: 100,
+	pointPxSizeMaxLowerLimit: 1,
+	pointPxSizeMaxUpperLimit: 1e3,
+	pointSizeMin: 0,
+	pointSizeMax: 1
+}, It = 1e3, Lt = F.object({
+	width: F.number(),
+	space: F.number()
+}), Rt = F.object({
+	regressionType: F.enum(ye),
+	strokeWidth: F.number().optional(),
+	strokeDash: Lt.optional().nullable(),
+	color: F.string().optional().nullable(),
+	labelType: F.enum(be).optional(),
+	label: F.string().optional(),
+	showEquation: F.boolean().optional(),
+	polynomialOrder: F.number().optional(),
+	precision: F.number().optional(),
+	pointsPerPeriod: F.number().optional(),
+	growthPerPeriod: F.number().optional()
+}), zt = Rt.extend({ type: F.literal("trend") }), Bt = Rt.extend({
+	type: F.literal("forecast"),
+	previousDataPoints: F.number().min(j.minDataPoints).max(j.maxDataPoints).optional(),
+	forecastedDataPoints: F.number().min(j.minDataPoints).max(j.maxDataPoints).optional(),
+	pointsPerPeriod: F.number().min(j.minPointsPerPeriod).max(j.maxPointsPerPeriod).optional(),
+	growthPerPeriod: F.number().min(j.minGrowthPerPeriod).max(j.maxGrowthPerPeriod).optional(),
+	dataPointShape: F.enum(o).optional(),
+	dataPointSize: F.number().optional(),
+	showDataPoints: F.boolean().optional(),
+	showForecastStart: F.boolean().optional(),
+	inheritColor: F.enum(Ce).optional(),
+	refLineLabel: F.string().optional()
+}), U = F.object({
+	dataItem: Dt,
+	label: F.string().optional(),
+	description: F.string().optional(),
+	customLabel: F.object({
+		enabled: F.boolean(),
+		value: L.optional()
+	}).optional(),
+	formatter: Pt.optional(),
+	showNullValues: F.boolean().optional(),
+	topDimension: F.boolean().optional(),
+	imageFit: F.enum(y).optional(),
+	trendLine: zt.optional().nullable(),
+	dateLevel: F.enum(I.DateLevel).optional().nullable(),
+	datePart: F.enum(I.DatePart).optional().nullable(),
+	isImported: F.boolean().optional(),
+	coloring: F.object({
+		type: F.enum(ie),
+		palette: F.string().nullable().optional(),
+		customPalette: ut.optional(),
+		color: F.string().nullable().optional(),
+		persistentColors: F.boolean().optional()
+	}).optional(),
+	enabled: F.boolean().optional(),
+	group: F.string().optional(),
+	role: F.enum(oe).optional()
+}), Vt = F.object({
+	weight: F.number().optional().nullable().describe("Font weight"),
+	bold: F.boolean().optional().describe("Bold font. Should take precedence over weight"),
+	italic: F.boolean().optional(),
+	underlined: F.boolean().optional(),
+	strikethrough: F.boolean().optional()
+}).extend({
+	fontFamily: F.string().optional().nullable(),
+	fontSize: F.number().optional(),
+	fontColor: B.optional().nullable().describe("Font color (hex, with optional alpha)")
+}), Ht = F.object({
+	width: F.number().min(1).max(10),
+	space: F.number().min(1).max(10)
+}), Ut = F.object({
+	enabled: F.boolean().optional(),
+	dataItem: Dt,
+	stroke: B.optional().nullable(),
+	strokeWidth: F.number().optional(),
+	strokeDash: Ht.optional()
+}), Wt = F.object({
+	wordBreak: F.enum([
+		"none",
+		"break-word",
+		"break-all"
+	]).optional().describe("Word break rule"),
+	maxLines: F.number().optional().describe("Maximum number of lines allowed if label is broken into multiple lines"),
+	maxWidth: F.number().optional().describe("Maximum width of label, in px"),
+	fontSize: F.string().regex(/^\d+px$/).optional().describe("Legend item label font size (eg. \"12px\")"),
+	fontFamily: F.string().optional().describe("Legend item label font family"),
+	fill: B.optional().nullable().describe("Legend item label font color (hexadecimal color code)"),
+	maxGlyphCount: F.number().optional().nullable().describe("Maximum number of glyphs in the legend item label"),
+	limitCharacters: F.boolean().optional().describe("Limit characters by maxGlyphCount")
+}), Gt = F.object({
+	showTitle: F.boolean().optional().describe("Show legend title"),
+	titleText: F.string().nullable().optional().describe("Legend title text"),
+	alignText: F.enum([
+		"start",
+		"middle",
+		"end"
+	]).optional().describe("Horizontal alignment of the text"),
+	wordBreak: F.enum([
+		"none",
+		"break-word",
+		"break-all"
+	]).optional().describe("Word break rule"),
+	maxLines: F.number().optional().describe("Maximum number of lines allowed if label is broken into multiple lines"),
+	maxWidth: F.number().optional().describe("Maximum width of title, in px"),
+	fontSize: F.number().optional().describe("Legend title font size in pixels (eg. 12)"),
+	fontFamily: F.string().optional().describe("Legend title font family")
+}), Kt = F.object({
+	position: F.enum(x).describe("Legend position"),
+	direction: F.enum(["ltr", "rtl"]).optional().describe("Legend direction (left to right or right to left)"),
+	size: F.number().optional().describe("Maximum number of columns (vertical) or rows (horizontal)"),
+	showItems: F.boolean().optional().describe("Show legend items"),
+	enabled: F.boolean().describe("Enable legend"),
+	itemLabel: Wt.optional().describe("Legend item label settings"),
+	title: Gt.optional().describe("Legend title settings"),
+	layoutMode: F.enum([
+		"grid",
+		"flex",
+		"masonry"
+	]).optional().describe("Layout mode for legend items"),
+	align: F.nativeEnum(Ee).optional().describe("Alignment of legend items (applicable only when dock is top or bottom)")
+}), qt = F.object({
+	chartType: F.enum(se).optional(),
+	lineCurve: F.enum(h).optional()
+}), Jt = F.object({
+	value: L.optional(),
+	valueFrom: L.optional(),
+	valueTo: L.optional(),
+	secondValue: L.optional()
+}), Yt = F.object({
+	id: F.string(),
+	dataFieldId: F.string(),
+	operator: F.enum(ke).or(F.enum(I.DynamicDateCalcRangeType)),
+	values: Jt,
+	dateFilter: F.enum(I.DynamicDateCalcRangeType).or(F.null()).optional().describe("Predefined date filter"),
+	isApplied: F.boolean().optional().describe("Is filter applied")
+}), Xt = F.enum(["and", "or"]), Zt = F.lazy(() => F.object({
+	id: F.string(),
+	operator: Xt,
+	filters: F.array(F.union([Yt, Zt]))
+})), Qt = F.object({
+	ignoreGlobalFilters: F.boolean().optional().describe("Ignore global filters"),
+	disableInteraction: F.boolean().optional().describe("Disable interaction (selections etc.) on the chart"),
+	ignoredFilters: F.array(F.object({
+		fieldId: F.string(),
+		name: F.string()
+	})).optional().describe("Ignored filters"),
+	ignoreFiltersType: F.enum(le).optional().describe("Ignore filters type"),
+	filters: F.array(Yt).optional().describe("Filters"),
+	filterGroup: Zt.optional().describe("Nested filters"),
+	showGlobalFiltersEffect: F.boolean().optional().describe("Show effects of global filters on the chart")
+}), $t = F.object({
+	icon: F.string().optional(),
+	iconColor: B.optional().nullable(),
+	numberColor: B.optional().nullable(),
+	comparisonColor: B.optional().nullable(),
+	backgroundColor: B.optional().nullable()
+}), en = F.object({
+	target: R,
+	targetTolerance: F.number().min(0).max(1),
+	aboveTargetColorAndIcon: $t,
+	targetColorAndIcon: $t,
+	belowTargetColorAndIcon: $t
+}), tn = F.object({
+	value: it,
+	dataType: F.enum([
+		"string",
+		"int",
+		"float",
+		"boolean",
+		"date",
+		"millisec",
+		"millisec_tz",
+		"timestamp",
+		"timestamp_tz"
+	]).optional()
+}), nn = F.enum([
+	"low",
+	"medium",
+	"high"
+]), rn = F.object({
+	itemKey: F.string(),
+	itemName: F.string().optional()
+}), an = F.object({
+	value: it,
+	dataType: F.enum([
+		"string",
+		"int",
+		"float",
+		"boolean",
+		"date"
+	]),
+	sourceType: F.enum([ne.STATIC, ne.VARIABLE])
+}), on = F.object({
+	selectedUdf: rn,
+	parameters: F.record(F.string(), an).optional(),
+	arrayParameterDimensionDataFieldIds: F.record(F.string(), F.array(F.string())).optional()
+}), sn = F.object({
+	type: F.enum([
+		"none",
+		"movingCalculation",
+		"runningTotal",
+		"runningRate",
+		"accumulatedGrowth",
+		"rank",
+		"total",
+		"shareTotal",
+		"nestedCalculation",
+		"nestedRatio",
+		"nestedCorrelation",
+		"value",
+		"diff",
+		"ratio",
+		"growth",
+		"apg",
+		"cagr",
+		"periodOverCorrelation",
+		"udf",
+		"customUdf"
+	]),
+	aggregation: F.enum([
+		"SUM",
+		"AVG",
+		"MIN",
+		"MAX",
+		"PERCENTILE",
+		"OUTLIERS",
+		"CONTROL_VALUE"
+	]).optional(),
+	additionalAggregation: F.enum([
+		"SUM",
+		"AVG",
+		"MIN",
+		"MAX"
+	]).optional(),
+	dense: F.boolean().optional(),
+	rankSortDirection: F.enum(["asc", "desc"]).optional(),
+	groupType: F.enum([
+		"value",
+		"diff",
+		"ratio",
+		"growth"
+	]).optional(),
+	dimensionDataFieldIds: F.array(F.string()).optional(),
+	additionalDimensionDataFieldIds: F.array(F.string()).optional(),
+	nestedOutputType: F.enum([
+		"default",
+		"dimensionValue",
+		"seriesValue"
+	]).optional(),
+	nestedOutputPosition: F.enum(["first", "last"]).optional(),
+	nestedOutputTransform: F.enum(["percentRank", "standardScore"]).optional(),
+	dimensionsIds: F.array(F.string()).optional(),
+	offset: R.optional(),
+	startFromZero: F.boolean().optional(),
+	periodsPerYear: R.optional(),
+	windowBegin: R.optional(),
+	windowEnd: R.optional(),
+	nullIfNotEnoughValues: F.boolean().optional(),
+	compareMeasureDataFieldId: F.string().optional().nullable(),
+	sortingOrder: F.array(F.object({
+		id: F.string(),
+		sortDirection: F.enum(c)
+	})).optional(),
+	percentileValue: R.optional(),
+	percentileContinuous: F.boolean().optional(),
+	percentileApprox: F.boolean().optional(),
+	standardDeviations: R.optional(),
+	parameters: F.record(F.string(), tn).optional().nullable(),
+	comparisonType: F.enum([
+		"absolute",
+		"percentage",
+		"naturalLog"
+	]).optional(),
+	rangesComparison: F.object({
+		enabled: F.boolean(),
+		type: F.enum(["absolute", "percentage"]),
+		firstRangeStart: R,
+		firstRangeEnd: R,
+		secondRangeStart: R,
+		secondRangeEnd: R
+	}).optional(),
+	udf: on.optional(),
+	customUdfFunctionName: F.string().optional(),
+	customUdfFunctionParam: R.optional(),
+	nonTimePeriod: F.boolean().optional(),
+	nonTimePeriodGranularity: F.enum([
+		"day",
+		"week",
+		"month",
+		"quarter",
+		"year"
+	]).optional()
+}), cn = F.enum(["measures", "supportingMeasures"]), ln = F.enum(["advancedCalculation", "nestedCalculation"]), un = F.object({
+	key: F.string(),
+	enabled: F.boolean().optional(),
+	_enabled: F.boolean().optional(),
+	source: F.enum(["variable", "field"]).optional(),
+	propertyValue: it.optional().nullable(),
+	indicator: F.enum([
+		"none",
+		"inverse",
+		"custom"
+	]).optional().nullable(),
+	indicatorThreshold: F.object({
+		thresholdType: F.enum(["target"]),
+		targetThreshold: en.nullable().optional()
+	}).nullable().optional()
+}).strict(), dn = F.object({
+	id: F.string(),
+	dataFieldId: F.string(),
+	operator: F.enum(ke).or(F.enum(I.DynamicDateCalcRangeType)),
+	values: Jt,
+	dateFilter: F.enum(I.DynamicDateCalcRangeType).optional().nullable(),
+	isApplied: F.boolean().optional(),
+	isPostFilter: F.boolean().optional(),
+	protected: F.boolean().optional()
+}), W = F.object({
+	dataItem: Dt,
+	aggregation: et.optional(),
+	filters: F.array(dn).optional(),
+	parameters: F.record(F.string(), tn).optional(),
+	postFilters: F.array(dn).optional(),
+	label: F.string().optional(),
+	description: F.string().optional(),
+	customLabel: F.object({
+		enabled: F.boolean(),
+		value: L.optional()
+	}).optional(),
+	filterValueLabel: F.string().optional(),
+	formatter: Pt.optional(),
+	graphType: F.enum(je).optional(),
+	strokeWidth: F.number().optional(),
+	strokeDash: Lt.optional().nullable(),
+	graphColor: F.string().optional().nullable(),
+	showDataPoints: F.boolean().optional(),
+	hideLineArea: F.boolean().optional(),
+	lineCurve: F.enum(h).optional().nullable(),
+	dataLabels: F.object({
+		show: F.boolean().optional(),
+		rotate: F.boolean().optional(),
+		size: R.optional(),
+		showBackdrop: F.boolean().optional(),
+		isColored: F.boolean().optional(),
+		backdropColor: B.optional().nullable(),
+		textColor: B.optional().nullable(),
+		displayParts: F.array(F.enum(f)).optional(),
+		density: F.enum(de).optional(),
+		labelFormat: F.enum(Ye).optional(),
+		measureLabelFormat: F.enum(Xe).optional(),
+		barLabelPlacements: F.array(F.object({
+			position: F.enum($e).optional(),
+			justify: F.number().min(0).max(1).optional()
+		})).optional()
+	}).optional(),
+	dataPointShape: F.enum(o).optional().nullable().describe("Shape marking the data points"),
+	dataPointSize: F.number().min(Ft.pointSizeMin).max(Ft.pointSizeMax).optional().describe("Adaptive size (in percent)"),
+	dataPointSizeMinPx: F.number().min(Ft.pointPxSizeMinLowerLimit).max(Ft.pointPxSizeMinUpperLimit).optional().describe("Min size of the datapoint (in pixels)"),
+	dataPointSizeMaxPx: F.number().min(Ft.pointPxSizeMaxLowerLimit).max(Ft.pointPxSizeMaxUpperLimit).optional().describe("Max size of the datapoint (in pixels)"),
+	secondaryAxis: F.boolean().optional(),
+	targetValue: F.number().optional(),
+	trendLine: zt.optional().nullable(),
+	showNullValues: F.boolean().optional(),
+	forecasts: F.array(Bt).optional(),
+	replaceNullWith: F.object({
+		enabled: F.boolean().optional(),
+		value: F.number().nullable().optional()
+	}).optional(),
+	isImported: F.boolean().optional(),
+	advancedCalculation: sn.optional(),
+	nestedCalculation: sn.optional(),
+	enabled: F.boolean().optional(),
+	group: F.string().optional(),
+	geoSimplify: F.object({
+		enabled: F.boolean(),
+		tolerance: F.number()
+	}).optional(),
+	includeInTotal: F.boolean().optional(),
+	parentId: F.string().optional().nullable(),
+	role: F.enum(_).optional(),
+	slots: F.array(un).optional().nullable()
+}), fn = F.object({
+	schema: F.string().optional(),
+	view: F.string(),
+	showAll: F.enum(I.ViewStateShowAll).optional(),
+	compatibleTypeFlags: F.object({ associativeListFilter: F.boolean().optional() }).optional()
+}), pn = F.object({
+	dataItem: Dt.nullable(),
+	sortDirection: F.enum(c),
+	enabled: F.boolean().optional(),
+	fieldType: F.enum([
+		"dimension",
+		"measure",
+		"calculated-column",
+		"calculated-conditional-column"
+	]),
+	customSortMeasuresIdx: F.number().optional(),
+	calculatedColumnId: F.string().optional(),
+	calculatedConditionalColumnId: F.string().optional(),
+	isSupportingMeasure: F.boolean().optional()
+}), mn = F.object({
+	stringLabel: F.string().optional(),
+	booleanLabel: F.boolean().optional(),
+	numberLabel: F.number().optional()
+}), hn = F.object({
+	enabled: F.boolean(),
+	timeout: z((e) => e.min(120).max(600)).optional()
+}), gn = F.object({
+	enabled: F.boolean(),
+	ruleCreated: F.boolean().optional(),
+	numberOfValues: R.optional(),
+	showOthers: F.boolean().optional().describe("Group other values into one \"Others\" item"),
+	othersPosition: F.nativeEnum(Ze).optional().describe("Position of \"Others\" item - first (at the beginning), last (at the end) or default (let engine decide)"),
+	othersLabel: mn.optional().describe("Custom label for \"Others\" item"),
+	rankMeasureDataFieldId: F.string().optional(),
+	rankMeasureAggregation: F.string().optional(),
+	sortOrder: F.enum(["asc", "desc"]).optional().describe("Sort order (ascending or descending) to determine whether to show top or bottom N values"),
+	dimensionIdx: F.number().optional().nullable(),
+	parameters: F.record(F.string(), tn).optional().nullable(),
+	sortByRank: F.boolean().optional().describe("Sort chart by rank when Top N is applied")
+}), _n = F.array(pn).optional(), vn = F.object({
+	enabled: F.boolean(),
+	createdAt: F.boolean().optional(),
+	createdBy: F.boolean().optional(),
+	sql: F.boolean().optional(),
+	semanticLayer: F.boolean().optional(),
+	title: F.boolean().optional(),
+	subtitle: F.boolean().optional(),
+	footnote: F.boolean().optional(),
+	custom: F.object({
+		enabled: F.boolean(),
+		name: L.optional().nullable(),
+		value: L.optional().nullable()
+	}).nullable().optional()
+}), G = F.object({
+	limitQuery: F.number().optional().nullable(),
+	pageSize: F.number().optional().nullable(),
+	limitType: F.enum(["top", "bottom"]).optional(),
+	exportLimit: F.number().optional().nullable(),
+	exportTopDimLimit: F.number().optional().nullable(),
+	csvFormatValues: F.boolean().optional(),
+	sortingOrder: _n,
+	viewStates: F.array(fn).optional(),
+	topN: gn.optional(),
+	hideZeroValues: F.boolean().optional(),
+	enableCustomNullValue: F.boolean().optional(),
+	nullAs: L.optional().nullable(),
+	queryTimeout: hn.optional(),
+	withMetadata: vn.or(F.boolean()).optional(),
+	viewStatesParameters: F.record(F.string(), tn.optional().nullable()).optional().nullable()
+}), yn = F.record(F.string(), F.string()), bn = F.object({
+	text: F.string().optional(),
+	padding: F.number().min(0).max(50).optional(),
+	fontSize: F.number().min(0).max(50).optional(),
+	vAlign: F.enum([
+		"top",
+		"middle",
+		"bottom"
+	]).optional(),
+	align: F.enum([
+		"left",
+		"center",
+		"right"
+	]).optional(),
+	showValue: F.boolean().optional(),
+	fill: B.optional()
+}), xn = F.object({
+	value: F.union([L, R]).nullable(),
+	stroke: B.nullable().optional(),
+	strokeWidth: F.number().min(0).max(50).optional(),
+	label: bn.optional(),
+	isSecondaryAxis: F.boolean().optional(),
+	showOob: F.boolean().optional()
+}), Sn = F.object({
+	x: F.array(xn).optional(),
+	y: F.array(xn).optional()
+}), Cn = W.extend({ includeInExport: F.boolean().optional() }), wn = F.object({
+	type: F.enum([
+		"timestamp",
+		"offset",
+		"none"
+	]).describe("Time travel type"),
+	month: F.string().optional().describe("Month"),
+	day: F.string().optional().describe("Day"),
+	time: F.string().optional().describe("Time"),
+	offsetDays: F.string().optional().describe("Offset days"),
+	offsetHours: F.string().optional().describe("Offset hours"),
+	offsetMinutes: F.string().optional().describe("Offset minutes")
+}), Tn = F.object({
+	show: F.boolean().optional(),
+	hideTotal: F.boolean().optional(),
+	showFullNumberValues: F.boolean().optional(),
+	supportingMeasuresDataItemIds: F.array(F.string()).optional()
+}), En = F.object({
+	variableName: F.string().min(1),
+	separator: F.string().max(50).optional(),
+	useVariableValueOnInitialLoad: F.boolean().optional()
+}).strict();
+F.object({
+	allItems: En.optional(),
+	enabledItems: En.optional()
+}).strict().refine((e) => e.allItems || e.enabledItems, { message: "At least one assignment must be provided" });
+var K = F.object({
+	allItems: En.nullable().optional(),
+	enabledItems: En.nullable().optional()
+}).strict(), Dn = F.object({
+	dimensions: K.optional(),
+	measuresSlice: K.optional(),
+	measuresLength: K.optional(),
+	supportingMeasures: K.optional()
+}).strict().nullable(), On = F.object({
+	dimensions: K.optional(),
+	measures: K.optional(),
+	supportingMeasures: K.optional()
+}).strict().nullable(), kn = F.object({
+	dimensions: K.optional(),
+	measures: K.optional(),
+	supportingMeasures: K.optional()
+}).strict().nullable(), An = F.object({
+	dimensions: K.optional(),
+	measures: K.optional(),
+	supportingMeasures: K.optional()
+}).strict().nullable(), jn = F.object({
+	dimensions: K.optional(),
+	measuresValue: K.optional(),
+	measuresTarget: K.optional(),
+	supportingMeasures: K.optional()
+}).strict().nullable(), Mn = F.object({
+	dimensions: K.optional(),
+	measuresValue: K.optional(),
+	supportingMeasures: K.optional()
+}).strict().nullable(), Nn = F.object({
+	dimensionsHorizontal: K.optional(),
+	dimensionsVertical: K.optional(),
+	measuresColor: K.optional(),
+	measuresSize: K.optional(),
+	supportingMeasures: K.optional()
+}).strict().nullable(), Pn = F.object({ dimensions: K.optional() }).strict().nullable(), Fn = F.object({
+	dimensions: K.optional(),
+	measures: K.optional(),
+	supportingMeasures: K.optional()
+}).strict().nullable(), In = F.object({
+	measures: K.optional(),
+	comparison: K.optional()
+}).strict().nullable(), Ln = F.object({
+	dimensions: K.optional(),
+	measures: K.optional()
+}).strict().nullable(), Rn = F.object({
+	dimensions: K.optional(),
+	measures: K.optional()
+}).strict().nullable(), zn = F.object({
+	dimensions: K.optional(),
+	dimensionsImage: K.optional(),
+	measuresHorizontal: K.optional(),
+	measuresVertical: K.optional(),
+	measuresSize: K.optional(),
+	supportingMeasures: K.optional()
+}).strict().nullable(), Bn = F.object({
+	dimensions: K.optional(),
+	measures: K.optional(),
+	supportingMeasures: K.optional()
+}).strict().nullable(), Vn = F.object({
+	measures: K.optional(),
+	supportingMeasures: K.optional()
+}).strict().nullable(), Hn = F.object({
+	dimensions: K.optional(),
+	measures: K.optional(),
+	supportingMeasures: K.optional()
+}).strict().nullable(), Un = F.object({
+	dimensions: K.optional(),
+	measures: K.optional(),
+	supportingMeasures: K.optional()
+}).strict().nullable(), Wn = F.object({
+	dimensions: K.optional(),
+	measures: K.optional()
+}).strict().nullable(), Gn = F.object({
+	enabled: F.boolean(),
+	limitBy: F.enum(["size", "count"]),
+	minCount: F.number().min(5).max(It).optional(),
+	minSize: F.number().min(1).max(128).optional(),
+	fixateLayout: F.boolean().optional(),
+	startFromEnd: F.boolean().optional(),
+	miniChart: F.boolean().optional(),
+	offset: F.number().optional(),
+	limit: F.number().optional()
+}), Kn = F.object({
+	enabled: F.boolean(),
+	density: F.enum(de),
+	isColored: F.boolean().optional(),
+	colorType: F.enum(Be).optional(),
+	textColor: B.optional().nullable(),
+	backdropColor: B.optional().nullable(),
+	fontSize: z((e) => e.min(0)).optional().nullable(),
+	maxLength: z((e) => e.int().min(1)).optional().nullable()
+}), qn = F.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/).describe("vSpec version"), Jn = /* @__PURE__ */ e(r()), Yn = (e) => e.aggregators.filter((e) => !e.disabled && !e.requiredExtraParams).map((e) => e.funcName), Xn = (e) => {
+	let t = Yn(e);
+	return t.length > 0 ? t.join(", ") : "none";
+}, Zn = (e, t) => t ? Yn(e).find((e) => e === t) ?? null : null;
+function q(e, t) {
+	e.next({
+		action: me.UpdateVSpecPartial,
+		payload: { vSpecChange: t }
+	});
+}
+var Qn = (e) => {
+	try {
+		let t = e.flatten();
+		return [...t.formErrors, ...Object.values(t.fieldErrors).flat()].join("\n");
+	} catch {
+		return "Incorrect input";
+	}
+}, J = (e, t, n, r) => {
+	let i = e.safeParse(t);
+	if (!i.success) {
+		let e = Qn(i.error);
+		return n.warn(`[${r}] validation failed`, {
+			payload: t,
+			error: i.error.issues
+		}), {
+			success: !1,
+			errorMessage: e
+		};
+	}
+	return {
+		success: !0,
+		errorMessage: void 0
+	};
+}, $n = (e, t) => ({
+	dataItem: e.dataItem,
+	sortDirection: c.Asc,
+	fieldType: "dimension",
+	...t === void 0 ? {} : { enabled: t }
+}), er = (e, t = !1, n = [], r) => {
+	let i = {
+		dataItem: e.dataItem,
+		sortDirection: c.Desc,
+		fieldType: "measure",
+		...r === void 0 ? {} : { enabled: r }
+	};
+	return t && (i.customSortMeasuresIdx = n.length), i;
+};
+function tr(e, t) {
+	return {
+		type: "excel-format",
+		format: rr(Te(e), e, !1, t)
+	};
+}
+function nr(e) {
+	return {
+		type: "excel-format",
+		format: rr(Te(e), e, !0)
+	};
+}
+function rr(e, t, n = !1, r = "") {
+	let i = e;
+	e === I.FieldType.GROUPED_DIMENSION && N(t) && (i = a[t.dimension.resultType]);
+	let o = { ...S }, s = ir(i, t, r);
+	switch (!0) {
+		case !!ge(t): return o.formatType = v.Inherit, o;
+		case n && (i === I.FieldType.TIMESTAMP || i === I.FieldType.TIMESTAMP_TZ): return o.formatType = p.DefaultDatetime, o;
+		case n && He(i): return o.formatType = p.DefaultDate, o;
+		case s === I.FieldType.TIME: return o.formatType = p.DefaultTime, o;
+		case s === I.FieldType.INT: return o.formatType = v.AbbreviationAuto, o;
+		case s === I.FieldType.DECIMAL || s === I.FieldType.FLOAT: return o.formatType = v.DefaultNumber, o;
+		default: return o;
+	}
+}
+function ir(e, t, n) {
+	let r = (t?.aggregators ?? []).find((e) => e.funcName === n);
+	return r ? r.resultType === "incoming" ? e : r.resultType : null;
+}
+var ar = (e, n, r, i, a, o) => {
+	let { key: s, newReferencedData: c } = Se(r, e), l = {
+		dataItem: Oe(e, s),
+		label: Pe(e),
+		description: t(e),
+		formatter: o ?? nr(e),
+		showNullValues: !0,
+		enabled: !1,
+		role: n
+	}, u = $n(l, (i ?? []).length === 0), d = [...i ?? [], u];
+	return {
+		newReferencedData: c,
+		newDimension: l,
+		newDimensions: [...Me(a), l],
+		newSorting: d
+	};
+}, or = (e) => {
+	let t = e.querySettings?.pageSize, n = O(e);
+	return t ?? n;
+}, sr = (e) => e.querySettings?.limitQuery ?? or(e), cr = () => ({ segmentSettings: {
+	position: ee.Absolute,
+	segments: []
+} }), lr = (e, t, n, r, i) => e.map((e) => {
+	if (e.id === t && b(e)) {
+		let t = e.indicatorSettings ?? cr(), a = t.segmentSettings ?? cr().segmentSettings;
+		return {
+			...e,
+			indicatorSettings: {
+				...t,
+				segmentSettings: {
+					...a,
+					segments: (a.segments ?? []).map((e, t) => t === n ? {
+						...e,
+						[r]: i
+					} : e)
+				}
+			}
+		};
+	}
+	return e;
+}), ur = (e, t, n = {}) => {
+	let r = t === "button" ? ce.Button : ce.Text;
+	return {
+		...Me(Ve),
+		id: C(),
+		columnType: t,
+		dataItem: e.dataItem,
+		label: e.label,
+		description: e.description,
+		formatter: e.formatter,
+		representation: r,
+		parameters: "parameters" in e ? e.parameters : void 0,
+		...dr(t, n),
+		...e.showNullValues !== void 0 && { showNullValues: e.showNullValues }
+	};
+}, dr = (e, t) => ({
+	horizontalAlign: t?.horizontalAlign ?? g.horizontalAlign,
+	fontColor: { code: t?.fontColor ?? g.fontColor },
+	backgroundColor: { code: t?.backgroundColor ?? g.backgroundColor },
+	verticalAlign: t?.verticalAlign ?? g.verticalAlign,
+	border: t?.border ?? g.border,
+	filterIconBehavior: t?.filterIconBehavior ?? g.filterIconBehavior,
+	sortIconBehavior: t?.sortIconBehavior ?? g.sortIconBehavior,
+	drillThroughIconBehaviour: t?.drillThroughIconBehaviour ?? g.drillThroughIconBehaviour,
+	freezeIconBehaviour: t?.freezeIconBehaviour ?? g.freezeIconBehaviour,
+	...t?.fontStyle && { fontStyle: t.fontStyle }
+}), fr = (e, t, n) => {
+	let r = t.find((t) => P(t.dataItem) === P(e));
+	if (!r) throw Error("Data item not found");
+	let i = Me(r);
+	return i.dataItem.uniqueSignature = E(), n.push(i), i.dataItem;
+}, pr = /* @__PURE__ */ e(ze()), mr = (e, r, a, o, s, c, l) => {
+	let { key: d, newReferencedData: f } = Se(o, e), p = {
+		dataItem: Re(e, r, d),
+		label: Pe(e),
+		description: t(e),
+		formatter: l ?? tr(e, r),
+		showNullValues: !0,
+		aggregation: n(r),
+		advancedCalculation: i,
+		nestedCalculation: i,
+		forecasts: [],
+		enabled: !1,
+		role: a
+	}, m = u(e, c);
+	m && (p.parameters = {
+		...p.parameters,
+		...m
+	});
+	let h = er(p, !1, [], (s ?? []).length === 0);
+	return {
+		newReferencedData: f,
+		newMeasure: p,
+		newSorting: [...s ?? [], h]
+	};
+};
+function Y(e) {
+	let t = {}, n = new Ke();
+	n.subscribe((e) => {
+		"payload" in e && typeof e.payload == "object" && e.payload !== null && "vSpecChange" in e.payload && e.payload.vSpecChange && (t = (0, Jn.default)(t, e.payload.vSpecChange, (e, t) => Array.isArray(t) ? t : void 0));
+	});
+	let r = e.map((e) => e(n, t)), i = r.find((e) => !e.success);
+	return n.complete(), i ? {
+		vSpecPartial: t,
+		results: r,
+		success: !1,
+		errorMessage: i.errorMessage
+	} : {
+		vSpecPartial: t,
+		results: r,
+		success: !0
+	};
+}
+var hr = he(), gr = (e) => N(e) ? e.type === hr.DatabaseItemType.MEASURE ? "measure" : e.type === hr.DatabaseItemType.CALCULATION ? "calculation" : null : "field", _r = (e, t, n) => {
+	if (!t) return null;
+	let r = gr(e);
+	return r ? r === t ? null : {
+		success: !1,
+		errorMessage: `Selected item ${e.name ?? e.key} is a ${r}, not a ${t}`
+	} : {
+		success: !1,
+		errorMessage: `Selected item ${e.name ?? e.key} cannot be added as a ${n}`
+	};
+}, vr = (e, t) => N(e) && e.type !== hr.DatabaseItemType.MEASURE && e.type !== hr.DatabaseItemType.CALCULATION ? {
+	success: !1,
+	errorMessage: `When using DVE-defined items, only measure or calculation can be added as the ${t}`
+} : null, yr = (e, t) => N(e) ? void 0 : t, br = (e, t, n) => ({
+	success: !1,
+	errorMessage: `Aggregation "${t}" is not supported for ${n} ${e.name ?? e.key}. Supported aggregations: ${Xn(e)}`
+}), xr = (e, t, n, r) => {
+	if (N(e)) return { result: null };
+	if (!t) return { result: {
+		success: !1,
+		errorMessage: n
+	} };
+	let i = Zn(e, t);
+	return i ? {
+		result: null,
+		resolvedAggregation: i
+	} : { result: br(e, t, r) };
+}, Sr = (e, t, n) => {
+	if (!e) return {
+		result: null,
+		resolvedAggregation: t
+	};
+	let r = Zn(e, t);
+	return r ? {
+		result: null,
+		resolvedAggregation: r
+	} : {
+		result: br(e, t, n),
+		resolvedAggregation: t
+	};
+};
+function Cr(e, t, n, r, i) {
+	return q(e, { [t]: De(n, r, i) }), { success: !0 };
+}
+function X(e, t, n, r) {
+	return Cr(e, "measures", t, n, r);
+}
+var Z = Ie("measure-handlers", "#76ff03"), wr = (e, t, n, r, i = [], a, o, s, c = [], l, u, d, f, p, m) => {
+	Z.info("[handleMeasureAdd] input", {
+		field: o,
+		aggregation: l,
+		dimensions: n,
+		measures: t,
+		sortingOrder: i
+	});
+	let { success: h, errorMessage: g } = J(F.object({
+		dimensions: F.array(U),
+		measures: F.array(W),
+		chartType: F.string(),
+		referencedData: yn,
+		sortingOrder: G.shape.sortingOrder,
+		field: jt,
+		aggregation: F.string().optional(),
+		role: F.enum(_).optional()
+	}), {
+		dimensions: n,
+		measures: t,
+		chartType: r,
+		referencedData: a,
+		sortingOrder: i,
+		field: o,
+		aggregation: l,
+		role: s
+	}, Z, "handleMeasureAdd");
+	if (!h) return {
+		success: !1,
+		errorMessage: g
+	};
+	let v = _r(o, m, "measure");
+	if (v) return v;
+	let y = N(o), b = vr(o, "measure");
+	if (b) return Z.error("[handleMeasureAdd] When using DVE-defined items, only measure or calculation can be added", {
+		field: o,
+		aggregation: l,
+		isCustomMeasure: y
+	}), b;
+	let { result: x, resolvedAggregation: S } = xr(o, l, "Aggregation is required for non-DVE-defined measures", "measure field");
+	if (x?.success === !1) return Z.error("[handleMeasureAdd] invalid aggregation for measure", {
+		field: o,
+		aggregation: l,
+		isCustomMeasure: y,
+		errorMessage: x.errorMessage
+	}), x;
+	let C = i ?? [], { newReferencedData: ee, newMeasure: w, newSorting: te } = mr(o, yr(o, S), s, a, C, c, u), T = w;
+	f && (T = f(w));
+	let ne = [...structuredClone(t), T], { dimensions: E, measures: D } = A(n, ne, r, {
+		type: M.ENABLE,
+		dataItemId: P(T.dataItem)
+	}, { alternateSettings: p }), O = d?.({
+		dimensions: E,
+		measures: D
+	});
+	return Z.debug("[handleMeasureAdd] adding new measure", {
+		finalMeasure: T,
+		newMeasures: ne,
+		adjustedDimensions: E,
+		adjustedMeasures: D,
+		oldSorting: C,
+		newSorting: te,
+		newColoring: O
+	}), q(e, {
+		referencedData: ee,
+		dimensions: E,
+		measures: D,
+		querySettings: { sortingOrder: te },
+		...O ? { coloring: O } : {}
+	}), {
+		success: !0,
+		data: T
+	};
+}, Tr = (e, t, n, r, i = [], a, o, s, c, u = [], d, f, p, m, h, g) => {
+	Z.info("[handleMeasureAddForEngineKey] input", {
+		measures: t,
+		dimensions: n,
+		chartType: r,
+		referencedData: o,
+		sortingOrder: i,
+		engineKey: s,
+		aggregation: d,
+		role: c,
+		coloringSideEffectsFn: p,
+		availableFields: a
+	});
+	let { success: v, errorMessage: y } = J(F.object({
+		dimensions: F.array(U),
+		measures: F.array(W),
+		chartType: F.string(),
+		referencedData: yn,
+		sortingOrder: G.shape.sortingOrder,
+		engineKey: F.string(),
+		aggregation: F.string().optional(),
+		role: F.enum(_).optional()
+	}), {
+		dimensions: n,
+		measures: t,
+		chartType: r,
+		referencedData: o,
+		sortingOrder: i,
+		engineKey: s,
+		aggregation: d,
+		role: c
+	}, Z, "handleMeasureAddForEngineKey");
+	if (!v) return {
+		success: !1,
+		errorMessage: y
+	};
+	let b = l(a, s);
+	if (!b) return {
+		success: !1,
+		errorMessage: `Field with engine key ${s} not found`
+	};
+	let x = _r(b, h, "measure");
+	if (x) return x;
+	let S = N(b), { result: C, resolvedAggregation: ee } = xr(b, d, "Aggregation is required for non-DVE-defined measures", "measure field");
+	if (C?.success === !1) return Z.error("[handleMeasureAddForEngineKey] invalid aggregation for measure", {
+		field: b,
+		aggregation: d,
+		isCustomMeasure: S,
+		errorMessage: C.errorMessage
+	}), C;
+	let w = vr(b, "measure");
+	if (w) return Z.error("[handleMeasureAddForEngineKey] When using DVE-defined items, only measure or calculation can be added", {
+		field: b,
+		aggregation: d,
+		isCustomMeasure: S
+	}), w;
+	let te = yr(b, ee), T = i ?? [], { newReferencedData: ne, newMeasure: E, newSorting: D } = mr(b, te, c, o, T, u, f), O = E;
+	g && (O = g(E));
+	let k = [...structuredClone(t), O], { dimensions: re, measures: ie } = A(n, k, r, {
+		type: M.ENABLE,
+		dataItemId: P(E.dataItem)
+	}, { alternateSettings: m }), ae = p?.({
+		dimensions: re,
+		measures: ie
+	});
+	return Z.debug("[handleMeasureAdd] adding new measure", {
+		newMeasure: E,
+		newMeasures: k,
+		adjustedDimensions: re,
+		adjustedMeasures: ie,
+		oldSorting: T,
+		newSorting: D,
+		newColoring: ae
+	}), q(e, {
+		referencedData: ne,
+		dimensions: re,
+		measures: ie,
+		querySettings: { sortingOrder: D },
+		...ae ? { coloring: ae } : {}
+	}), {
+		success: !0,
+		data: O
+	};
+}, Er = (e, t, n, r, i, a = [], o, s, c, l) => {
+	Z.info("handleMeasureRemove input", {
+		measures: t,
+		dataItemId: i,
+		sortingOrder: a
+	});
+	let { success: u, errorMessage: d } = J(F.object({
+		measures: F.array(W),
+		dataItemId: Array.isArray(i) ? F.array(V) : V,
+		sortingOrder: _n
+	}), {
+		measures: t,
+		dataItemId: i,
+		sortingOrder: a
+	}, Z, "handleMeasureRemove");
+	if (!u) return {
+		success: !1,
+		errorMessage: d
+	};
+	let f = Array.isArray(i) ? i : [i], p = structuredClone(t).filter((e) => !f.includes(P(e.dataItem))), m = structuredClone(a).filter((e) => e.dataItem === null || !f.includes(P(e.dataItem))), h = pe(p, o), g = structuredClone(c ?? []).filter((e) => !f.includes(P(e.dataItem))), { dimensions: _, measures: v } = A(n, p, r, { type: M.FIX_STATE }, { alternateSettings: l }), y = s?.({
+		dimensions: _,
+		measures: v
+	});
+	return Z.debug("[handleMeasureRemove] removing measure(s)", {
+		newMeasures: p,
+		adjustedDimensions: _,
+		adjustedMeasures: v,
+		newSorting: m,
+		newRefLines: h,
+		newColoring: y
+	}), q(e, {
+		dimensions: _,
+		measures: v,
+		querySettings: { sortingOrder: m },
+		refLines: h,
+		...y ? { coloring: y } : {},
+		grid: g
+	}), { success: !0 };
+}, Dr = (e, t, n, r, i) => {
+	Z.info("handleMeasureChangeForDataItemId input", {
+		measures: t,
+		dataItemId: n,
+		changes: r
+	});
+	let { success: a, errorMessage: o } = J(F.object({
+		measures: F.array(W),
+		dataItemId: V,
+		changes: F.object({ customLabel: F.object({
+			enabled: F.boolean(),
+			value: F.string().optional()
+		}).optional() })
+	}), {
+		measures: t,
+		dataItemId: n,
+		changes: r
+	}, Z, "handleMeasureChangeForDataItemId");
+	if (!a) return {
+		success: !1,
+		errorMessage: o
+	};
+	let s = Ne(t, n, (e) => (r.customLabel !== void 0 && r.customLabel !== null && (e.customLabel = {
+		enabled: r.customLabel.enabled,
+		value: r.customLabel.value
+	}), e)), c = i?.({ measures: s });
+	return Z.debug("[handleMeasureChangeForDataItemId] updating measure", {
+		newMeasures: s,
+		newColoring: c
+	}), q(e, {
+		measures: s,
+		...c ? { coloring: c } : {}
+	}), { success: !0 };
+}, Or = (e, t, n, r, i, a, o, s, c = !1, l) => {
+	Z.info("handleMeasureToggle input", {
+		measures: t,
+		dimensions: n,
+		chartType: r,
+		dataItemId: a,
+		enabled: o
+	});
+	let { success: u, errorMessage: d } = J(F.object({
+		measures: F.array(W),
+		dimensions: F.array(U),
+		chartType: F.string(),
+		dataItemId: V,
+		enabled: F.boolean()
+	}), {
+		measures: t,
+		dimensions: n,
+		chartType: r,
+		dataItemId: a,
+		enabled: o
+	}, Z, "handleMeasureToggle");
+	if (!u) return {
+		success: !1,
+		errorMessage: d
+	};
+	if (a === null) return {
+		success: !1,
+		errorMessage: "Data item ID is required"
+	};
+	let f = structuredClone(t), { dimensions: p, measures: m } = A(n, f, r, {
+		type: o ? M.ENABLE : M.DISABLE,
+		dataItemId: a
+	}, {
+		fixStateOnDisable: c,
+		alternateSettings: l
+	}), h = s?.({
+		dimensions: p,
+		measures: m
+	}), g = pe(m, i);
+	return Z.debug("[handleMeasureToggle] updating measure", {
+		newMeasures: f,
+		adjustedDimensions: p,
+		adjustedMeasures: m,
+		newColoring: h,
+		newRefLines: g
+	}), q(e, {
+		dimensions: p,
+		measures: m,
+		...h ? { coloring: h } : {},
+		refLines: g
+	}), { success: !0 };
+}, kr = (e, t, n, r, i, a, o, s, c) => {
+	Z.info("handleToggleMeasuresByNames input", {
+		measures: t,
+		name: a,
+		enabled: o,
+		coloringSideEffectsFn: s
+	});
+	let l = t.filter((e) => e.label === a);
+	if (l.length === 0) return Z.info("[handleToggleMeasuresByNames] No matching measures found, nothing to toggle", { name: a }), { success: !0 };
+	let u = [];
+	l.forEach((e) => {
+		let a = P(e.dataItem), l = o === void 0 ? !e.enabled : o;
+		u.push((e, o) => Or(e, o.measures ?? t, o.dimensions ?? n, r, i, a, l, s, !1, c));
+	});
+	let d = Y(u);
+	return d.success ? (Z.debug("[handleToggleMeasuresByNames] updated measures", { newMeasures: d.vSpecPartial.measures }), q(e, d.vSpecPartial), { success: !0 }) : {
+		success: !1,
+		errorMessage: d?.errorMessage
+	};
+}, Ar = (e, t, n, r, i, a, o, s) => {
+	Z.info("handleMeasureDuplicate input", {
+		measures: t,
+		dataItemId: i,
+		sortingOrder: s
+	});
+	let { success: c, errorMessage: l } = J(F.object({
+		measures: F.array(W),
+		dataItemId: V,
+		sortingOrder: G.shape.sortingOrder.optional()
+	}), {
+		measures: t,
+		dataItemId: i,
+		sortingOrder: s
+	}, Z, "handleMeasureDuplicate");
+	if (!c) return {
+		success: !1,
+		errorMessage: l
+	};
+	let u = Array.isArray(i) ? i : [i], d = structuredClone(t), f = u.map((e) => d.find((t) => P(t.dataItem) === e)).filter((e) => e !== void 0).map((e) => {
+		let t = structuredClone(e);
+		return t.dataItem.uniqueSignature = E(), t;
+	}), p = [...d, ...f], m = s ? [...s, ...f.map((e, t) => er(e, !1, [], s.length === 0 && t === 0))] : void 0, h = structuredClone(n), g = structuredClone(p);
+	for (let e of f) {
+		let { dimensions: t, measures: i } = A(n, g, r, {
+			type: M.ENABLE,
+			dataItemId: P(e.dataItem)
+		}, { alternateSettings: o });
+		h = t, g = i;
+	}
+	let _ = a?.({
+		dimensions: h,
+		measures: g
+	});
+	return Z.debug("[handleMeasureDuplicate] duplicating measure(s)", {
+		newMeasures: p,
+		adjustedDimensionsResult: h,
+		adjustedMeasuresResult: g,
+		newSorting: m,
+		newColoring: _
+	}), q(e, {
+		dimensions: h,
+		measures: g,
+		...m ? { querySettings: { sortingOrder: m } } : {},
+		..._ ? { coloring: _ } : {}
+	}), {
+		data: f,
+		success: !0
+	};
+}, jr = (e, r, i, a = [], o, s, c, l, u, d) => {
+	Z.info("handleMeasureFieldChange input", {
+		measures: r,
+		dataItemId: i,
+		newField: s,
+		aggregation: l,
+		uniqueSignature: u,
+		sourceKind: d
+	});
+	let { success: f, errorMessage: p } = J(F.object({
+		measures: F.array(W),
+		dataItemId: V,
+		newField: jt,
+		aggregation: F.string().optional(),
+		uniqueSignature: F.string().optional()
+	}), {
+		measures: r,
+		dataItemId: i,
+		newField: s,
+		aggregation: l,
+		uniqueSignature: u
+	}, Z, "handleMeasureFieldChange");
+	if (!f) return {
+		success: !1,
+		errorMessage: p
+	};
+	let m = _r(s, d, "measure");
+	if (m) return m;
+	if (!gr(s)) return {
+		success: !1,
+		errorMessage: `Selected item ${s.name ?? s.key} cannot be used as a measure`
+	};
+	let { result: h, resolvedAggregation: g } = xr(s, l, "Aggregation is required for raw fields used as measures", "measure field");
+	if (h) return h;
+	let _ = yr(s, g), v = r.findIndex((e) => P(e.dataItem) === i);
+	if (v === -1) return {
+		success: !1,
+		errorMessage: `Measure with data item ID ${i} not found`
+	};
+	let y = a?.findIndex((e) => P(e.dataItem) === i), { key: b, newReferencedData: x } = Se(o, s), S = we(Ne(r, i, (e) => ({
+		...e,
+		label: Pe(s),
+		description: t(s),
+		dataItem: Re(s, _, b, u),
+		aggregation: n(_)
+	}))), C = S[v], ee = [...a];
+	y > -1 && (ee[y] = er(C, !1, [], a[y]?.enabled));
+	let w = c?.({ measures: S });
+	return Z.debug("[handleMeasureFieldChange] updating measure", {
+		newReferencedData: x,
+		newMeasures: S,
+		newColoring: w
+	}), q(e, {
+		referencedData: x,
+		measures: S,
+		...w ? { coloring: w } : {},
+		querySettings: { sortingOrder: ee }
+	}), {
+		data: C,
+		success: !0
+	};
+}, Mr = (e, t, r, i, a, o) => {
+	Z.info("handleMeasureAggregationChange input", {
+		measures: t,
+		dataItemId: r,
+		aggregation: i
+	});
+	let { success: s, errorMessage: c } = J(F.object({
+		measures: F.array(W),
+		dataItemId: V,
+		aggregation: F.string()
+	}), {
+		measures: t,
+		dataItemId: r,
+		aggregation: i
+	}, Z, "handleMeasureAggregationChange");
+	if (!s) return {
+		success: !1,
+		errorMessage: c
+	};
+	let { result: l, resolvedAggregation: u } = Sr(o, i, "measure");
+	if (l) return l;
+	let d = n(u);
+	if (!d) return {
+		success: !1,
+		errorMessage: `Aggregation "${u}" is not recognized`
+	};
+	let f = Ne(t, r, (e) => ({
+		...e,
+		aggregation: d,
+		dataItem: {
+			...e.dataItem,
+			aggregation: d
+		}
+	})), p = a?.({ measures: f });
+	return q(e, {
+		measures: f,
+		...p ? { coloring: p } : {}
+	}), { success: !0 };
+}, Nr = (e, t, n, r) => {
+	Z.info("handleMeasureStrokeWidthChange input", {
+		measures: t,
+		dataItemId: n,
+		strokeWidth: r
+	});
+	let { success: i, errorMessage: a } = J(F.object({
+		measures: F.array(W),
+		dataItemId: V,
+		strokeWidth: W.shape.strokeWidth
+	}), {
+		measures: t,
+		dataItemId: n,
+		strokeWidth: r
+	}, Z, "handleMeasureStrokeWidthChange");
+	return i ? X(e, t, n, (e) => ({
+		...e,
+		strokeWidth: r,
+		...e.strokeDash ? { strokeDash: {
+			width: r * 3,
+			space: r * 3
+		} } : {}
+	})) : {
+		success: !1,
+		errorMessage: a
+	};
+}, Pr = (e, t, n, r, i = 1) => {
+	Z.info("handleMeasureLineStyleChange input", {
+		measures: t,
+		dataItemId: n,
+		lineStyle: r,
+		strokeWidth: i
+	});
+	let { success: a, errorMessage: o } = J(F.object({
+		measures: F.array(W),
+		dataItemId: V,
+		lineStyle: F.enum(Ae),
+		strokeWidth: W.shape.strokeWidth.optional()
+	}), {
+		measures: t,
+		dataItemId: n,
+		lineStyle: r,
+		strokeWidth: i
+	}, Z, "handleMeasureLineStyleChange");
+	if (!a) return {
+		success: !1,
+		errorMessage: o
+	};
+	let s = r === Ae.Dashed ? {
+		width: i * 3,
+		space: i * 3
+	} : null;
+	return X(e, t, n, (e) => ({
+		...e,
+		strokeDash: s
+	}));
+}, Fr = (e, t, n, r) => {
+	Z.info("handleMeasureDataPointShapeChange input", {
+		measures: t,
+		dataItemId: n,
+		dataPointShape: r
+	});
+	let { success: i, errorMessage: a } = J(F.object({
+		measures: F.array(W),
+		dataItemId: V,
+		dataPointShape: W.shape.dataPointShape
+	}), {
+		measures: t,
+		dataItemId: n,
+		dataPointShape: r
+	}, Z, "handleMeasureDataPointShapeChange");
+	if (!i) return {
+		success: !1,
+		errorMessage: a
+	};
+	let o = {};
+	return (0, pr.default)(r) ? (o.dataPointShape = null, o.showDataPoints = !1) : (o.dataPointShape = r, o.showDataPoints = !0), X(e, t, n, (e) => ({
+		...e,
+		...o
+	}));
+}, Ir = (e, t, n, r) => {
+	Z.info("handleMeasureDataPointSizeChange input", {
+		measures: t,
+		dataItemId: n,
+		dataPointSize: r
+	});
+	let { success: i, errorMessage: a } = J(F.object({
+		measures: F.array(W),
+		dataItemId: V,
+		dataPointSize: W.shape.dataPointSize
+	}), {
+		measures: t,
+		dataItemId: n,
+		dataPointSize: r
+	}, Z, "handleMeasureDataPointSizeChange");
+	return i ? X(e, t, n, (e) => ({
+		...e,
+		dataPointSize: r
+	})) : {
+		success: !1,
+		errorMessage: a
+	};
+}, Lr = (e, t, n, r) => {
+	Z.info("handleMeasureDataPointSizeMinChange input", {
+		measures: t,
+		dataItemId: n,
+		dataPointSizeMinPx: r
+	});
+	let { success: i, errorMessage: a } = J(F.object({
+		measures: F.array(W),
+		dataItemId: V,
+		dataPointSizeMinPx: W.shape.dataPointSizeMinPx
+	}), {
+		measures: t,
+		dataItemId: n,
+		dataPointSizeMinPx: r
+	}, Z, "handleMeasureDataPointSizeMinChange");
+	return i ? X(e, t, n, (e) => ({
+		...e,
+		dataPointSizeMinPx: r
+	})) : {
+		success: !1,
+		errorMessage: a
+	};
+}, Rr = (e, t, n, r) => {
+	Z.info("handleMeasureDataPointSizeMaxChange input", {
+		measures: t,
+		dataItemId: n,
+		dataPointSizeMaxPx: r
+	});
+	let { success: i, errorMessage: a } = J(F.object({
+		measures: F.array(W),
+		dataItemId: V,
+		dataPointSizeMaxPx: W.shape.dataPointSizeMaxPx
+	}), {
+		measures: t,
+		dataItemId: n,
+		dataPointSizeMaxPx: r
+	}, Z, "handleMeasureDataPointSizeMaxChange");
+	return i ? X(e, t, n, (e) => ({
+		...e,
+		dataPointSizeMaxPx: r
+	})) : {
+		success: !1,
+		errorMessage: a
+	};
+};
+function zr(e, t, n, r, i) {
+	Z.info("handleMeasureSecondaryAxis input", {
+		measureDataItemId: n,
+		secondaryAxis: i
+	});
+	let { success: a, errorMessage: o } = J(F.object({
+		measures: F.array(W),
+		measureDataItemId: V,
+		secondaryAxis: W.shape.secondaryAxis
+	}), {
+		measures: t,
+		measureDataItemId: n,
+		secondaryAxis: i
+	}, Z, "handleMeasureSecondaryAxis");
+	if (!a) return {
+		success: !1,
+		errorMessage: o
+	};
+	let s = Ne(t, n, (e) => ({
+		...e,
+		secondaryAxis: i
+	}));
+	return q(e, {
+		measures: s,
+		refLines: pe(s, r)
+	}), { success: !0 };
+}
+function Br(e, t, n, r) {
+	Z.info("handleDataLabelsBackdropColor input", {
+		measureDataItemId: n,
+		backdropColor: r
+	});
+	let { success: i, errorMessage: a } = J(F.object({
+		measures: F.array(W),
+		measureDataItemId: V,
+		backdropColor: W.shape.dataLabels.unwrap().shape.backdropColor
+	}), {
+		measures: t,
+		measureDataItemId: n,
+		backdropColor: r
+	}, Z, "handleDataLabelsBackdropColor");
+	return i ? X(e, t, n, (e) => ({
+		...e,
+		dataLabels: {
+			...e.dataLabels,
+			backdropColor: r
+		}
+	})) : {
+		success: !1,
+		errorMessage: a
+	};
+}
+function Vr(e, t, n, r) {
+	Z.info("handleDataLabelsShowBackdrop input", {
+		measureDataItemId: n,
+		showBackdrop: r
+	});
+	let { success: i, errorMessage: a } = J(F.object({
+		measures: F.array(W),
+		measureDataItemId: V,
+		showBackdrop: W.shape.dataLabels.unwrap().shape.showBackdrop
+	}), {
+		measures: t,
+		measureDataItemId: n,
+		showBackdrop: r
+	}, Z, "handleDataLabelsShowBackdrop");
+	return i ? X(e, t, n, (e) => ({
+		...e,
+		dataLabels: {
+			...e.dataLabels,
+			showBackdrop: r
+		}
+	})) : {
+		success: !1,
+		errorMessage: a
+	};
+}
+function Hr(e, t, n, r) {
+	Z.info("handleMeasureDataLabelsTextColor input", {
+		measureDataItemId: n,
+		textColor: r
+	});
+	let { success: i, errorMessage: a } = J(F.object({
+		measures: F.array(W),
+		measureDataItemId: V,
+		textColor: W.shape.dataLabels.unwrap().shape.textColor
+	}), {
+		measures: t,
+		measureDataItemId: n,
+		textColor: r
+	}, Z, "handleMeasureDataLabelsTextColor");
+	return i ? X(e, t, n, (e) => ({
+		...e,
+		dataLabels: {
+			...e.dataLabels,
+			textColor: r
+		}
+	})) : {
+		success: !1,
+		errorMessage: a
+	};
+}
+function Ur(e, t, n, r) {
+	Z.info("handleMeasureDataLabelsIsColored input", {
+		measureDataItemId: n,
+		isColored: r
+	});
+	let { success: i, errorMessage: a } = J(F.object({
+		measures: F.array(W),
+		measureDataItemId: V,
+		isColored: W.shape.dataLabels.unwrap().shape.isColored
+	}), {
+		measures: t,
+		measureDataItemId: n,
+		isColored: r
+	}, Z, "handleMeasureDataLabelsIsColored");
+	return i ? X(e, t, n, (e) => ({
+		...e,
+		dataLabels: {
+			...e.dataLabels,
+			isColored: r
+		}
+	})) : {
+		success: !1,
+		errorMessage: a
+	};
+}
+function Wr(e, t, n, r) {
+	Z.info("handleMeasureDataLabelsDensity input", {
+		measureDataItemId: n,
+		density: r
+	});
+	let { success: i, errorMessage: a } = J(F.object({
+		measures: F.array(W),
+		measureDataItemId: V,
+		density: W.shape.dataLabels.unwrap().shape.density
+	}), {
+		measures: t,
+		measureDataItemId: n,
+		density: r
+	}, Z, "handleMeasureDataLabelsDensity");
+	return i ? X(e, t, n, (e) => ({
+		...e,
+		dataLabels: {
+			...e.dataLabels,
+			density: r
+		}
+	})) : {
+		success: !1,
+		errorMessage: a
+	};
+}
+function Gr(e, t, n, r) {
+	Z.info("handleDataLabelsDisplayParts input", {
+		measureDataItemId: n,
+		displayParts: r
+	});
+	let i = [];
+	switch (r) {
+		case "Value":
+			i = [f.Value];
+			break;
+		case "Ratio":
+			i = [f.Ratio];
+			break;
+		case "Both":
+			i = [f.Value, f.Ratio];
+			break;
+	}
+	let { success: a, errorMessage: o } = J(F.object({
+		measures: F.array(W),
+		measureDataItemId: V,
+		displayParts: W.shape.dataLabels.unwrap().shape.displayParts
+	}), {
+		measures: t,
+		measureDataItemId: n,
+		displayParts: i
+	}, Z, "handleDataLabelsDisplayParts");
+	return a ? X(e, t, n, (e) => ({
+		...e,
+		dataLabels: {
+			...e.dataLabels,
+			displayParts: i
+		}
+	})) : {
+		success: !1,
+		errorMessage: o
+	};
+}
+function Kr(e, t, n, r) {
+	Z.info("handleMeasureDataLabelsBarPlacementsChange input", {
+		measure: n,
+		placements: r
+	});
+	let { success: i, errorMessage: a } = J(F.object({ placements: W.shape.dataLabels.unwrap().shape.barLabelPlacements }), { placements: r }, Z, "handleMeasureDataLabelsBarPlacementsChange");
+	return i ? X(e, t, P(n.dataItem), (e) => ({
+		...e,
+		dataLabels: {
+			...e.dataLabels,
+			barLabelPlacements: r
+		}
+	})) : {
+		success: !1,
+		errorMessage: a
+	};
+}
+function qr(e, t, n, r) {
+	Z.info("handleMeasureGraphColor input", {
+		measureDataItemId: n,
+		graphColor: r
+	});
+	let { success: i, errorMessage: a } = J(F.object({
+		measures: F.array(W),
+		measureDataItemId: V,
+		graphColor: W.shape.graphColor
+	}), {
+		measures: t,
+		measureDataItemId: n,
+		graphColor: r
+	}, Z, "handleMeasureGraphColor");
+	return i ? X(e, t, n, (e) => ({
+		...e,
+		graphColor: r
+	})) : {
+		success: !1,
+		errorMessage: a
+	};
+}
+function Jr(e, t, n, r, i) {
+	Z.info("handleMeasuresParameterChange input", {
+		measureDataItemId: n,
+		variableName: r,
+		value: i
+	});
+	let { success: a, errorMessage: o } = J(F.object({
+		measures: F.array(W),
+		measureDataItemId: V,
+		variableName: F.string(),
+		value: tn.optional()
+	}), {
+		measures: t,
+		measureDataItemId: n,
+		variableName: r,
+		value: i
+	}, Z, "handleMeasuresParameterChange");
+	return a ? X(e, t, n, (e) => {
+		let { [r]: t, ...n } = e.parameters || {};
+		return i === void 0 ? {
+			...e,
+			parameters: n
+		} : {
+			...e,
+			parameters: {
+				...n,
+				[r]: i
+			}
+		};
+	}) : {
+		success: !1,
+		errorMessage: o
+	};
+}
+function Yr(e, t, n, r) {
+	Z.info("handleMeasureGraphType input", {
+		measure: n,
+		graphType: r
+	});
+	let { success: i, errorMessage: a } = J(F.object({ graphType: W.shape.graphType }), { graphType: r }, Z, "handleMeasureGraphType");
+	if (!i) return {
+		success: !1,
+		errorMessage: a
+	};
+	let o = Ne(t, P(n.dataItem), (e) => ({
+		...e,
+		graphType: r
+	}));
+	if (r === je.Bar) {
+		let e = o.find((e) => e.graphType === je.Bar), t = e?.secondaryAxis ?? !1, n = o.filter((n) => n.graphType === je.Bar && n !== e && n.secondaryAxis !== t).map((e) => P(e.dataItem));
+		n?.length && (o = o.map((e) => n.includes(P(e.dataItem)) ? {
+			...e,
+			secondaryAxis: t
+		} : e));
+	}
+	return X(e, o, null, (e) => e);
+}
+var Xr = /* @__PURE__ */ e(Fe()), Q = Ie("dimension-handlers", "#aaa69d"), Zr = (e, t, n, r, i, a = [], o, s, c, l, u) => {
+	Q.info("handleDimensionAdd input", {
+		field: o,
+		dimensions: t,
+		measures: n,
+		chartType: r,
+		referencedData: i,
+		sortingOrder: a,
+		role: s,
+		coloringSideEffectsFn: l
+	});
+	let { success: d, errorMessage: f } = J(F.object({
+		dimensions: F.array(U),
+		measures: F.array(W),
+		chartType: F.string(),
+		referencedData: yn,
+		sortingOrder: G.shape.sortingOrder,
+		field: jt,
+		role: F.enum(oe).optional()
+	}), {
+		dimensions: t,
+		measures: n,
+		chartType: r,
+		referencedData: i,
+		sortingOrder: a,
+		field: o,
+		role: s
+	}, Q, "handleDimensionAdd");
+	if (!d) return {
+		success: !1,
+		errorMessage: f
+	};
+	let { newReferencedData: p, newDimension: m, newSorting: h } = ar(o, s, i, a ?? [], t, c);
+	Q.debug("[handleDimensionAdd] adding new dimension", {
+		newDimension: m,
+		oldSorting: a,
+		newSorting: h,
+		newReferencedData: p
+	});
+	let g = [...structuredClone(t), m], { dimensions: _, measures: v } = A(g, n, r, {
+		type: M.ENABLE,
+		dataItemId: P(m.dataItem)
+	}, { alternateSettings: u }), y = l?.({
+		dimensions: _,
+		measures: v
+	});
+	return Q.debug("[handleDimensionAdd] new dimension created", {
+		newDimension: m,
+		newDimensions: g,
+		adjustedDimensions: _,
+		adjustedMeasures: v,
+		newColoring: y
+	}), q(e, {
+		referencedData: p,
+		dimensions: _,
+		measures: v,
+		querySettings: { sortingOrder: h },
+		...y ? { coloring: y } : {}
+	}), {
+		success: !0,
+		data: m
+	};
+}, Qr = (e, t, n, r, i = [], a, o, s, c, u, d, f) => {
+	Q.info("handleDimensionAddForEngineKey input", {
+		dimensions: t,
+		measures: n,
+		chartType: r,
+		referencedData: o,
+		sortingOrder: i,
+		engineKey: s,
+		role: c,
+		coloringSideEffectsFn: d,
+		availableFields: a
+	});
+	let { success: p, errorMessage: m } = J(F.object({
+		dimensions: F.array(U),
+		measures: F.array(W),
+		chartType: F.string(),
+		referencedData: yn,
+		sortingOrder: G.shape.sortingOrder,
+		engineKey: F.string(),
+		role: F.enum(oe).optional()
+	}), {
+		dimensions: t,
+		measures: n,
+		chartType: r,
+		referencedData: o,
+		sortingOrder: i,
+		engineKey: s,
+		role: c
+	}, Q, "handleDimensionAddForEngineKey");
+	if (!p) return {
+		success: !1,
+		errorMessage: m
+	};
+	let h = l(a, s);
+	if (!h) return {
+		success: !1,
+		errorMessage: `Field with engine key ${s} not found`
+	};
+	let g = i ?? [], { newReferencedData: _, newDimension: v, newSorting: y } = ar(h, c, o, g, t, u);
+	Q.debug("[handleDimensionAddForEngineKey] adding new dimension", {
+		newDimension: v,
+		oldSorting: g,
+		newSorting: y,
+		newReferencedData: _
+	});
+	let b = [...structuredClone(t), v], { dimensions: x, measures: S } = A(b, n, r, {
+		type: M.ENABLE,
+		dataItemId: P(v.dataItem)
+	}, { alternateSettings: f }), C = d?.({
+		dimensions: x,
+		measures: S
+	});
+	return Q.debug("[handleDimensionAddForEngineKey] new dimension created", {
+		newDimension: v,
+		newDimensions: b,
+		adjustedDimensions: x,
+		adjustedMeasures: S,
+		newColoring: C
+	}), q(e, {
+		referencedData: _,
+		dimensions: x,
+		measures: S,
+		querySettings: { sortingOrder: y },
+		...C ? { coloring: C } : {}
+	}), {
+		success: !0,
+		data: v
+	};
+}, $r = (e, t, n, r, i, a = [], o, s, c, l) => {
+	Q.info("handleDimensionRemove input", {
+		dimensions: t,
+		dataItemId: i,
+		sortingOrder: a,
+		coloringSideEffectsFn: s
+	});
+	let { success: u, errorMessage: d } = J(F.object({
+		dimensions: F.array(U),
+		measures: F.array(W),
+		chartType: F.string(),
+		dataItemId: Array.isArray(i) ? F.array(V) : V,
+		sortingOrder: G.shape.sortingOrder
+	}), {
+		dimensions: t,
+		measures: n,
+		chartType: r,
+		dataItemId: i,
+		sortingOrder: a
+	}, Q, "handleDimensionRemove");
+	if (!u) return {
+		success: !1,
+		errorMessage: d
+	};
+	let f = Array.isArray(i) ? i : [i], p = structuredClone(t).filter((e) => !f.includes(P(e.dataItem))), m = structuredClone(a).filter((e) => e.dataItem === null || !f.includes(P(e.dataItem))), h = structuredClone(c)?.filter((e) => !f.includes(P(e.dataItem))), g = o?.dimensionIdx ?? null;
+	if (g !== null) {
+		let e = t[g];
+		if (!(0, Xr.default)(e, p[g])) {
+			let t = p.findIndex((t) => (0, Xr.default)(t, e));
+			g = t === -1 ? null : t;
+		}
+	}
+	let { dimensions: _, measures: v } = A(p, n, r, { type: M.FIX_STATE }, { alternateSettings: l }), y = s?.({
+		dimensions: _,
+		measures: v
+	});
+	return Q.debug("[handleDimensionRemove] removing dimension(s)", {
+		newDimensions: p,
+		adjustedDimensions: _,
+		adjustedMeasures: v,
+		newSorting: m,
+		newColoring: y
+	}), q(e, {
+		dimensions: _,
+		measures: v,
+		querySettings: {
+			sortingOrder: m,
+			topN: {
+				...o,
+				dimensionIdx: g
+			}
+		},
+		...y ? { coloring: y } : {},
+		grid: h
+	}), { success: !0 };
+}, ei = (e, t, n, r, i) => {
+	Q.info("handleDimensionChangeForDataItemId input", {
+		dimensions: t,
+		dataItemId: n,
+		changes: r,
+		coloringSideEffectsFn: i
+	});
+	let { success: a, errorMessage: o } = J(F.object({
+		dimensions: F.array(U),
+		dataItemId: V,
+		changes: F.object({
+			customLabel: F.object({
+				enabled: F.boolean(),
+				value: F.string().optional()
+			}).optional(),
+			showNullValues: F.boolean().optional()
+		})
+	}), {
+		dimensions: t,
+		dataItemId: n,
+		changes: r
+	}, Q, "handleDimensionChangeForDataItemId");
+	if (!a) return {
+		success: !1,
+		errorMessage: o
+	};
+	let s = structuredClone(t).map((e) => {
+		if (P(e.dataItem) === n) {
+			let t = structuredClone(e);
+			return r.customLabel !== void 0 && r.customLabel !== null && (t.customLabel = {
+				enabled: r.customLabel.enabled,
+				value: r.customLabel.value
+			}), r.showNullValues !== void 0 && r.showNullValues !== null && (t.showNullValues = r.showNullValues), t;
+		}
+		return e;
+	}), c = i?.({ dimensions: s });
+	return Q.debug("[handleDimensionChangeForDataItemId] updating dimension", {
+		newDimensions: s,
+		newColoring: c
+	}), q(e, {
+		dimensions: s,
+		...c ? { coloring: c } : {}
+	}), { success: !0 };
+}, ti = (e, t, n, r, i, a, o, s = !1, c) => {
+	Q.info("handleDimensionToggle input", {
+		dimensions: t,
+		dataItemId: i,
+		enabled: a,
+		coloringSideEffectsFn: o,
+		fixStateOnDisable: s
+	});
+	let { success: l, errorMessage: u } = J(F.object({
+		dimensions: F.array(U),
+		measures: F.array(W),
+		chartType: F.string(),
+		dataItemId: V,
+		enabled: F.boolean()
+	}), {
+		dimensions: t,
+		measures: n,
+		chartType: r,
+		dataItemId: i,
+		enabled: a
+	}, Q, "handleDimensionToggle");
+	if (!l) return {
+		success: !1,
+		errorMessage: u
+	};
+	if (i === null) return {
+		success: !1,
+		errorMessage: "Data item ID is required"
+	};
+	let d = structuredClone(t), { dimensions: f, measures: p } = A(d, n, r, {
+		type: a ? M.ENABLE : M.DISABLE,
+		dataItemId: i
+	}, {
+		fixStateOnDisable: s,
+		alternateSettings: c
+	}), m = o?.({
+		dimensions: f,
+		measures: p
+	});
+	return Q.debug("[handleDimensionToggle] updating dimension", {
+		newDimensions: d,
+		adjustedDimensions: f,
+		adjustedMeasures: p,
+		newColoring: m
+	}), q(e, {
+		dimensions: f,
+		measures: p,
+		...m ? { coloring: m } : {}
+	}), { success: !0 };
+}, ni = (e, t, n, r, i, a, o, s) => {
+	Q.info("handleToggleDimensionsByNames input", {
+		dimensions: t,
+		name: i,
+		enabled: a,
+		coloringSideEffectsFn: o
+	});
+	let c = t.filter((e) => e.label === i);
+	if (c.length === 0) return Q.info("[handleToggleDimensionsByNames] No matching dimensions found, nothing to toggle", { name: i }), { success: !0 };
+	let l = [];
+	c.forEach((e) => {
+		let i = P(e.dataItem), c = a === void 0 ? !e.enabled : a;
+		l.push((e, a) => ti(e, a.dimensions ?? t, a.measures ?? n, r, i, c, o, !1, s));
+	});
+	let u = Y(l);
+	return u.success ? (Q.debug("[handleToggleDimensionsByNames] updated dimensions", { newDimensions: u.vSpecPartial.dimensions }), q(e, u.vSpecPartial), { success: !0 }) : {
+		success: !1,
+		errorMessage: u?.errorMessage
+	};
+}, ri = (e, t, n, r, i, a, o, s) => {
+	Q.info("handleDimensionDuplicate input", {
+		dimensions: t,
+		dataItemId: i,
+		coloringSideEffectsFn: a,
+		sortingOrder: s
+	});
+	let { success: c, errorMessage: l } = J(F.object({
+		dimensions: F.array(U),
+		measures: F.array(W),
+		chartType: F.string(),
+		dataItemId: Array.isArray(i) ? F.array(V) : V,
+		sortingOrder: G.shape.sortingOrder.optional()
+	}), {
+		dimensions: t,
+		measures: n,
+		chartType: r,
+		dataItemId: i,
+		sortingOrder: s
+	}, Q, "handleDimensionDuplicate");
+	if (!c) return {
+		success: !1,
+		errorMessage: l
+	};
+	let u = Array.isArray(i) ? i : [i], d = structuredClone(t), f = u.map((e) => d.find((t) => P(t.dataItem) === e)).filter((e) => e !== void 0).map((e) => {
+		let t = structuredClone(e);
+		return t.dataItem.uniqueSignature = E(), t;
+	}), p = [...d, ...f], m = s ? [...s, ...f.map((e, t) => $n(e, s.length === 0 && t === 0))] : void 0;
+	Q.debug("[handleDimensionDuplicate] duplicating dimension(s)", {
+		newDimensions: p,
+		newSorting: m
+	});
+	let h = structuredClone(p), g = structuredClone(n);
+	for (let e of f) {
+		let { dimensions: t, measures: i } = A(h, n, r, {
+			type: M.ENABLE,
+			dataItemId: P(e.dataItem)
+		}, { alternateSettings: o });
+		h = t, g = i;
+	}
+	let _ = a?.({
+		dimensions: h,
+		measures: g
+	});
+	return Q.debug("[handleDimensionDuplicate] adjusted dimensions", {
+		newDimensions: p,
+		newDimensionsAfterAdjustment: h,
+		newColoring: _
+	}), q(e, {
+		dimensions: h,
+		measures: g,
+		...m ? { querySettings: { sortingOrder: m } } : {},
+		..._ ? { coloring: _ } : {}
+	}), { success: !0 };
+}, ii = (e, n, r, i = [], a, o, s) => {
+	Q.info("handleDimensionFieldChange input", {
+		dimensions: n,
+		dataItemId: r,
+		newField: o,
+		sortingOrder: i,
+		coloringSideEffectsFn: s
+	});
+	let { success: c, errorMessage: l } = J(F.object({
+		dimensions: F.array(U),
+		dataItemId: V,
+		newField: jt
+	}), {
+		dimensions: n,
+		dataItemId: r,
+		newField: o
+	}, Q, "handleDimensionFieldChange");
+	if (!c) return {
+		success: !1,
+		errorMessage: l
+	};
+	let u = n.findIndex((e) => P(e.dataItem) === r), d = i.findIndex((e) => P(e.dataItem) === r), { key: f, newReferencedData: p } = Se(a, o), m = ve(structuredClone(n).map((e) => P(e.dataItem) === r ? {
+		...e,
+		label: Pe(o),
+		description: t(o),
+		dataItem: Oe(o, f)
+	} : e)), h = s?.({ dimensions: m }), g = m[u], _ = [...i];
+	return d > -1 && (_[d] = $n(g, i[d]?.enabled)), Q.debug("[handleDimensionFieldChange] updating dimension", {
+		newReferencedData: p,
+		newDimensions: m,
+		newColoring: h
+	}), q(e, {
+		referencedData: p,
+		dimensions: m,
+		...h ? { coloring: h } : {},
+		querySettings: { sortingOrder: _ }
+	}), {
+		success: !0,
+		data: g
+	};
+}, ai = Ie("histogram-data-handlers", "#76ff03");
+function oi(e, t, n, r, i, o, s, c, l) {
+	ai.info("handleHistogramDimensionAdd input", { field: s });
+	let { success: u, errorMessage: d } = J(F.object({
+		dimensions: F.array(U),
+		measures: F.array(W),
+		sortingOrder: G.shape.sortingOrder,
+		field: jt
+	}), {
+		dimensions: t,
+		measures: n,
+		sortingOrder: o,
+		field: s
+	}, ai, "handleHistogramDimensionAdd");
+	if (!u) return {
+		success: !1,
+		errorMessage: d
+	};
+	let f = s;
+	if (N(s)) {
+		let { fieldKey: e, schema: t = "", view: n, name: r, resultType: i } = s.dimension ?? {};
+		f = {
+			key: e,
+			schema: t,
+			view: n,
+			name: r,
+			dataType: i === void 0 ? void 0 : a[i],
+			aggregators: []
+		};
+	}
+	let p = [(e, a) => Zr(e, t, n, r, i, a.querySettings?.sortingOrder ?? o ?? [], s, void 0, nr(s), l)], h = Y(p);
+	if (!h.success) return {
+		success: !1,
+		errorMessage: h.errorMessage
+	};
+	let g = h.results[0], _ = g?.success ? g.data : void 0;
+	p = [(e) => wr(e, [], h.vSpecPartial?.dimensions, r, h.vSpecPartial?.querySettings?.sortingOrder ?? o ?? [], h.vSpecPartial?.referencedData ?? i, m(f), void 0, c, "COUNT", void 0, l)];
+	let v = Y(p);
+	return v.success ? (q(e, v.vSpecPartial), {
+		success: !0,
+		data: _
+	}) : {
+		success: !1,
+		errorMessage: v.errorMessage
+	};
+}
+function si(e, t, n, r, i, a, o, c, l, u, d, f) {
+	ai.info("handleHistogramDimensionRemove input", { dataItemId: i });
+	let { success: p, errorMessage: h } = J(F.object({ dataItemId: Array.isArray(i) ? F.array(V) : V }), { dataItemId: i }, ai, "handleHistogramDimensionRemove");
+	if (!p) return {
+		success: !1,
+		errorMessage: h
+	};
+	let g = [];
+	g.push((e, a) => $r(e, t, n, r, i, a.querySettings?.sortingOrder ?? l ?? [], u, d, a.grid ?? f));
+	let _ = Y(g), v = _.vSpecPartial.dimensions, y = _.vSpecPartial.measures;
+	if (!v || !y) return {
+		success: !1,
+		errorMessage: "Removing the dimension did not produce updated dimensions and measures"
+	};
+	if (g = [], v.length > 0) {
+		let e = v.find((e) => T(e));
+		if (e) {
+			let t = s(a, o, e.dataItem.internalKey);
+			if (!t) return {
+				success: !1,
+				errorMessage: `No data field found for internal key ${e.dataItem.internalKey}`
+			};
+			g.push((e) => wr(e, [], v, r, _.vSpecPartial?.querySettings?.sortingOrder ?? l ?? [], o, m(t), void 0, c, "COUNT", void 0, d));
+		} else {
+			let e = y.map((e) => P(e.dataItem));
+			g.push((t) => Er(t, y, v, r, e, _.vSpecPartial?.querySettings?.sortingOrder ?? l ?? [], void 0, d, f));
+		}
+	} else {
+		let e = y.map((e) => P(e.dataItem));
+		g.push((t) => Er(t, y, v, r, e, _.vSpecPartial?.querySettings?.sortingOrder ?? l ?? [], void 0, d, f));
+	}
+	let b = Y(g);
+	return b.success ? (q(e, b.vSpecPartial), { success: !0 }) : {
+		success: !1,
+		errorMessage: b.errorMessage
+	};
+}
+var ci = (e, t, n, r, i, a, o, c, l, u) => {
+	ai.info("handleHistogramDimensionToggle input", {
+		dataItemId: i,
+		enabled: a
+	});
+	let { success: d, errorMessage: f } = J(F.object({
+		dimensions: F.array(U),
+		measures: F.array(W),
+		chartType: F.string(),
+		dataItemId: V,
+		enabled: F.boolean()
+	}), {
+		dimensions: t,
+		measures: n,
+		chartType: r,
+		dataItemId: i,
+		enabled: a
+	}, ai, "handleHistogramDimensionToggle");
+	if (!d) return {
+		success: !1,
+		errorMessage: f
+	};
+	let p = [];
+	p.push((e) => ti(e, t, n, r, i, a, u));
+	let h = Y(p);
+	if (!h.success) return {
+		success: !1,
+		errorMessage: h.errorMessage
+	};
+	let g = h.vSpecPartial.dimensions, _ = h.vSpecPartial.measures;
+	if (!g || !_) return {
+		success: !1,
+		errorMessage: "Toggling the dimension did not produce updated dimensions and measures"
+	};
+	p = [];
+	let v = g.find((e) => T(e));
+	if (v) {
+		let e = s(o, c, v.dataItem.internalKey);
+		if (!e) return {
+			success: !1,
+			errorMessage: `No data field found for internal key ${v.dataItem.internalKey}`
+		};
+		p.push((t) => wr(t, [], g, r, h.vSpecPartial?.querySettings?.sortingOrder ?? [], c, m(e), void 0, l, "COUNT", void 0, u));
+	} else {
+		let e = _.map((e) => P(e.dataItem));
+		p.push((i) => Er(i, n, t, r, e, h.vSpecPartial?.querySettings?.sortingOrder ?? [], void 0, u));
+	}
+	let y = Y(p);
+	return y.success ? (q(e, y.vSpecPartial), { success: !0 }) : {
+		success: !1,
+		errorMessage: y.errorMessage
+	};
+}, $ = Ie("line-chart-data-handlers", "#76ff03"), li = (e, t, n, r, i, a, o, s, c, l, u, d) => {
+	$.info("handleLineChartDimensionAddForEngineKey input", { engineKey: s });
+	let f = Y([(e) => Qr(e, t, n, r, i, a, o, s, c, l, u, d)]);
+	if (!f.success) return {
+		success: !1,
+		errorMessage: f.errorMessage
+	};
+	let p = f.vSpecPartial?.dimensions ?? t;
+	if (!w(p.filter(T))) {
+		let e = k(f.vSpecPartial?.measures ?? n);
+		f.vSpecPartial = {
+			...f.vSpecPartial,
+			measures: e
+		};
+	}
+	q(e, f.vSpecPartial);
+	let m = new Set(t.map((e) => P(e.dataItem))), h = p.find((e) => !m.has(P(e.dataItem)));
+	return h ? {
+		success: !0,
+		data: h
+	} : {
+		success: !1,
+		errorMessage: "Line dimension add did not create a dimension."
+	};
+}, ui = (e, t, n, r, i, a, o, s, c, l) => {
+	$.info("handleLineChartDimensionRemove input", { dataItemId: i });
+	let u = Y([(e) => $r(e, t, n, r, i, a, o, s, c, l)]);
+	if (!u.success) return {
+		success: !1,
+		errorMessage: u.errorMessage
+	};
+	if (!w((u.vSpecPartial?.dimensions ?? t).filter(T))) {
+		let e = k(u.vSpecPartial?.measures ?? n);
+		u.vSpecPartial = {
+			...u.vSpecPartial,
+			measures: e
+		};
+	}
+	return q(e, u.vSpecPartial), { success: !0 };
+}, di = (e, t, n, r, i, a, o, s = !1, c) => {
+	$.info("handleLineChartDimensionToggle input", {
+		dataItemId: i,
+		enabled: a
+	});
+	let l = Y([(e) => ti(e, t, n, r, i, a, o, s, c)]);
+	if (!l.success) return {
+		success: !1,
+		errorMessage: l.errorMessage
+	};
+	if (!w((l.vSpecPartial?.dimensions ?? t).filter(T))) {
+		let e = k(l.vSpecPartial?.measures ?? n);
+		l.vSpecPartial = {
+			...l.vSpecPartial,
+			measures: e
+		};
+	}
+	return q(e, l.vSpecPartial), { success: !0 };
+}, fi = (e, t, n, r, i, a, o, s) => {
+	$.info("handleLineChartDimensionDuplicate input", { dataItemId: i });
+	let c = Y([(e) => ri(e, t, n, r, i, a, o, s)]);
+	if (!c.success) return {
+		success: !1,
+		errorMessage: c.errorMessage
+	};
+	if (!w((c.vSpecPartial?.dimensions ?? t).filter(T))) {
+		let e = k(c.vSpecPartial?.measures ?? n);
+		c.vSpecPartial = {
+			...c.vSpecPartial,
+			measures: e
+		};
+	}
+	return q(e, c.vSpecPartial), { success: !0 };
+}, pi = (e, t, n, r, i, a, o, s, c, l, u, d, f, p, m) => {
+	$.info("handleLineChartMeasureAddForEngineKey input", { engineKey: s });
+	let h = Y([(e) => Tr(e, t, n, r, i, a, o, s, c, l, u, d, f, p, m, ae)]);
+	if (!h.success) return {
+		success: !1,
+		errorMessage: h.errorMessage
+	};
+	if (!w((h.vSpecPartial?.dimensions ?? n).filter(T))) {
+		let e = k(h.vSpecPartial?.measures ?? t);
+		h.vSpecPartial = {
+			...h.vSpecPartial,
+			measures: e
+		};
+	}
+	q(e, h.vSpecPartial);
+	let g = h.vSpecPartial?.measures ?? t, _ = new Set(t.map((e) => P(e.dataItem))), v = g.find((e) => !_.has(P(e.dataItem)));
+	return v ? {
+		success: !0,
+		data: v
+	} : {
+		success: !1,
+		errorMessage: "Line measure add did not create a measure."
+	};
+}, mi = (e, t, n, r, i, a, o, s, c, l) => {
+	$.info("handleLineChartMeasureRemove input", { dataItemId: i });
+	let u = Y([(e) => Er(e, t, n, r, i, a, o, s, c, l)]);
+	if (!u.success) return {
+		success: !1,
+		errorMessage: u.errorMessage
+	};
+	if (!w((u.vSpecPartial?.dimensions ?? n).filter(T))) {
+		let e = k(u.vSpecPartial?.measures ?? t);
+		u.vSpecPartial = {
+			...u.vSpecPartial,
+			measures: e
+		};
+	}
+	return q(e, u.vSpecPartial), { success: !0 };
+}, hi = (e, t, n, r, i, a, o, s, c = !1, l) => {
+	$.info("handleLineChartMeasureToggle input", {
+		dataItemId: a,
+		enabled: o
+	});
+	let u = Y([(e) => Or(e, t, n, r, i, a, o, s, c, l)]);
+	if (!u.success) return {
+		success: !1,
+		errorMessage: u.errorMessage
+	};
+	if (!w((u.vSpecPartial?.dimensions ?? n).filter(T))) {
+		let e = k(u.vSpecPartial?.measures ?? t);
+		u.vSpecPartial = {
+			...u.vSpecPartial,
+			measures: e
+		};
+	}
+	return q(e, u.vSpecPartial), { success: !0 };
+}, gi = (e, t, n, r, i, a, o, s) => {
+	$.info("handleLineChartMeasureDuplicate input", { dataItemId: i });
+	let c = Y([(e) => Ar(e, t, n, r, i, a, o, s)]);
+	if (!c.success) return {
+		success: !1,
+		errorMessage: c.errorMessage
+	};
+	if (!w((c.vSpecPartial?.dimensions ?? n).filter(T))) {
+		let e = k(c.vSpecPartial?.measures ?? t);
+		c.vSpecPartial = {
+			...c.vSpecPartial,
+			measures: e
+		};
+	}
+	return q(e, c.vSpecPartial), { success: !0 };
+}, _i = class extends Ke {};
+export { _r as $, en as $t, Vr as A, dt as An, Bn as At, Pr as B, Xe as Bn, hn as Bt, Mr as C, vt as Cn, In as Ct, Wr as D, ht as Dn, zn as Dt, Kr as E, gt as En, Rn as Et, Lr as F, R as Fn, Cn as Ft, Jr as G, cn as Gt, zr as H, Je as Hn, _n as Ht, Ar as I, L as In, Sn as It, X as J, sn as Jt, kr as K, ln as Kt, jr as L, tt as Ln, yn as Lt, Fr as M, z as Mn, Hn as Mt, Ir as N, at as Nn, Tn as Nt, Gr as O, B as On, Un as Ot, Rr as P, it as Pn, wn as Pt, vr as Q, $t as Qt, qr as R, $e as Rn, vn as Rt, Tr as S, _t as Sn, Fn as St, Br as T, yt as Tn, Ln as Tt, Nr as U, qe as Un, mn as Ut, Er as V, Ye as Vn, pn as Vt, Or as W, gn as Wt, xr as X, W as Xt, yr as Y, tn as Yt, Sr as Z, on as Zt, ii as _, V as _n, Mn as _t, di as a, Kt as an, sr as at, ni as b, xt as bn, Nn as bt, mi as c, Ht as cn, $n as ct, si as d, It as dn, q as dt, Zt as en, Y as et, ci as f, Pt as fn, qn as ft, ri as g, wt as gn, kn as gt, ei as h, jt as hn, On as ht, ui as i, Wt as in, lr as it, Hr as j, pt as jn, Vn as jt, Ur as k, ft as kn, Wn as kt, hi as l, Vt as ln, er as lt, Qr as m, Mt as mn, Gn as mt, li as n, Jt as nn, ur as nt, pi as o, Gt as on, ar as ot, Zr as p, Nt as pn, Kn as pt, Cr as q, nn as qt, fi as r, qt as rn, fr as rt, gi as s, Ut as sn, nr as st, _i as t, Qt as tn, mr as tt, oi as u, U as un, J as ut, $r as v, Dt as vn, An as vt, Dr as w, mt as wn, Dn as wt, wr as x, bt as xn, Pn as xt, ti as y, Tt as yn, jn as yt, Yr as z, Ze as zn, G as zt };