@tissuumaps/core 0.1.0-beta.0

package/dist/index.js

@@ -0,0 +1,3091 @@
+import { rgb } from "d3-color";
+import { mat3, vec2 } from "gl-matrix";
+import { interpolateBlues, interpolateBrBG, interpolateBuGn, interpolateBuPu, interpolateCividis, interpolateCool, interpolateCubehelixDefault, interpolateGnBu, interpolateGreens, interpolateGreys, interpolateInferno, interpolateMagma, interpolateOrRd, interpolateOranges, interpolatePRGn, interpolatePiYG, interpolatePlasma, interpolatePuBu, interpolatePuBuGn, interpolatePuOr, interpolatePuRd, interpolatePurples, interpolateRainbow, interpolateRdBu, interpolateRdGy, interpolateRdPu, interpolateRdYlBu, interpolateRdYlGn, interpolateReds, interpolateSinebow, interpolateSpectral, interpolateTurbo, interpolateViridis, interpolateWarm, interpolateYlGn, interpolateYlGnBu, interpolateYlOrBr, interpolateYlOrRd, schemeAccent, schemeCategory10, schemeDark2, schemeObservable10, schemePaired, schemePastel1, schemePastel2, schemeSet1, schemeSet2, schemeSet3, schemeTableau10 } from "d3-scale-chromatic";
+//#region src/model/primitives.ts
+/** The marker shapes that points can be rendered as */
+var Marker = {
+	Cross: 0,
+	Diamond: 1,
+	Square: 2,
+	TriangleUp: 3,
+	Star: 4,
+	Clobber: 5,
+	Disc: 6,
+	HBar: 7,
+	VBar: 8,
+	TailedArrow: 9,
+	TriangleDown: 10,
+	Ring: 11,
+	X: 12,
+	Arrow: 13,
+	Gaussian: 14
+};
+//#endregion
+//#region src/model/constants.ts
+/** Identity similarity transform */
+var identityTransform = {
+	flip: false,
+	scale: 1,
+	rotation: 0,
+	translation: {
+		x: 0,
+		y: 0
+	}
+};
+/**
+* Default seed of random configurations (see `RandomConfig`), used when a
+* configuration does not specify one
+*/
+var defaultRandomSeed = 0;
+/** Default label color */
+var defaultLabelColor = {
+	r: 255,
+	g: 255,
+	b: 255
+};
+/** ID of the default color palette for random label colors */
+var defaultLabelColorPalette = "distinct";
+/** Default label visibility */
+var defaultLabelVisibility = true;
+/** Default label opacity */
+var defaultLabelOpacity = 1;
+/** Default point marker */
+var defaultPointMarker = Marker.Disc;
+/** Default point size */
+var defaultPointSize = 1;
+/** Default coordinate space in which point sizes are specified */
+var defaultPointSizeUnit = "data";
+/** Default point color */
+var defaultPointColor = {
+	r: 255,
+	g: 255,
+	b: 255
+};
+/** Default point visibility */
+var defaultPointVisibility = true;
+/** Default point opacity */
+var defaultPointOpacity = 1;
+/** Default shape visibility */
+var defaultShapeVisibility = true;
+/** Default shape opacity */
+var defaultShapeOpacity = 1;
+/** Default shape fill color */
+var defaultShapeFillColor = {
+	r: 255,
+	g: 255,
+	b: 255
+};
+/** Default shape fill visibility */
+var defaultShapeFillVisibility = true;
+/** Default shape fill opacity */
+var defaultShapeFillOpacity = 1;
+/** Default shape stroke color */
+var defaultShapeStrokeColor = {
+	r: 0,
+	g: 0,
+	b: 0
+};
+/** Default shape stroke visibility */
+var defaultShapeStrokeVisibility = true;
+/** Default shape stroke opacity */
+var defaultShapeStrokeOpacity = 1;
+//#endregion
+//#region src/model/base.ts
+/**
+* Default values for {@link RawModel}
+*/
+var modelDefaults = {};
+/**
+* Creates a {@link Model} from a {@link RawModel} by applying {@link modelDefaults}
+*
+* @param rawModel - The raw model
+* @returns The complete model with default values applied
+*/
+function createModel(rawModel) {
+	return {
+		...structuredClone(modelDefaults),
+		...structuredClone(rawModel)
+	};
+}
+/**
+* Default values for {@link RawDataObject}
+*/
+var dataObjectDefaults = {};
+/**
+* Creates a {@link DataObject} from a {@link RawDataObject} by applying {@link dataObjectDefaults}
+*
+* @param rawDataObject - The raw data object
+* @returns The complete data object with default values applied
+*/
+function createDataObject(rawDataObject) {
+	return {
+		...createModel(rawDataObject),
+		...structuredClone(dataObjectDefaults),
+		...structuredClone(rawDataObject),
+		dataSource: createDataSource(rawDataObject.dataSource)
+	};
+}
+/**
+* Default values for {@link RawRenderedDataObject}
+*/
+var renderedDataObjectDefaults = {
+	visibility: true,
+	opacity: 1,
+	transform: identityTransform
+};
+/**
+* Creates a {@link RenderedDataObject} from a {@link RawRenderedDataObject} by applying {@link renderedDataObjectDefaults}
+*
+* @param rawRenderedDataObject - The raw rendered data object
+* @returns The complete rendered data object with default values applied
+*/
+function createRenderedDataObject(rawRenderedDataObject) {
+	return {
+		...createDataObject(rawRenderedDataObject),
+		...structuredClone(renderedDataObjectDefaults),
+		...structuredClone(rawRenderedDataObject)
+	};
+}
+/**
+* Default values for {@link RawRenderedRasterDataObject}
+*/
+var renderedRasterDataObjectDefaults = {};
+/**
+* Creates a {@link RenderedRasterDataObject} from a {@link RawRenderedRasterDataObject} by applying {@link renderedRasterDataObjectDefaults}
+*
+* @param rawRenderedRasterDataObject - The raw rendered raster data object
+* @returns The complete rendered raster data object with default values applied
+*/
+function createRenderedRasterDataObject(rawRenderedRasterDataObject) {
+	return {
+		...createRenderedDataObject(rawRenderedRasterDataObject),
+		...structuredClone(renderedRasterDataObjectDefaults),
+		...structuredClone(rawRenderedRasterDataObject)
+	};
+}
+/**
+* Default values for {@link RawRenderedItemsDataObject}
+*/
+var renderedItemsDataObjectDefaults = {};
+/**
+* Creates a {@link RenderedItemsDataObject} from a {@link RawRenderedItemsDataObject} by applying {@link renderedItemsDataObjectDefaults}
+*
+* @param rawRenderedItemsDataObject - The raw rendered items data object
+* @returns The complete rendered items data object with default values applied
+*/
+function createRenderedItemsDataObject(rawRenderedItemsDataObject) {
+	return {
+		...createRenderedDataObject(rawRenderedItemsDataObject),
+		...structuredClone(renderedItemsDataObjectDefaults),
+		...structuredClone(rawRenderedItemsDataObject)
+	};
+}
+/**
+* Default values for {@link RawDataSource}
+*/
+var dataSourceDefaults = {};
+/**
+* Creates a {@link DataSource} from a {@link RawDataSource} by applying {@link dataSourceDefaults}
+*
+* @param rawDataSource - The raw data source
+* @returns The complete data source with default values applied
+*/
+function createDataSource(rawDataSource) {
+	return {
+		...createModel(rawDataSource),
+		...structuredClone(dataSourceDefaults),
+		...structuredClone(rawDataSource)
+	};
+}
+/**
+* Default values for {@link RawAnnotatedDataSource}
+*/
+var annotatedDataSourceDefaults = {};
+/**
+* Creates an {@link AnnotatedDataSource} from a {@link RawAnnotatedDataSource} by applying {@link annotatedDataSourceDefaults}
+*
+* @param rawAnnotatedDataSource - The raw annotated data source
+* @returns The complete annotated data source with default values applied
+*/
+function createAnnotatedDataSource(rawAnnotatedDataSource) {
+	return {
+		...createDataSource(rawAnnotatedDataSource),
+		...structuredClone(annotatedDataSourceDefaults),
+		...structuredClone(rawAnnotatedDataSource)
+	};
+}
+//#endregion
+//#region src/model/configs.ts
+/**
+* Determines the active source of the given {@link Config}
+*
+* If a source is explicitly prioritized using {@link Config.source}, that source is returned.
+*
+* Otherwise, the active source is determined by checking for the presence of configuration-specific fields in the following order:
+* - {@link ConstantConfig}
+* - {@link FromConfig}
+* - {@link GroupByConfig}
+* - {@link RandomConfig}
+*
+* @param config - The configuration
+* @returns The active configuration source, or `undefined` if none is active
+*/
+function getActiveConfigSource(config) {
+	if (config.source !== void 0) return config.source;
+	if (isConstantConfig(config)) return "constant";
+	if (isFromConfig(config)) return "from";
+	if (isGroupByConfig(config)) return "groupBy";
+	if (isRandomConfig(config)) return "random";
+}
+/**
+* Determines whether the given object is a {@link ConstantConfig}
+*
+* @param obj - The object to check
+* @returns Whether the object is a {@link ConstantConfig}
+*/
+function isConstantConfig(obj) {
+	return obj.constant !== void 0;
+}
+/**
+* Determines whether the given object is a {@link FromConfig}
+*
+* @param obj - The object to check
+* @returns Whether the object is a {@link FromConfig}
+*/
+function isFromConfig(obj) {
+	return obj.from !== void 0;
+}
+/**
+* Determines whether the given object is a {@link GroupByConfig}
+*
+* @param obj - The object to check
+* @returns Whether the object is a {@link GroupByConfig}
+*/
+function isGroupByConfig(obj) {
+	return obj.groupBy !== void 0;
+}
+/**
+* Determines whether the given object is a {@link RandomConfig}
+*
+* @param obj - The object to check
+* @returns Whether the object is a {@link RandomConfig}
+*/
+function isRandomConfig(obj) {
+	return obj.random !== void 0;
+}
+//#endregion
+//#region src/model/image.ts
+/**
+* How the channels of multi-channel image data are displayed
+*
+* - `composite`: all visible channels, blended in their colors
+* - `grayscale`: the active channel alone, in gray
+* - `color`: the active channel alone, in its color
+*/
+var ImageChannelViewMode = {
+	composite: "composite",
+	grayscale: "grayscale",
+	color: "color"
+};
+/**
+* Default values for {@link RawImage}
+*/
+var imageDefaults = {
+	channelViewMode: ImageChannelViewMode.composite,
+	activeChannel: 0
+};
+/**
+* Creates an {@link Image} from a {@link RawImage} by applying {@link imageDefaults}
+*
+* @param rawImage - The raw image
+* @returns The complete image with default values applied
+*/
+function createImage(rawImage) {
+	return {
+		...createRenderedRasterDataObject(rawImage),
+		...structuredClone(imageDefaults),
+		...structuredClone(rawImage),
+		dataSource: createImageDataSource(rawImage.dataSource)
+	};
+}
+/**
+* Default values for {@link RawImageDataSource}
+*/
+var imageDataSourceDefaults = {};
+/**
+* Creates an {@link ImageDataSource} from a {@link RawImageDataSource} by applying {@link imageDataSourceDefaults}
+*
+* @param rawImageDataSource - The raw image data source
+* @returns The complete image data source with default values applied
+*/
+function createImageDataSource(rawImageDataSource) {
+	return {
+		...createDataSource(rawImageDataSource),
+		...structuredClone(imageDataSourceDefaults),
+		...structuredClone(rawImageDataSource)
+	};
+}
+//#endregion
+//#region src/model/labels.ts
+/**
+* Default values for {@link RawLabels}
+*/
+var labelsDefaults = {
+	labelColor: { random: { palette: defaultLabelColorPalette } },
+	labelVisibility: { constant: { value: true } },
+	labelOpacity: { constant: { value: 1 } }
+};
+/**
+* Creates a {@link Labels} from a {@link RawLabels} by applying {@link labelsDefaults}
+*
+* @param rawLabels - The raw labels
+* @returns The complete labels with default values applied
+*/
+function createLabels(rawLabels) {
+	return {
+		...createRenderedRasterDataObject(rawLabels),
+		...structuredClone(labelsDefaults),
+		...structuredClone(rawLabels),
+		dataSource: createLabelsDataSource(rawLabels.dataSource)
+	};
+}
+/**
+* Default values for {@link RawLabelsDataSource}
+*/
+var labelsDataSourceDefaults = {};
+/**
+* Creates a {@link LabelsDataSource} from a {@link RawLabelsDataSource} by applying {@link labelsDataSourceDefaults}
+*
+* @param rawLabelsDataSource - The raw labels data source
+* @returns The complete labels data source with default values applied
+*/
+function createLabelsDataSource(rawLabelsDataSource) {
+	return {
+		...createAnnotatedDataSource(rawLabelsDataSource),
+		...structuredClone(labelsDataSourceDefaults),
+		...structuredClone(rawLabelsDataSource)
+	};
+}
+//#endregion
+//#region src/model/layer.ts
+/**
+* Default values for {@link RawLayer}
+*/
+var layerDefaults = {
+	transform: identityTransform,
+	visibility: true,
+	opacity: 1,
+	pointSizeFactor: 1
+};
+/**
+* Creates a {@link Layer} from a {@link RawLayer} by applying {@link layerDefaults}
+*
+* @param rawLayer - The raw layer
+* @returns The complete layer with default values applied
+*/
+function createLayer(rawLayer) {
+	return {
+		...createModel(rawLayer),
+		...structuredClone(layerDefaults),
+		...structuredClone(rawLayer)
+	};
+}
+//#endregion
+//#region src/model/points.ts
+/**
+* Default values for {@link RawPoints}
+*/
+var pointsDefaults = {
+	pointMarker: { constant: { value: defaultPointMarker } },
+	pointSize: { constant: { value: 1 } },
+	pointColor: { constant: { value: defaultPointColor } },
+	pointVisibility: { constant: { value: true } },
+	pointOpacity: { constant: { value: 1 } },
+	pointSizeFactor: 1
+};
+/**
+* Creates a {@link Points} from a {@link RawPoints} by applying {@link pointsDefaults}
+*
+* @param rawPoints - The raw points
+* @returns The complete points with default values applied
+*/
+function createPoints(rawPoints) {
+	return {
+		...createRenderedItemsDataObject(rawPoints),
+		...structuredClone(pointsDefaults),
+		...structuredClone(rawPoints),
+		dataSource: createPointsDataSource(rawPoints.dataSource)
+	};
+}
+/**
+* Default values for {@link RawPointsDataSource}
+*/
+var pointsDataSourceDefaults = {};
+/**
+* Creates a {@link PointsDataSource} from a {@link RawPointsDataSource} by applying {@link pointsDataSourceDefaults}
+*
+* @param rawPointsDataSource - The raw points data source
+* @returns The complete points data source with default values applied
+*/
+function createPointsDataSource(rawPointsDataSource) {
+	return {
+		...createAnnotatedDataSource(rawPointsDataSource),
+		...structuredClone(pointsDataSourceDefaults),
+		...structuredClone(rawPointsDataSource)
+	};
+}
+//#endregion
+//#region src/model/shapes.ts
+/**
+* Default values for {@link RawShapes}
+*/
+var shapesDefaults = {
+	shapeVisibility: { constant: { value: true } },
+	shapeOpacity: { constant: { value: 1 } },
+	shapeFillColor: { constant: { value: defaultShapeFillColor } },
+	shapeFillVisibility: { constant: { value: true } },
+	shapeFillOpacity: { constant: { value: 1 } },
+	shapeStrokeColor: { constant: { value: defaultShapeStrokeColor } },
+	shapeStrokeVisibility: { constant: { value: true } },
+	shapeStrokeOpacity: { constant: { value: 1 } }
+};
+/**
+* Creates a {@link Shapes} from a {@link RawShapes} by applying {@link shapesDefaults}
+*
+* @param rawShapes - The raw shapes
+* @returns The complete shapes with default values applied
+*/
+function createShapes(rawShapes) {
+	return {
+		...createRenderedItemsDataObject(rawShapes),
+		...structuredClone(shapesDefaults),
+		...structuredClone(rawShapes),
+		dataSource: createShapesDataSource(rawShapes.dataSource)
+	};
+}
+/**
+* Default values for {@link RawShapesDataSource}
+*/
+var shapesDataSourceDefaults = {};
+/**
+* Creates a {@link ShapesDataSource} from a {@link RawShapesDataSource} by applying {@link shapesDataSourceDefaults}
+*
+* @param rawShapesDataSource - The raw shapes data source
+* @returns The complete shapes data source with default values applied
+*/
+function createShapesDataSource(rawShapesDataSource) {
+	return {
+		...createAnnotatedDataSource(rawShapesDataSource),
+		...structuredClone(shapesDataSourceDefaults),
+		...structuredClone(rawShapesDataSource)
+	};
+}
+//#endregion
+//#region src/model/table.ts
+/**
+* Default values for {@link RawTable}
+*/
+var tableDefaults = {};
+/**
+* Creates a {@link Table} from a {@link RawTable} by applying {@link tableDefaults}
+*
+* @param rawTable - The raw table
+* @returns The complete table with default values applied
+*/
+function createTable(rawTable) {
+	return {
+		...createDataObject(rawTable),
+		...structuredClone(tableDefaults),
+		...structuredClone(rawTable),
+		dataSource: createTableDataSource(rawTable.dataSource)
+	};
+}
+/**
+* Default values for {@link RawTableDataSource}
+*/
+var tableDataSourceDefaults = {};
+/**
+* Creates a {@link TableDataSource} from a {@link RawTableDataSource} by applying {@link tableDataSourceDefaults}
+*
+* @param rawTableDataSource - The raw table data source
+* @returns The complete table data source with default values applied
+*/
+function createTableDataSource(rawTableDataSource) {
+	return {
+		...createDataSource(rawTableDataSource),
+		...structuredClone(tableDataSourceDefaults),
+		...structuredClone(rawTableDataSource)
+	};
+}
+//#endregion
+//#region src/model/project.ts
+/**
+* Default values for {@link RawProject}
+*/
+var projectDefaults = {
+	markerMaps: [],
+	sizeMaps: [],
+	colorMaps: [],
+	visibilityMaps: [],
+	opacityMaps: [],
+	osOptions: {
+		viewerOptions: {
+			minZoomImageRatio: 0,
+			maxZoomPixelRatio: Infinity,
+			preserveImageSizeOnResize: true,
+			visibilityRatio: 0,
+			animationTime: 0,
+			gestureSettingsMouse: { flickEnabled: false },
+			gestureSettingsTouch: { flickEnabled: false },
+			gestureSettingsPen: { flickEnabled: false },
+			gestureSettingsUnknown: { flickEnabled: false },
+			zoomPerClick: 1,
+			showNavigator: true,
+			navigatorPosition: "BOTTOM_LEFT",
+			maxImageCacheCount: 2e3,
+			showNavigationControl: false,
+			imageSmoothingEnabled: false
+		},
+		viewerAnimationStartOptions: {
+			immediateRender: false,
+			imageLoaderLimit: 1
+		},
+		viewerAnimationFinishOptions: { immediateRender: true }
+	},
+	glOptions: {
+		pointsRenderOptions: { globalPointSizeFactor: 1 },
+		shapesRenderOptions: {
+			strokeWidth: 1,
+			edgesPerScanline: 8,
+			binWidthFactor: 1,
+			shapePadding: .2
+		}
+	},
+	viewerBackgroundColor: {
+		r: 0,
+		g: 0,
+		b: 0
+	}
+};
+/**
+* Creates a {@link Project} from a {@link RawProject} by applying {@link projectDefaults}
+*
+* @param rawProject - The raw project
+* @returns The complete project with default values applied
+*/
+function createProject(rawProject) {
+	return {
+		...createModel(rawProject),
+		...structuredClone(projectDefaults),
+		...structuredClone(rawProject),
+		osOptions: {
+			viewerOptions: {
+				...projectDefaults.osOptions.viewerOptions,
+				...rawProject.osOptions?.viewerOptions
+			},
+			viewerAnimationStartOptions: {
+				...projectDefaults.osOptions.viewerAnimationStartOptions,
+				...rawProject.osOptions?.viewerAnimationStartOptions
+			},
+			viewerAnimationFinishOptions: {
+				...projectDefaults.osOptions.viewerAnimationFinishOptions,
+				...rawProject.osOptions?.viewerAnimationFinishOptions
+			}
+		},
+		glOptions: {
+			pointsRenderOptions: {
+				...projectDefaults.glOptions.pointsRenderOptions,
+				...rawProject.glOptions?.pointsRenderOptions
+			},
+			shapesRenderOptions: {
+				...projectDefaults.glOptions.shapesRenderOptions,
+				...rawProject.glOptions?.shapesRenderOptions
+			}
+		},
+		layers: rawProject.layers?.map(createLayer) ?? [],
+		images: rawProject.images?.map(createImage) ?? [],
+		labels: rawProject.labels?.map(createLabels) ?? [],
+		points: rawProject.points?.map(createPoints) ?? [],
+		shapes: rawProject.shapes?.map(createShapes) ?? [],
+		tables: rawProject.tables?.map(createTable) ?? []
+	};
+}
+//#endregion
+//#region src/utils/NumberUtils.ts
+/**
+* Utility methods for coercing untrusted values to numbers
+*
+* Numbers, bigints and non-blank strings are accepted; everything else, and
+* everything that does not coerce to a finite number, is rejected. The
+* `tryParse*` methods report rejection by returning `undefined`, the `parse*`
+* methods by throwing.
+*/
+var NumberUtils = class NumberUtils {
+	static _minSafeBigInt = BigInt(Number.MIN_SAFE_INTEGER);
+	static _maxSafeBigInt = BigInt(Number.MAX_SAFE_INTEGER);
+	/**
+	* Parses a value as a finite number
+	*
+	* @param value - The value to parse
+	* @returns The parsed number
+	* @throws Error if the value is not a finite number
+	*/
+	static parseFinite(value) {
+		const v = NumberUtils.tryParseFinite(value);
+		if (v === void 0) throw new Error(`Value is not a finite number: ${String(value)}`);
+		return v;
+	}
+	/**
+	* Parses a value as a safe integer
+	*
+	* @param value - The value to parse
+	* @returns The parsed integer
+	* @throws Error if the value is not a safe integer
+	*/
+	static parseSafeInt(value) {
+		const v = NumberUtils.tryParseSafeInt(value);
+		if (v === void 0) throw new Error(`Value is not a safe integer: ${String(value)}`);
+		return v;
+	}
+	/**
+	* Parses a value as a finite number, without throwing
+	*
+	* A bigint outside of the safe integer range loses precision when converted:
+	* by default this is only warned about, `requireSafeBigInt` rejects it.
+	*
+	* @param value - The value to parse
+	* @param options - Set `requireSafeBigInt` to reject bigints that are outside
+	* of the safe integer range, rather than converting them with a warning
+	* @returns The parsed number, or `undefined` if the value is not a finite
+	* number
+	*/
+	static tryParseFinite(value, options) {
+		let v;
+		if (typeof value === "number") v = value;
+		else if (typeof value === "bigint") {
+			if (value < NumberUtils._minSafeBigInt || value > NumberUtils._maxSafeBigInt) {
+				if (options?.requireSafeBigInt) return;
+				console.warn(`Value ${value} is outside the safe integer range`);
+			}
+			v = Number(value);
+		} else if (typeof value === "string" && value.trim() !== "") v = Number(value);
+		else return;
+		return Number.isFinite(v) ? v : void 0;
+	}
+	/**
+	* Parses a value as a safe integer, without throwing
+	*
+	* @param value - The value to parse
+	* @returns The parsed integer, or `undefined` if the value is not a safe
+	* integer
+	*/
+	static tryParseSafeInt(value) {
+		const v = NumberUtils.tryParseFinite(value, { requireSafeBigInt: true });
+		if (v === void 0) return;
+		return Number.isSafeInteger(v) ? v : void 0;
+	}
+};
+//#endregion
+//#region src/utils/ArrayUtils.ts
+/**
+* Utility methods for converting arrays to the types the storage API holds
+*/
+var ArrayUtils = class ArrayUtils {
+	/**
+	* Converts item IDs to an `IDArray`
+	*
+	* Integer typed arrays, string arrays and 64-bit float arrays holding safe
+	* integers are returned as they are. Any other array has to hold either
+	* strings only, which are copied into a string array, or safe integers only,
+	* which are copied into 64-bit floats. Numeric strings are not parsed:
+	* whether `"12"` is an ID or a number is up to the data provider. An empty
+	* array yields an empty unsigned 32-bit integer array.
+	*
+	* @param values - The IDs to convert
+	* @returns The IDs as an integer typed array, a 64-bit float array or a
+	* string array
+	* @throws Error if a value is neither a string nor a safe integer, or if
+	* strings and integers are mixed
+	*/
+	static toIDArray(values) {
+		if (ArrayUtils._isIntOrUintArray(values)) return values;
+		if (values.length === 0) return /* @__PURE__ */ new Uint32Array(0);
+		if (typeof values[0] === "string") {
+			const ids = Array.isArray(values) ? values : Array.from(values);
+			for (const id of ids) if (typeof id !== "string") throw new Error(`ID is not a string: ${String(id)}`);
+			return ids;
+		}
+		const ids = values instanceof Float64Array ? values : new Float64Array(values.length);
+		for (let i = 0; i < values.length; i++) {
+			const id = values[i];
+			if (typeof id !== "number" || !Number.isSafeInteger(id)) throw new Error(`ID is not a safe integer: ${String(id)}`);
+			ids[i] = id;
+		}
+		return ids;
+	}
+	/**
+	* Tells whether an array is an integer typed array of at most 32 bits
+	*/
+	static _isIntOrUintArray(values) {
+		return values instanceof Int8Array || values instanceof Int16Array || values instanceof Int32Array || values instanceof Uint8Array || values instanceof Uint8ClampedArray || values instanceof Uint16Array || values instanceof Uint32Array;
+	}
+	/**
+	* Converts 64-bit integers to 64-bit floats
+	*
+	* @param values - The integers, as read from a file (e.g. a `BigInt64Array`)
+	* @returns The integers as floats
+	* @throws Error if an integer is outside the safe integer range
+	*/
+	static parseSafeInts(values) {
+		return Float64Array.from(values, (v) => NumberUtils.parseSafeInt(v));
+	}
+};
+//#endregion
+//#region src/utils/AsyncUtils.ts
+/**
+* Utility methods for running large CPU workloads on the main thread without
+* blocking the UI, by cooperatively yielding to the event loop
+*/
+var AsyncUtils = class AsyncUtils {
+	static _messageChannel;
+	static _pendingResolvers = [];
+	/**
+	* Yields control back to the event loop, allowing the browser to paint and
+	* process input before resuming.
+	*
+	* Uses the native `scheduler.yield()` when available, otherwise falls back to
+	* a shared `MessageChannel` (a macrotask without `setTimeout`'s clamping).
+	*
+	* @returns A promise that resolves once the event loop has been yielded to
+	*/
+	static yield() {
+		const scheduler = globalThis.scheduler;
+		if (typeof scheduler?.yield === "function") return scheduler.yield();
+		if (AsyncUtils._messageChannel === void 0) {
+			AsyncUtils._messageChannel = new MessageChannel();
+			AsyncUtils._messageChannel.port1.onmessage = () => {
+				AsyncUtils._pendingResolvers.shift()?.();
+			};
+		}
+		return new Promise((resolve) => {
+			AsyncUtils._pendingResolvers.push(resolve);
+			AsyncUtils._messageChannel.port2.postMessage(void 0);
+		});
+	}
+	/**
+	* Creates a time-sliced yielder for loops whose iterations are too coarse or
+	* heterogeneous for {@link AsyncUtils.forEach} (e.g. nested loops).
+	*
+	* Call the returned function at safe points inside a loop: it checks the
+	* abort signal on every call for fail-fast cancellation, and additionally
+	* yields to the event loop once the time budget since the last yield is
+	* exceeded. When within budget and not aborted, it is a cheap no-op.
+	*
+	* @param options - Optional time (ms) to run before yielding
+	* @returns The yielder, which takes an optional abort signal
+	*/
+	static createYielder(options) {
+		const { yieldMs = 5 } = options ?? {};
+		let start = performance.now();
+		return async (opts) => {
+			const { signal } = opts ?? {};
+			signal?.throwIfAborted();
+			if (performance.now() - start > yieldMs) {
+				await AsyncUtils.yield();
+				signal?.throwIfAborted();
+				start = performance.now();
+			}
+		};
+	}
+	/**
+	* Invokes `callback(item, index)` for every element of `items`, yielding to
+	* the event loop whenever the time budget is exceeded so the UI stays
+	* responsive.
+	*
+	* The abort signal is checked up front and after every yield, preserving
+	* fail-fast cancellation: an abort rejects with the signal's reason and no
+	* further iterations run.
+	*
+	* @param items - The array-like collection to iterate over
+	* @param callback - Synchronous work to perform for each `item` and its `index`
+	* @param options - Optional abort signal, time (ms) to run before yielding
+	*   (`yieldMs`), and the number of iterations between budget checks
+	*   (`checkEvery`)
+	* @returns A promise that resolves once every item has been visited, or
+	*   rejects with the signal's reason
+	*/
+	static async forEach(items, callback, options) {
+		const { signal, yieldMs, checkEvery = 1024 } = options ?? {};
+		signal?.throwIfAborted();
+		const maybeYield = AsyncUtils.createYielder({ yieldMs });
+		for (let i = 0; i < items.length; i++) {
+			callback(items[i], i);
+			if ((i + 1) % checkEvery === 0 && i + 1 < items.length) await maybeYield({ signal });
+		}
+	}
+	/**
+	* Returns a promise that resolves or rejects with the given `promise`, but
+	* rejects early if the given `signal` is aborted.
+	*
+	* @param promise - The promise to race against the abort signal
+	* @param options - Optional abort signal to race against the promise
+	* @returns A promise that resolves or rejects based on the race condition
+	*/
+	static async raceSignal(promise, options) {
+		const { signal } = options ?? {};
+		if (signal === void 0) return promise;
+		signal.throwIfAborted();
+		return new Promise((resolve, reject) => {
+			const onAbort = () => reject(signal.reason);
+			signal.addEventListener("abort", onAbort, { once: true });
+			promise.then((value) => {
+				signal.removeEventListener("abort", onAbort);
+				resolve(value);
+			}, (error) => {
+				signal.removeEventListener("abort", onAbort);
+				reject(error);
+			});
+		});
+	}
+	/**
+	* Creates a promise together with the functions that resolve and reject it,
+	* like `Promise.withResolvers()`, which is not yet widely available.
+	*
+	* @returns The promise and the functions that resolve and reject it
+	*/
+	static withResolvers() {
+		let resolve;
+		let reject;
+		return {
+			promise: new Promise((resolvePromise, rejectPromise) => {
+				resolve = resolvePromise;
+				reject = rejectPromise;
+			}),
+			resolve,
+			reject
+		};
+	}
+};
+//#endregion
+//#region src/utils/BitUtils.ts
+/** Utility methods for bitwise operations that yield unsigned 32-bit results */
+var BitUtils = class {
+	/**
+	* Performs a bitwise AND, returning an unsigned 32-bit result
+	*
+	* @param a - First operand
+	* @param b - Second operand
+	* @returns The result, as an unsigned 32-bit integer
+	*/
+	static safeAnd(a, b) {
+		return (a & b) >>> 0;
+	}
+	/**
+	* Performs a bitwise OR, returning an unsigned 32-bit result
+	*
+	* @param a - First operand
+	* @param b - Second operand
+	* @returns The result, as an unsigned 32-bit integer
+	*/
+	static safeOr(a, b) {
+		return (a | b) >>> 0;
+	}
+	/**
+	* Performs a bitwise XOR, returning an unsigned 32-bit result
+	*
+	* @param a - First operand
+	* @param b - Second operand
+	* @returns The result, as an unsigned 32-bit integer
+	*/
+	static safeXor(a, b) {
+		return (a ^ b) >>> 0;
+	}
+	/**
+	* Performs a bitwise NOT, returning an unsigned 32-bit result
+	*
+	* @param a - The operand
+	* @returns The result, as an unsigned 32-bit integer
+	*/
+	static safeNot(a) {
+		return ~a >>> 0;
+	}
+	/**
+	* Performs a left shift, returning an unsigned 32-bit result
+	*
+	* @param value - The value to shift
+	* @param shift - Number of bit positions to shift
+	* @returns The result, as an unsigned 32-bit integer
+	*/
+	static safeLeftShift(value, shift) {
+		return value << shift >>> 0;
+	}
+	/**
+	* Performs an unsigned right shift
+	*
+	* @param value - The value to shift
+	* @param shift - Number of bit positions to shift
+	* @returns The result, as an unsigned 32-bit integer
+	*/
+	static safeRightShift(value, shift) {
+		return value >>> shift;
+	}
+};
+//#endregion
+//#region src/utils/HashUtils.ts
+/**
+* Utility methods for non-cryptographic hashing
+*
+* Hashing a string is split into two steps: {@link hashRaw} reduces the
+* string to a 32-bit integer, and {@link mix} scrambles that integer together
+* with a seed. Callers that hash the same key repeatedly with different seeds
+* can cache the raw hash and only re-run the cheap mixing step. {@link hash}
+* does both in one call.
+*
+* The underlying primitives, {@link fnv1a} and {@link fmix32}, are exposed
+* for callers that need the plain algorithms without the seeding convention
+* of the methods above.
+*/
+var HashUtils = class HashUtils {
+	static _murmur3Config = {
+		s1: 16,
+		m1: 2246822507,
+		s2: 13,
+		m2: 3266489909,
+		s3: 16
+	};
+	/**
+	* Computes the raw hash of a string
+	*
+	* Currently {@link fnv1a}. The raw hash is fast and deterministic, but only
+	* weakly mixed: similar keys yield correlated hashes, and the hash of an
+	* empty string is non-zero. Pass the result through {@link mix} before
+	* using it to select from a small range.
+	*
+	* @param key - The string to hash; hashed by UTF-16 code unit
+	* @returns The raw hash, as a non-negative 32-bit integer
+	*/
+	static hashRaw(key) {
+		return HashUtils.fnv1a(key);
+	}
+	/**
+	* Scrambles a 32-bit integer with a seed
+	*
+	* The seed is XOR-ed into the value, which is then passed through
+	* {@link fmix32}. Consecutive inputs map to unrelated outputs, so the result
+	* is suitable for scattering sequential IDs or raw string hashes over a
+	* small range, e.g. `mix(id, seed) % palette.length`. Different seeds yield
+	* different outputs for the same input.
+	*
+	* @param h - The integer to mix; only its lower 32 bits are used
+	* @param seed - The seed; only its lower 32 bits are used
+	* @returns The mixed value, as a non-negative 32-bit integer
+	*/
+	static mix(h, seed = 0) {
+		return HashUtils.fmix32(h ^ seed);
+	}
+	/**
+	* Computes a seeded 32-bit hash of a string
+	*
+	* Equivalent to `mix(hashRaw(key), seed)`.
+	*
+	* @param key - The string to hash; hashed by UTF-16 code unit
+	* @param seed - The seed; only its lower 32 bits are used
+	* @returns The hash, as a non-negative 32-bit integer
+	*/
+	static hash(key, seed = 0) {
+		return HashUtils.mix(HashUtils.hashRaw(key), seed);
+	}
+	/**
+	* Computes the 32-bit FNV-1a hash of a string
+	*
+	* Iterates over the UTF-16 code units of the string, XOR-ing each into the
+	* running hash and multiplying by the FNV prime. The hash of an empty string
+	* is the FNV offset basis (`0x811c9dc5`). Code units above `0xff` are XOR-ed
+	* in whole rather than byte-wise, so results for non-Latin-1 text differ
+	* from byte-oriented FNV-1a implementations.
+	*
+	* @see http://www.isthe.com/chongo/tech/comp/fnv/
+	* @param str - The string to hash
+	* @returns The hash, as a non-negative 32-bit integer
+	*/
+	static fnv1a(str) {
+		let h = 2166136261;
+		for (let i = 0; i < str.length; i++) h = Math.imul(h ^ str.charCodeAt(i), 16777619);
+		return h >>> 0;
+	}
+	/**
+	* Applies a three-round xorshift-multiply finalizer; defaults to MurmurHash3's constants
+	*
+	* The finalizer is a bijective avalanche step: every input bit affects
+	* every output bit, and distinct 32-bit inputs map to distinct outputs.
+	* Note that `fmix32(0)` is `0`.
+	*
+	* @see https://github.com/aappleby/smhasher/blob/master/src/MurmurHash3.cpp
+	* @param h - The integer to finalize; only its lower 32 bits are used
+	* @param c - The constants to use; defaults are the MurmurHash3 finalizer constants
+	* @returns The finalized value, as a non-negative 32-bit integer
+	*/
+	static fmix32(h, c = HashUtils._murmur3Config) {
+		h ^= h >>> c.s1;
+		h = Math.imul(h, c.m1);
+		h ^= h >>> c.s2;
+		h = Math.imul(h, c.m2);
+		h ^= h >>> c.s3;
+		return h >>> 0;
+	}
+};
+//#endregion
+//#region src/utils/RandomUtils.ts
+/**
+* Utility methods for seeded, non-cryptographic pseudo-random numbers
+*
+* All methods except {@link seed} are deterministic: the same seed always
+* yields the same sequence, so callers can store a seed instead of the values
+* it produced (e.g. for reproducible random colors). None of the generators
+* are suitable for security-sensitive purposes.
+*
+* {@link createUint32RNG} returns a generator that draws one 32-bit integer
+* per call; {@link toUnitFloat32} maps such a draw to `[0, 1)`. The scalar
+* `rand*` methods take the first draw of a fresh generator, and the
+* `rand*Array` methods write consecutive draws of a fresh generator into a
+* typed array. Because they all consume the same stream,
+* `randUint32Array(n, seed)` starts with `randUint32(seed)`, and a longer
+* array has the shorter one as a prefix.
+*
+* Every `rand*` method takes either a seed or a generator as `seedOrRng`. A
+* seed creates a fresh generator; passing a generator draws from it instead,
+* which allows continuing one stream across several calls.
+*
+* The underlying generator, {@link splitmix32}, is exposed for callers that
+* need the plain algorithm regardless of the current default.
+*/
+var RandomUtils = class RandomUtils {
+	static _splitmix32Config = {
+		s1: 16,
+		m1: 569420461,
+		s2: 15,
+		m2: 1935289751,
+		s3: 15
+	};
+	/**
+	* Draws a random seed from `Math.random()`
+	*
+	* This is the one non-deterministic method of this class; use it to obtain
+	* a seed for the other methods when reproducibility is not required, e.g.
+	* for a "shuffle" action. The result is stored rather than the values it
+	* produces, so the draw can be reproduced later.
+	*
+	* @returns A uniformly distributed non-negative 32-bit integer
+	*/
+	static seed() {
+		return Math.random() * 4294967296 >>> 0;
+	}
+	/**
+	* Creates a seeded generator of 32-bit integers
+	*
+	* Currently {@link splitmix32}. Each call to the returned function yields
+	* the next value of the stream.
+	*
+	* @param seed - The seed; only its lower 32 bits are used
+	* @returns A function that returns the next non-negative 32-bit integer
+	*/
+	static createUint32RNG(seed = 0) {
+		return RandomUtils.splitmix32(seed);
+	}
+	/**
+	* Draws a 32-bit integer
+	*
+	* Given a seed, returns the first value of a fresh generator for it, i.e.
+	* `createUint32RNG(seed)()`. Note that this is a pure function of the seed:
+	* calling it repeatedly with the same seed returns the same value. Given a
+	* generator, returns its next value instead.
+	*
+	* @param seedOrRng - The seed (only its lower 32 bits are used), or the
+	* generator to draw from
+	* @returns A non-negative 32-bit integer
+	*/
+	static randUint32(seedOrRng = 0) {
+		return RandomUtils._toRNG(seedOrRng)();
+	}
+	/**
+	* Draws consecutive 32-bit integers into an array
+	*
+	* Given a seed, values come from a fresh generator for it, so the first
+	* element equals `randUint32(seed)`. Given a generator, its next `n` values
+	* are drawn instead, e.g. to continue one stream across several arrays. By
+	* default, a new array of length `n` is allocated; pass `array` to fill the
+	* first `n` elements of an existing array in place instead, leaving any
+	* further elements untouched.
+	*
+	* @param n - The number of values to draw, a non-negative integer
+	* @param seedOrRng - The seed (only its lower 32 bits are used), or the
+	* generator to draw from
+	* @param array - The array to fill; defaults to `new Uint32Array(n)`
+	* @returns The filled array, i.e. `array` if given
+	* @throws RangeError if `array` is given and holds fewer than `n` elements
+	*/
+	static randUint32Array(n, seedOrRng = 0, array = new Uint32Array(n)) {
+		if (n > array.length) throw new RangeError("array must hold at least n elements");
+		const rng = RandomUtils._toRNG(seedOrRng);
+		for (let i = 0; i < n; i++) array[i] = rng();
+		return array;
+	}
+	/**
+	* Maps a 32-bit integer to a float in `[0, 1)` that is exact in `float32`
+	*
+	* Uses the upper 24 bits of the integer, so the result is a multiple of
+	* `2^-24` and survives storage in a `Float32Array` without rounding. The
+	* largest possible result is `1 - 2^-24`; the lower 8 bits of the input are
+	* discarded.
+	*
+	* @param uint32 - The integer to map; only its lower 32 bits are used
+	* @returns A float in `[0, 1)`
+	*/
+	static toUnitFloat32(uint32) {
+		return (uint32 >>> 8) / 16777216;
+	}
+	/**
+	* Draws a float in `[0, 1)` that is exact in `float32`
+	*
+	* Equivalent to `toUnitFloat32(randUint32(seedOrRng))`. Given a seed, this
+	* is a pure function of it: calling it repeatedly with the same seed returns
+	* the same value. Given a generator, its next value is drawn instead.
+	*
+	* @param seedOrRng - The seed (only its lower 32 bits are used), or the
+	* generator to draw from
+	* @returns A float in `[0, 1)`, exact in `float32`
+	*/
+	static randUnitFloat32(seedOrRng = 0) {
+		return RandomUtils.toUnitFloat32(RandomUtils.randUint32(seedOrRng));
+	}
+	/**
+	* Draws consecutive floats in `[0, 1)` into an array
+	*
+	* Each element is `toUnitFloat32` of the corresponding element that
+	* {@link randUint32Array} would produce for the same arguments, and is
+	* stored in the `Float32Array` without rounding. Given a seed, values come
+	* from a fresh generator for it, so the first element equals
+	* `randUnitFloat32(seed)`. Given a generator, its next `n` values are drawn
+	* instead, e.g. to continue one stream across several arrays. By default, a
+	* new array of length `n` is allocated; pass `array` to fill the first `n`
+	* elements of an existing array in place instead, leaving any further
+	* elements untouched.
+	*
+	* @param n - The number of values to draw, a non-negative integer
+	* @param seedOrRng - The seed (only its lower 32 bits are used), or the
+	* generator to draw from
+	* @param array - The array to fill; defaults to `new Float32Array(n)`
+	* @returns The filled array, i.e. `array` if given
+	* @throws RangeError if `array` is given and holds fewer than `n` elements
+	*/
+	static randUnitFloat32Array(n, seedOrRng = 0, array = new Float32Array(n)) {
+		if (n > array.length) throw new RangeError("array must hold at least n elements");
+		const rng = RandomUtils._toRNG(seedOrRng);
+		for (let i = 0; i < n; i++) array[i] = RandomUtils.toUnitFloat32(rng());
+		return array;
+	}
+	/**
+	* Creates a SplitMix32 generator
+	*
+	* The state is a 32-bit counter advanced by the golden-ratio constant
+	* `0x9e3779b9` (a Weyl sequence); each output is the state passed through
+	* {@link HashUtils.fmix32} with the SplitMix32 constants. Since the
+	* finalizer is a bijection, the stream has a period of `2^32` and visits
+	* every 32-bit value exactly once per period. All seeds walk the same
+	* cycle; seeds that differ in their lower 32 bits start at different points.
+	*
+	* @see https://github.com/bryc/code/blob/master/jshash/PRNGs.md#splitmix32
+	* @param seed - The seed; only its lower 32 bits are used
+	* @returns A function that returns the next non-negative 32-bit integer
+	*/
+	static splitmix32(seed = 0) {
+		let h = seed >>> 0;
+		return () => {
+			h = h + 2654435769 >>> 0;
+			return HashUtils.fmix32(h, RandomUtils._splitmix32Config);
+		};
+	}
+	/**
+	* Resolves a seed or generator to a generator
+	*
+	* @param seedOrRng - A seed, or an existing generator
+	* @returns A fresh generator for the seed, or the given generator
+	*/
+	static _toRNG(seedOrRng) {
+		return typeof seedOrRng === "number" ? RandomUtils.createUint32RNG(seedOrRng) : seedOrRng;
+	}
+};
+//#endregion
+//#region src/utils/MathUtils.ts
+/**
+* Utility methods for numeric clamping, remapping, alignment, rounding,
+* medians, histograms and counts
+*/
+var MathUtils = class MathUtils {
+	/**
+	* Clamps a value to the range `[min, max]`
+	*
+	* @param value - The value to clamp
+	* @param min - Lower bound
+	* @param max - Upper bound
+	* @returns The clamped value
+	*/
+	static clamp(value, min, max) {
+		return Math.min(Math.max(min, value), max);
+	}
+	/**
+	* Linearly maps a value from one range to another
+	*
+	* Values outside `from` are extrapolated, not clamped; clamp at the call
+	* site where the domain is known. Swapping `from` and `to` yields the
+	* inverse mapping.
+	*
+	* @param value - The value to map
+	* @param from - The source range, as `[min, max]`, with `min !== max`
+	* @param to - The target range, as `[min, max]`
+	* @returns The mapped value
+	* @throws Error if `from` is degenerate
+	*/
+	static remap(value, from, to) {
+		const [fromMin, fromMax] = from;
+		const [toMin, toMax] = to;
+		if (fromMin === fromMax) throw new Error("from must not be degenerate");
+		return toMin + (value - fromMin) / (fromMax - fromMin) * (toMax - toMin);
+	}
+	/**
+	* Aligns a positive number `n` to the next multiple of `m`
+	*
+	* If `n` is already a multiple of `m`, returns `n`.
+	* Otherwise, returns the smallest multiple of `m` that is greater than `n`.
+	*
+	* @param n - The non-negative number to align
+	* @param m - The strictly positive multiple to align to
+	* @returns The aligned number
+	* @throws Error if `n` is negative, or if `m` is not strictly positive
+	*/
+	static align(n, m) {
+		if (n < 0) throw new Error("n must be non-negative");
+		if (m <= 0) throw new Error("m must be strictly positive");
+		if (n % m === 0) return n;
+		return Math.ceil(n / m) * m;
+	}
+	/**
+	* Rounds a value to the decimal places that a step needs
+	*
+	* Steps of `1` or more round to whole numbers, `0.1` to one decimal place,
+	* `0.05` to two. Stepping through a range adds floating-point noise that this
+	* rounds away, e.g. `0.30000000000000004` becomes `0.3` for a step of `0.1`.
+	*
+	* @param value - The value to round
+	* @param step - The strictly positive step
+	* @returns The rounded value
+	* @throws Error if `step` is not strictly positive
+	*/
+	static roundToStepDecimals(value, step) {
+		if (step <= 0) throw new Error("step must be strictly positive");
+		const decimals = Math.max(0, -Math.floor(Math.log10(step)));
+		return Number(value.toFixed(decimals));
+	}
+	/**
+	* Computes the weighted median of numeric values
+	*
+	* Returns the smallest value whose cumulative weight, in ascending order of
+	* the values, reaches half the total weight. If the total weight is zero,
+	* all values are weighted equally instead.
+	*
+	* @param values - The non-empty values to compute the weighted median of
+	* @param weights - The non-negative weight of each value
+	* @returns The weighted median
+	* @throws Error if `values` is empty, or if `weights` has a different length
+	*/
+	static computeWeightedMedian(values, weights) {
+		if (values.length === 0) throw new Error("values must not be empty");
+		if (weights.length !== values.length) throw new Error("weights must have the same length as values");
+		const order = new Uint32Array(values.length).map((_, i) => i);
+		order.sort((i, j) => values[i] - values[j]);
+		let totalWeight = 0;
+		for (let i = 0; i < weights.length; i++) totalWeight += weights[i];
+		const weighted = totalWeight > 0;
+		const halfWeight = .5 * (weighted ? totalWeight : values.length);
+		let cumulativeWeight = 0;
+		for (const i of order) {
+			cumulativeWeight += weighted ? weights[i] : 1;
+			if (cumulativeWeight >= halfWeight) return values[i];
+		}
+		return values[order[order.length - 1]];
+	}
+	/**
+	* Computes the range of numeric values, as their minimum and maximum
+	*
+	* Non-finite values (`NaN`, infinities) are ignored. If no finite value is
+	* found (e.g. for empty arrays), the empty range `[Infinity, -Infinity]` is
+	* returned; callers can detect it by checking that the lower bound exceeds
+	* the upper bound.
+	*
+	* The values are traversed on the main thread, yielding to the event loop
+	* periodically so the UI stays responsive for large arrays (see
+	* {@link AsyncUtils.forEach}). Aborting the signal rejects with its reason.
+	*
+	* @param values - The values to compute the range of
+	* @param options - Optional abort signal
+	* @returns A promise that resolves to the range, as `[min, max]`
+	*/
+	static async computeRange(values, options) {
+		const { signal } = options ?? {};
+		signal?.throwIfAborted();
+		let vmin = Infinity;
+		let vmax = -Infinity;
+		await AsyncUtils.forEach(values, (v) => {
+			if (Number.isFinite(v)) {
+				if (v < vmin) vmin = v;
+				if (v > vmax) vmax = v;
+			}
+		}, { signal });
+		return [vmin, vmax];
+	}
+	/**
+	* Computes the histogram of numeric values over a given value range
+	*
+	* `hist[i]` counts the values that are closest to bin `i`, with bins spread
+	* evenly over `range`: bin `0` maps to the range's lower bound, the last bin
+	* to its upper bound, and each bin in between to `vmin + i / (bins - 1) *
+	* (vmax - vmin)`. Values outside the range are counted in the nearest edge
+	* bin, non-finite values (`NaN`, infinities) are ignored. If the range is
+	* degenerate (upper bound not above lower bound), or if `bins` is `1`, all
+	* values fall into bin `0`.
+	*
+	* If `sample` is positive and smaller than the number of values, the
+	* histogram is estimated from `sample` values drawn uniformly with
+	* replacement, using the seeded generator of
+	* {@link RandomUtils.createUint32RNG}; the counts then sum to `sample`
+	* (minus ignored non-finite values) rather than to the number of values.
+	* Sampling is deterministic for a given `seed`. Otherwise, every value is
+	* counted exactly once.
+	*
+	* The values are traversed on the main thread, yielding to the event loop
+	* periodically so the UI stays responsive for large arrays (see
+	* {@link AsyncUtils.forEach}). Aborting the signal rejects with its reason.
+	*
+	* @param values - The values to compute the histogram of
+	* @param range - The value range the bins span, as `[min, max]`
+	* @param options - Optional abort signal (`signal`), number of bins
+	*   (`bins`, a positive integer, defaults to `1024`), number of values to
+	*   sample (`sample`; omitting it, `0`, or at least the number of values
+	*   disables sampling), and seed for sampling (`seed`, defaults to `0`)
+	* @returns A promise that resolves to the histogram, as bin counts (`hist`)
+	* and the given value range (`range`)
+	*/
+	static async computeHistogram(values, range, options) {
+		const { signal, bins = 1024, sample, seed = 0 } = options ?? {};
+		signal?.throwIfAborted();
+		const [vmin, vmax] = range;
+		const hist = new Array(bins).fill(0);
+		const scale = vmin < vmax ? (bins - 1) / (vmax - vmin) : 0;
+		const rng = sample !== void 0 && sample > 0 && sample < values.length ? RandomUtils.createUint32RNG(seed) : void 0;
+		await AsyncUtils.forEach({ length: Math.min(sample || values.length, values.length) }, (_, i) => {
+			const v = values[rng ? rng() % values.length : i];
+			if (Number.isFinite(v)) {
+				const bin = MathUtils.clamp(Math.round((v - vmin) * scale), 0, bins - 1);
+				hist[bin] += 1;
+			}
+		}, { signal });
+		return {
+			hist,
+			range
+		};
+	}
+	/**
+	* Redistributes the counts of a histogram over equal bins of another range
+	*
+	* The new bins split `range` into `bins` equal intervals, the upper bound
+	* counting in the last one. Each bin of `histogram` is counted in the new bin
+	* that its value falls into (see {@link computeHistogram}), or dropped if
+	* its value is outside `range`. If `range` is degenerate (upper bound not
+	* above lower bound), all counts fall into bin `0`.
+	*
+	* @param histogram - The histogram to redistribute, as bin counts (`hist`)
+	* and the value range they span (`range`)
+	* @param range - The value range the new bins span, as `[min, max]`
+	* @param bins - The number of new bins, a positive integer
+	* @returns The redistributed histogram, as the counts of the new bins
+	* (`hist`) and the given value range (`range`)
+	*/
+	static rebinHistogram(histogram, range, bins) {
+		const { hist: origHist, range: origRange } = histogram;
+		const [min, max] = range;
+		const lastHistogramBin = Math.max(origHist.length - 1, 1);
+		const hist = new Array(bins).fill(0);
+		if (min >= max) {
+			hist[0] = origHist.reduce((sum, count) => sum + count, 0);
+			return {
+				hist,
+				range
+			};
+		}
+		for (let i = 0; i < origHist.length; i++) {
+			const value = MathUtils.remap(i, [0, lastHistogramBin], origRange);
+			if (value >= min && value <= max) {
+				const bin = Math.floor(MathUtils.remap(value, range, [0, bins]));
+				hist[Math.min(bin, bins - 1)] += origHist[i];
+			}
+		}
+		return {
+			hist,
+			range
+		};
+	}
+	/**
+	* Counts the number of occurrences of every distinct value
+	*
+	* The counts are keyed by value, in the order the values first occur.
+	* Distinctness follows `Map` key equality, i.e. `NaN` counts as one value
+	* and `0` and `-0` as the same one.
+	*
+	* The values are traversed on the main thread, yielding to the event loop
+	* periodically so the UI stays responsive for large arrays (see
+	* {@link AsyncUtils.forEach}). Aborting the signal rejects with its reason.
+	*
+	* @typeParam T - Element type of the values
+	* @param values - The values to count
+	* @param options - Optional abort signal
+	* @returns A promise that resolves to the count of every distinct value, in
+	* the order the values first appear
+	*/
+	static async computeUniqueValueCounts(values, options) {
+		const { signal } = options ?? {};
+		signal?.throwIfAborted();
+		const counts = /* @__PURE__ */ new Map();
+		await AsyncUtils.forEach(values, (v) => {
+			counts.set(v, (counts.get(v) ?? 0) + 1);
+		}, { signal });
+		return counts;
+	}
+};
+//#endregion
+//#region src/utils/ColorUtils.ts
+/** Utility methods for color parsing, packing, and conversion */
+var ColorUtils = class {
+	/**
+	* Parses a text-based color palette into an array of colors
+	*
+	* Each non-empty line is expected to contain three numeric components
+	* separated by `sep`, scaled from `[0, maxValue]` to `[0, 255]`.
+	*
+	* @param str - Multi-line palette string
+	* @param options - Component separator (default `" "`) and maximum input
+	* value per component (default `1`)
+	* @returns The parsed colors, in the order of the palette's lines
+	* @throws Error if a non-empty line does not hold exactly three components
+	*/
+	static parsePalette(str, options) {
+		const { sep = " ", maxValue = 1 } = options ?? {};
+		return str.split("\n").filter((line) => line.trim().length > 0).map((line, i) => {
+			const values = line.split(sep);
+			if (values.length !== 3) throw new Error(`Invalid color palette line ${i}: ${line}`);
+			return {
+				r: Number(values[0]) / maxValue * 255,
+				g: Number(values[1]) / maxValue * 255,
+				b: Number(values[2]) / maxValue * 255
+			};
+		});
+	}
+	/**
+	* Samples a continuous color scheme into an array of colors
+	*
+	* The scheme is evaluated at `n` evenly spaced positions covering the whole
+	* `[0, 1]` range, both ends included.
+	*
+	* @param colorScheme - Maps a position within `[0, 1]` to a CSS color string
+	* @param n - Number of colors to sample, an integer of at least two
+	* @returns The sampled colors, in the order of the scheme
+	* @throws Error if `n` is not an integer of at least two, or if the scheme
+	* yields a color string that cannot be parsed
+	*/
+	static sampleColorScheme(colorScheme, n) {
+		if (!Number.isInteger(n) || n < 2) throw new Error(`Invalid color scheme size: ${n}`);
+		return Array.from({ length: n }, (_, i) => {
+			const spec = colorScheme(i / (n - 1));
+			const { r, g, b } = rgb(spec);
+			if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b)) throw new Error(`Invalid color scheme color: ${spec}`);
+			return {
+				r,
+				g,
+				b
+			};
+		});
+	}
+	/**
+	* Packs an RGB color into a single 24-bit integer, `0xBBGGRR`
+	*
+	* The red component occupies the lowest byte, so that the integer, when
+	* stored in host byte order on a little-endian host, matches the R, G, B byte
+	* order of a canvas `ImageData` buffer.
+	*
+	* @param color - The color to pack
+	* @returns The packed color, `0xBBGGRR`
+	*/
+	static packColor(color) {
+		return color.b << 16 | color.g << 8 | color.r;
+	}
+	/**
+	* Packs a visibility into the form that {@link withAlpha} folds into a color
+	*
+	* @param visibility - The visibility
+	* @returns `1` if visible, `0` if not
+	*/
+	static packVisibility(visibility) {
+		return visibility ? 1 : 0;
+	}
+	/**
+	* Packs an opacity into the form that {@link withAlpha} folds into a color
+	*
+	* @param opacity - The opacity, in the range [0, 1]; values outside are clamped
+	* @returns The opacity as an integer in the range [0, 255]
+	*/
+	static packOpacity(opacity) {
+		return MathUtils.clamp(Math.round(opacity * 255), 0, 255);
+	}
+	/**
+	* Folds a visibility and an opacity into the alpha channel of a packed color
+	*
+	* Combines the lower 24 bits of `color` (see {@link packColor}) with
+	* `opacity` as alpha if `visibility` is non-zero, and with zero alpha
+	* otherwise, into a packed 32-bit RGBA color, `0xAABBGGRR`.
+	*
+	* @param packedColor - The packed color, `0xBBGGRR`; any higher bits are discarded
+	* @param packedVisibility - The visibility, larger than `0` for visible
+	* @param packedOpacity - The opacity, in the range [0, 255]
+	* @returns The packed RGBA color, `0xAABBGGRR`, as an unsigned 32-bit integer
+	*/
+	static withAlpha(packedColor, packedVisibility, packedOpacity) {
+		const rgb = packedColor & 16777215;
+		if (packedVisibility > 0) return BitUtils.safeOr(rgb, BitUtils.safeLeftShift(packedOpacity, 24));
+		return rgb;
+	}
+	/**
+	* Parses a hex color string into a {@link Color}
+	*
+	* @param hex - A `#RRGGBB` hex string
+	* @returns The parsed color
+	* @throws Error if the string is not a valid 6-digit hex color
+	*/
+	static fromHex(hex) {
+		if (!/^#([0-9A-Fa-f]{6})$/.test(hex)) throw new Error(`Invalid hex color: ${hex}`);
+		return {
+			r: parseInt(hex.slice(1, 3), 16),
+			g: parseInt(hex.slice(3, 5), 16),
+			b: parseInt(hex.slice(5, 7), 16)
+		};
+	}
+	/**
+	* Formats a {@link Color} as a `#RRGGBB` hex string
+	*
+	* @param color - The color to format
+	* @returns The formatted hex string
+	*/
+	static toHex(color) {
+		return `#${Math.round(color.r).toString(16).padStart(2, "0")}${Math.round(color.g).toString(16).padStart(2, "0")}${Math.round(color.b).toString(16).padStart(2, "0")}`;
+	}
+	/**
+	* Checks whether two colors have identical RGB components
+	*
+	* Components are compared exactly, without rounding or tolerance.
+	*
+	* @param a - The first color
+	* @param b - The second color
+	* @returns `true` if all three components are equal, `false` otherwise
+	*/
+	static equals(a, b) {
+		return a.r === b.r && a.g === b.g && a.b === b.b;
+	}
+	/**
+	* Converts an HSB (HSV) color to RGB, following Java's `Color.HSBtoRGB`
+	*
+	* @param hue - The hue, in the range [0, 1) (values outside wrap around)
+	* @param saturation - The saturation, in the range [0, 1]
+	* @param brightness - The brightness, in the range [0, 1]
+	* @returns The RGB color, with integer components in the range [0, 255]
+	*/
+	static fromHSB(hue, saturation, brightness) {
+		const scale = (x) => Math.round(x * 255);
+		if (saturation === 0) {
+			const v = scale(brightness);
+			return {
+				r: v,
+				g: v,
+				b: v
+			};
+		}
+		const h = (hue - Math.floor(hue)) * 6;
+		const f = h - Math.floor(h);
+		const v = scale(brightness);
+		const p = scale(brightness * (1 - saturation));
+		const q = scale(brightness * (1 - saturation * f));
+		const t = scale(brightness * (1 - saturation * (1 - f)));
+		switch (Math.floor(h)) {
+			case 0: return {
+				r: v,
+				g: t,
+				b: p
+			};
+			case 1: return {
+				r: q,
+				g: v,
+				b: p
+			};
+			case 2: return {
+				r: p,
+				g: v,
+				b: t
+			};
+			case 3: return {
+				r: p,
+				g: q,
+				b: v
+			};
+			case 4: return {
+				r: t,
+				g: p,
+				b: v
+			};
+			default: return {
+				r: v,
+				g: p,
+				b: q
+			};
+		}
+	}
+};
+//#endregion
+//#region src/utils/ConfigUtils.ts
+/** Utility methods for property configurations */
+var ConfigUtils = class ConfigUtils {
+	/**
+	* Returns the group-to-value map that a configuration resolves its values
+	* from, if any
+	*
+	* Only an active `groupBy` source (see {@link getActiveConfigSource}) with a
+	* map ID resolves from a map. The map is returned as found in `maps`, rather
+	* than copied: maps are never mutated, as an edit replaces the map, so
+	* callers can detect an edit by comparing the returned maps by identity.
+	*
+	* @param config - The configuration
+	* @param maps - The project-global maps to look the referenced map up in
+	* @returns The map, or `undefined` if the configuration does not resolve
+	* from a map, or if the map it references does not exist
+	*/
+	static findGroupByMap(config, maps) {
+		if (getActiveConfigSource(config) === "groupBy" && isGroupByConfig(config) && config.groupBy.map !== void 0) return maps.find((map) => map.id === config.groupBy.map);
+	}
+	/**
+	* Returns the IDs of the maps that configurations refer to
+	*
+	* A configuration refers to its map whatever its active source, as switching
+	* back to `groupBy` uses the map again.
+	*
+	* @param configs - The configurations
+	* @returns The IDs of the referenced maps
+	*/
+	static getGroupByMapIds(configs) {
+		const mapIds = /* @__PURE__ */ new Set();
+		for (const config of configs) if (isGroupByConfig(config) && config.groupBy.map !== void 0) mapIds.add(config.groupBy.map);
+		return mapIds;
+	}
+	/**
+	* Creates the function that returns the value a group-by configuration
+	* assigns to a group
+	*
+	* With a map, a group takes its value in the map, else the map's default,
+	* else `defaultValue`; a map that does not exist gives every group
+	* `defaultValue`. Without a map, a group takes the palette value its name
+	* hashes to, or `defaultValue` if there is no palette.
+	*
+	* @param config - The group-by configuration
+	* @param map - The map the configuration refers to (see
+	* {@link findGroupByMap}), or `undefined` if it refers to none or the map
+	* does not exist
+	* @param defaultValue - The value of a group that nothing assigns one to
+	* @param palette - The values to pick from by hash if there is no map
+	* @returns The value of a group, by group name (the cell value as a string)
+	*/
+	static createGroupValueGetter(config, map, defaultValue, palette) {
+		if (config.groupBy.map !== void 0) {
+			if (map === void 0) return () => defaultValue;
+			const values = new Map(Object.entries(map.values));
+			const mapDefault = map.default ?? defaultValue;
+			return (group) => values.get(group) ?? mapDefault;
+		}
+		if (palette === void 0 || palette.length === 0) return () => defaultValue;
+		return (group) => palette[HashUtils.hash(group) % palette.length];
+	}
+	/**
+	* Returns the table column a configuration groups by
+	*
+	* @param config - The configuration
+	* @returns The column, or `undefined` if `groupBy` is not the active source
+	*/
+	static getGroupByColumn(config) {
+		return getActiveConfigSource(config) === "groupBy" && isGroupByConfig(config) ? config.groupBy : void 0;
+	}
+	/**
+	* Points a configuration at a map, grouping by a column
+	*
+	* The configuration keeps its other sources and the extra fields of its
+	* `groupBy` specification (e.g. a palette), so that switching back to them
+	* restores them. The unit of the active source, which only sizes have, is
+	* carried over, so that the values keep their scale. A configuration that
+	* already groups by the column with the map is returned as is, so that
+	* updating an object with it changes nothing.
+	*
+	* @param config - The configuration
+	* @param groupBy - The categorical table column to group by
+	* @param mapId - ID of the project-global map to take the group values from
+	* @returns The configuration, with `groupBy` as its active source
+	*/
+	static withGroupByMap(config, groupBy, mapId) {
+		const currentGroupBy = ConfigUtils.getGroupByColumn(config);
+		if (currentGroupBy !== void 0 && ConfigUtils.isSameTableColumn(currentGroupBy, groupBy) && isGroupByConfig(config) && config.groupBy.map === mapId) return config;
+		const prevGroupBy = isGroupByConfig(config) ? config.groupBy : void 0;
+		const unit = ConfigUtils.getUnit(config);
+		return {
+			...config,
+			source: "groupBy",
+			groupBy: {
+				...prevGroupBy,
+				...(unit !== void 0 || prevGroupBy?.unit !== void 0) && { unit },
+				table: groupBy.table,
+				column: groupBy.column,
+				map: mapId
+			}
+		};
+	}
+	/**
+	* Returns the unit of the active source of a configuration
+	*
+	* @param config - The configuration, of which only sizes have a unit
+	* @returns The unit, or `undefined` if the active source has none
+	*/
+	static getUnit(config) {
+		switch (getActiveConfigSource(config)) {
+			case "constant": return isConstantConfig(config) ? config.constant.unit : void 0;
+			case "from": return isFromConfig(config) ? config.from.unit : void 0;
+			case "groupBy": return isGroupByConfig(config) ? config.groupBy.unit : void 0;
+			default: return;
+		}
+	}
+	/**
+	* Determines whether two table column references point to the same column
+	*
+	* References without a table point to the column of `defaultTable`.
+	*
+	* @param tableColumnRef - The table column reference
+	* @param otherTableColumnRef - The table column reference to compare with
+	* @param defaultTable - ID of the table of references without a table
+	* @returns Whether both references point to the same column
+	*/
+	static isSameTableColumn(tableColumnRef, otherTableColumnRef, defaultTable) {
+		return (tableColumnRef.table ?? defaultTable) === (otherTableColumnRef.table ?? defaultTable) && tableColumnRef.column === otherTableColumnRef.column;
+	}
+};
+//#endregion
+//#region src/utils/GeometryUtils.ts
+/** Utility methods for rectangle and dimension geometry */
+var GeometryUtils = class {
+	/**
+	* Computes the union of multiple rectangles and returns the smallest rectangle that contains all of them
+	*
+	* @param rects - The rectangles to compute the union of
+	* @returns The smallest rectangle that contains all the input rectangles, or `null` if no rectangles are provided
+	*/
+	static union(...rects) {
+		return rects.reduce((union, rect) => {
+			if (union === null) return rect;
+			const x = Math.min(union.x, rect.x);
+			const y = Math.min(union.y, rect.y);
+			return {
+				x,
+				y,
+				width: Math.max(union.x + union.width, rect.x + rect.width) - x,
+				height: Math.max(union.y + union.height, rect.y + rect.height) - y
+			};
+		}, null);
+	}
+	/**
+	* Computes the intersection of two rectangles
+	*
+	* @param a - The first rectangle
+	* @param b - The second rectangle
+	* @returns The rectangle covered by both, or `null` if they do not overlap
+	* (touching edges do not count as overlapping)
+	*/
+	static intersection(a, b) {
+		const x = Math.max(a.x, b.x);
+		const y = Math.max(a.y, b.y);
+		const width = Math.min(a.x + a.width, b.x + b.width) - x;
+		const height = Math.min(a.y + a.height, b.y + b.height) - y;
+		if (width <= 0 || height <= 0) return null;
+		return {
+			x,
+			y,
+			width,
+			height
+		};
+	}
+	/**
+	* Grows a rectangle by the same amount on every side
+	*
+	* @param rect - The rectangle to grow
+	* @param amount - The amount to move every side outwards by; negative
+	* amounts shrink the rectangle
+	* @returns The grown rectangle
+	*/
+	static dilate(rect, amount) {
+		return {
+			x: rect.x - amount,
+			y: rect.y - amount,
+			width: rect.width + 2 * amount,
+			height: rect.height + 2 * amount
+		};
+	}
+	/**
+	* Checks if two dimensions are equal by comparing their width and height properties
+	*
+	* @param a - The first dimensions to compare
+	* @param b - The second dimensions to compare
+	* @returns `true` if the dimensions are equal, `false` otherwise
+	*/
+	static dimsEquals(a, b) {
+		return a.width === b.width && a.height === b.height;
+	}
+	/**
+	* Checks if two rectangles are equal by comparing their x, y, width, and height properties
+	*
+	* @param a - The first rectangle to compare
+	* @param b - The second rectangle to compare
+	* @returns `true` if the rectangles are equal, `false` otherwise
+	*/
+	static rectEquals(a, b) {
+		return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+	}
+};
+//#endregion
+//#region src/utils/ImageUtils.ts
+/** The integer typed arrays, with the bits and signedness of their type */
+var integerArrayTypes = [
+	[
+		Uint8Array,
+		8,
+		false
+	],
+	[
+		Uint8ClampedArray,
+		8,
+		false
+	],
+	[
+		Uint16Array,
+		16,
+		false
+	],
+	[
+		Uint32Array,
+		32,
+		false
+	],
+	[
+		Int8Array,
+		8,
+		true
+	],
+	[
+		Int16Array,
+		16,
+		true
+	],
+	[
+		Int32Array,
+		32,
+		true
+	]
+];
+/** Utility methods for resolving and defaulting image channel settings */
+var ImageUtils = class ImageUtils {
+	/**
+	* Returns the color of a channel
+	*
+	* The color configured on the image wins, then the one its data states, and
+	* the only channel of single-channel image data is white, as a grayscale
+	* image rather than in the red the index-based default would give it (see
+	* {@link ImageUtils.getDefaultChannelColor}).
+	*
+	* @param image - The image
+	* @param data - The image data providing the channel
+	* @param c - The channel index (0-based)
+	* @returns The channel's color
+	*/
+	static getChannelColor(image, data, c) {
+		return image.channels?.[c]?.color ?? data.getChannelColor?.(c) ?? (data.getSizeC() === 1 ? {
+			r: 255,
+			g: 255,
+			b: 255
+		} : ImageUtils.getDefaultChannelColor(c));
+	}
+	/**
+	* Returns the contrast limits of a channel
+	*
+	* The limits configured on the image win over those its data states.
+	* Channels with neither are stretched between quantile-based limits derived
+	* from their histogram (see {@link ImageUtils.getDefaultContrastLimits}), if
+	* the data provides one, and otherwise over the range the data declares for
+	* their data type.
+	*
+	* @param image - The image
+	* @param data - The image data providing the channel
+	* @param c - The channel index (0-based)
+	* @returns The channel's contrast limits, or `undefined` if the data
+	* provides neither limits, a histogram nor a data type range
+	*/
+	static getChannelContrastLimits(image, data, c) {
+		const histogram = data.getChannelHistogram?.(c);
+		return image.channels?.[c]?.contrastLimits ?? data.getChannelContrastLimits?.(c) ?? (histogram !== void 0 ? ImageUtils.getDefaultContrastLimits(histogram) : void 0) ?? data.getChannelDataTypeRange?.(c);
+	}
+	/**
+	* Returns the visibility of a channel
+	*
+	* The visibility configured on the image wins over the one its data states,
+	* and channels with neither are visible.
+	*
+	* @param image - The image
+	* @param data - The image data providing the channel
+	* @param c - The channel index (0-based)
+	* @returns Whether the channel is visible
+	*/
+	static getChannelVisibility(image, data, c) {
+		return image.channels?.[c]?.visibility ?? data.getChannelVisibility?.(c) ?? true;
+	}
+	/**
+	* Returns the opacity of a channel
+	*
+	* The opacity configured on the image wins over the one its data states,
+	* and channels with neither are fully opaque.
+	*
+	* @param image - The image
+	* @param data - The image data providing the channel
+	* @param c - The channel index (0-based)
+	* @returns The channel's opacity, in `[0, 1]`
+	*/
+	static getChannelOpacity(image, data, c) {
+		return image.channels?.[c]?.opacity ?? data.getChannelOpacity?.(c) ?? 1;
+	}
+	/**
+	* Returns the channel an image shows in the single-channel view modes
+	*
+	* The image's active channel is bounded to the channels the data has, so
+	* that an image kept from data with more channels still shows one.
+	*
+	* @param image - The image
+	* @param sizeC - The number of channels the image data has
+	* @returns The channel index (0-based)
+	*/
+	static getActiveChannel(image, sizeC) {
+		return MathUtils.clamp(image.activeChannel, 0, sizeC - 1);
+	}
+	/**
+	* Returns a default color for a channel, for use when no channel colors are
+	* known
+	*
+	* The first six channels map to red, green, blue, yellow, cyan, and magenta.
+	* Further channels are assigned hues 128 degrees apart, with saturation and
+	* brightness decreasing by 0.05 every ten channels. Channel indices wrap
+	* around after 100, so that saturation and brightness stay above 0.5.
+	* Colors are not guaranteed to be unique.
+	*
+	* Resembles `ImageChannel.getDefaultChannelColor` in QuPath v0.7.0, except
+	* that yellow, cyan, and magenta have been replaced by pure versions (255
+	* for the two highest components, 0 for the lowest), and that QuPath wraps
+	* after 360 channels instead, yielding dim colors and eventually black.
+	*
+	* @param c - The channel index, a non-negative integer
+	* @returns The default color for the channel
+	*/
+	static getDefaultChannelColor(c) {
+		c = c % 100;
+		switch (c) {
+			case 0: return {
+				r: 255,
+				g: 0,
+				b: 0
+			};
+			case 1: return {
+				r: 0,
+				g: 255,
+				b: 0
+			};
+			case 2: return {
+				r: 0,
+				g: 0,
+				b: 255
+			};
+			case 3: return {
+				r: 255,
+				g: 255,
+				b: 0
+			};
+			case 4: return {
+				r: 0,
+				g: 255,
+				b: 255
+			};
+			case 5: return {
+				r: 255,
+				g: 0,
+				b: 255
+			};
+			default: {
+				const hue = c * 128 % 360 / 360;
+				const level = 1 - Math.floor(c / 10) / 20;
+				return ColorUtils.fromHSB(hue, level, level);
+			}
+		}
+	}
+	/**
+	* Returns quantile-based contrast limits derived from a channel histogram,
+	* for use as default contrast limits when no contrast limits are known
+	*
+	* The histogram's `hist[i]` counts the values that fall into bin `i`, with
+	* bins spread evenly over `range`: bin `0` maps to the range's lower bound,
+	* the last bin to its upper bound, and each bin in between to
+	* `vmin + i / (n - 1) * (vmax - vmin)` (see
+	* {@link MathUtils.computeHistogram}). The lower limit is the value of the
+	* first bin at which the cumulative count from the bottom reaches the
+	* fraction `qlow` of the total count, the upper limit is the value of the
+	* first bin at which the cumulative count from the top reaches the fraction
+	* `1 - qhigh`; i.e., the fraction `qlow` of the values is clipped at the
+	* bottom and the fraction `1 - qhigh` at the top. Only non-empty bins are
+	* considered, so quantiles of `0` and `1` yield the first and last non-empty
+	* bin, respectively. Values that fall into the same bin cannot be told
+	* apart, so the limits are only as precise as the bins.
+	*
+	* Histograms with fewer than two bins, histograms whose counts sum to zero
+	* and degenerate ranges return `range` as is. So do histograms whose clipped
+	* limits would not be ascending (upper bin at or below lower bin), which
+	* happens if more than `qhigh - qlow` of the values fall into a single bin,
+	* e.g. for sparse channels that are mostly background, or if `qhigh` is
+	* below `qlow`, and a `qlow` above `1`, which no bin can reach.
+	*
+	* @param histogram - The channel histogram, as bin counts and value range
+	* @param qlow - The quantile of the lower limit, in `[0, 1]`
+	* @param qhigh - The quantile of the upper limit, in `[0, 1]`, above `qlow`
+	* @returns The contrast limits, as `[low, high]` in the histogram's value
+	* range, with `low < high` unless the range is degenerate
+	*/
+	static getDefaultContrastLimits(histogram, qlow = .01, qhigh = .999) {
+		const { hist, range: [vmin, vmax] } = histogram;
+		const n = hist.length;
+		if (n < 2 || vmin === vmax) return [vmin, vmax];
+		const total = hist.reduce((sum, count) => sum + count, 0);
+		if (total === 0) return [vmin, vmax];
+		let binLeft;
+		let binRight;
+		let cumulativeLeft = 0;
+		let cumulativeRight = 0;
+		const targetLeft = total * qlow;
+		const targetRight = total - total * qhigh;
+		for (let i = 0; i < n; i++) {
+			const countLeft = hist[i];
+			if (countLeft > 0) {
+				cumulativeLeft += countLeft;
+				if (binLeft === void 0 && cumulativeLeft >= targetLeft) binLeft = i;
+			}
+			const countRight = hist[n - 1 - i];
+			if (countRight > 0) {
+				cumulativeRight += countRight;
+				if (binRight === void 0 && cumulativeRight >= targetRight) binRight = n - 1 - i;
+			}
+			if (binLeft !== void 0 && binRight !== void 0) break;
+		}
+		if (binLeft === void 0 || binRight === void 0 || binLeft >= binRight) return [vmin, vmax];
+		return [vmin + binLeft / (n - 1) * (vmax - vmin), vmin + binRight / (n - 1) * (vmax - vmin)];
+	}
+	/**
+	* Returns the value range that an integer type can hold
+	*
+	* @param bits - The number of bits per value, at most 32
+	* @param signed - Whether the type is signed
+	* @returns The value range, as `[min, max]`
+	*/
+	static getIntegerTypeRange(bits, signed) {
+		return signed ? [-(2 ** (bits - 1)), 2 ** (bits - 1) - 1] : [0, 2 ** bits - 1];
+	}
+	/**
+	* Returns the value range that the type of the given array can hold, for use
+	* as default contrast limits of image channel data
+	*
+	* Integer typed arrays span their full integer range, floating-point typed
+	* arrays are taken to hold normalized values in `[0, 1]`.
+	*
+	* @param values - The array whose value range to return
+	* @returns The value range, as `[min, max]`
+	*/
+	static getDataTypeRange(values) {
+		for (const [arrayType, bits, signed] of integerArrayTypes) if (values instanceof arrayType) return ImageUtils.getIntegerTypeRange(bits, signed);
+		return [0, 1];
+	}
+};
+//#endregion
+//#region src/utils/JSONUtils.ts
+/**
+* Utility methods for JSON serialization with support for non-finite numbers
+*
+* `NaN`, `Infinity` and `-Infinity` are encoded as the sentinel strings
+* `"__NaN__"`, `"__PositiveInfinity__"` and `"__NegativeInfinity__"`, which
+* {@link JSONUtils.parse} decodes back into numbers. Strings that happen to
+* equal a sentinel are therefore not round-trip safe.
+*/
+var JSONUtils = class JSONUtils {
+	/**
+	* Serializes a value to JSON, encoding non-finite numbers as sentinel strings
+	*
+	* Behaves like `JSON.stringify` without indentation: `toJSON` methods are
+	* honored, and object properties that cannot be represented (`undefined`,
+	* functions, symbols) are omitted.
+	*
+	* It differs from `JSON.stringify` where the latter is lossy: such a value
+	* throws instead of yielding `undefined` when it is the top-level value, and
+	* throws instead of being written as `null` when it is an array element. It
+	* also does not detect circular references, which overflow the stack rather
+	* than throwing a `TypeError`.
+	*
+	* @param value - The value to serialize
+	* @param options - Optional `stable` flag, sorting object keys alphabetically
+	*   so that the output is independent of property insertion order
+	*   (default `false`)
+	* @throws If the value itself, or any array element it contains, cannot be
+	*   represented in JSON
+	*/
+	static stringify(value, options) {
+		const { stable = false } = options || {};
+		if (!JSONUtils._isStringifiable(value)) throw new Error(`Value of type ${typeof value} is not stringifiable`);
+		if (typeof value !== "object" || value === null) return JSONUtils._stringifyPrimitive(value);
+		const obj = value;
+		if (typeof obj.toJSON === "function") return JSONUtils.stringify(obj.toJSON(), options);
+		if (Array.isArray(value)) return `[${value.map((v) => JSONUtils.stringify(v, options)).join(",")}]`;
+		const keys = Object.keys(obj).filter((key) => JSONUtils._isStringifiable(obj[key]));
+		if (stable) keys.sort();
+		return `{${keys.map((k) => `${JSONUtils._stringifyPrimitive(k)}:${JSONUtils.stringify(obj[k], options)}`).join(",")}}`;
+	}
+	/**
+	* Parses JSON, decoding the sentinel strings written by
+	* {@link JSONUtils.stringify} back into `NaN`, `Infinity` and `-Infinity`
+	*
+	* @param text - The JSON text to parse
+	* @throws If the text is not valid JSON
+	*/
+	static parse(text) {
+		return JSON.parse(text, function(_key, value) {
+			if (typeof value === "string") {
+				if (value === "__NaN__") return NaN;
+				if (value === "__PositiveInfinity__") return Number.POSITIVE_INFINITY;
+				if (value === "__NegativeInfinity__") return Number.NEGATIVE_INFINITY;
+			}
+			return value;
+		});
+	}
+	/** Whether a value can be represented in JSON */
+	static _isStringifiable(value) {
+		return value !== void 0 && typeof value !== "function" && typeof value !== "symbol";
+	}
+	/**
+	* Serializes a single primitive value (or object key) using
+	* `JSON.stringify`, replacing non-finite numbers with sentinel strings
+	*
+	* The replacer reads the raw value from the holder object, because
+	* `JSON.stringify` would otherwise pass the already-converted value (`null`
+	* for non-finite numbers) to the replacer.
+	*/
+	static _stringifyPrimitive(value) {
+		return JSON.stringify(value, function(key) {
+			const rawValue = this[key];
+			if (typeof rawValue === "number") {
+				if (Number.isNaN(rawValue)) return "__NaN__";
+				if (rawValue === Infinity) return "__PositiveInfinity__";
+				if (rawValue === -Infinity) return "__NegativeInfinity__";
+			}
+			return rawValue;
+		});
+	}
+};
+//#endregion
+//#region src/utils/ProjectUtils.ts
+/** Utility methods for projects */
+var ProjectUtils = class {
+	/**
+	* Returns whether a project has any data objects
+	*
+	* @param project - The project, or only its data objects
+	* @returns `true` if the project has images, labels, points, shapes or tables
+	*/
+	static hasData(project) {
+		return project.images.length > 0 || project.labels.length > 0 || project.points.length > 0 || project.shapes.length > 0 || project.tables.length > 0;
+	}
+	/**
+	* Returns the marker configurations of a project's points
+	*
+	* @param project - The project, or only its labels, points and shapes
+	* @returns The marker configurations
+	*/
+	static getMarkerConfigs(project) {
+		return project.points.map((points) => points.pointMarker);
+	}
+	/**
+	* Returns the size configurations of a project's points
+	*
+	* @param project - The project, or only its labels, points and shapes
+	* @returns The size configurations
+	*/
+	static getSizeConfigs(project) {
+		return project.points.map((points) => points.pointSize);
+	}
+	/**
+	* Returns the color configurations of a project's labels, points and shapes
+	*
+	* @param project - The project, or only its labels, points and shapes
+	* @returns The color configurations, including the fill and stroke colors of
+	* shapes
+	*/
+	static getColorConfigs(project) {
+		return [
+			...project.labels.map((labels) => labels.labelColor),
+			...project.points.map((points) => points.pointColor),
+			...project.shapes.flatMap((shapes) => [shapes.shapeFillColor, shapes.shapeStrokeColor])
+		];
+	}
+	/**
+	* Returns the visibility configurations of a project's labels, points and
+	* shapes
+	*
+	* @param project - The project, or only its labels, points and shapes
+	* @returns The visibility configurations, including the shape, fill and
+	* stroke visibilities of shapes
+	*/
+	static getVisibilityConfigs(project) {
+		return [
+			...project.labels.map((labels) => labels.labelVisibility),
+			...project.points.map((points) => points.pointVisibility),
+			...project.shapes.flatMap((shapes) => [
+				shapes.shapeVisibility,
+				shapes.shapeFillVisibility,
+				shapes.shapeStrokeVisibility
+			])
+		];
+	}
+	/**
+	* Returns the opacity configurations of a project's labels, points and shapes
+	*
+	* @param project - The project, or only its labels, points and shapes
+	* @returns The opacity configurations, including the shape, fill and stroke
+	* opacities of shapes
+	*/
+	static getOpacityConfigs(project) {
+		return [
+			...project.labels.map((labels) => labels.labelOpacity),
+			...project.points.map((points) => points.pointOpacity),
+			...project.shapes.flatMap((shapes) => [
+				shapes.shapeOpacity,
+				shapes.shapeFillOpacity,
+				shapes.shapeStrokeOpacity
+			])
+		];
+	}
+};
+//#endregion
+//#region src/utils/SourceUtils.ts
+/**
+* Utility methods for resolving the `source` of data sources to URLs or file
+* system handles
+*
+* A source is one of the following, tried in this order:
+*
+* 1. A URL with a scheme (e.g. `https://…`, `blob:…`, `data:…`), which is
+*    normalized and returned as is.
+* 2. An app-relative path, prefixed with `//`, resolved against the base URL
+*    of the application (e.g. `//data/points.csv`).
+* 3. A workspace-relative path, prefixed with `/`, resolved to a file or
+*    directory within the open workspace (e.g. `/data/points.csv`). Without an
+*    open workspace it falls back to being app-relative.
+* 4. A project-relative path, without prefix, resolved against where the
+*    project was loaded from: a URL, or a workspace-relative path (e.g.
+*    `points.csv`, `./points.csv`, `../shared/points.csv`). Without a project
+*    source it falls back to being workspace-relative. Whenever it resolves to
+*    a workspace-relative path - against a workspace-relative project source,
+*    or through that fallback - it falls back further to being app-relative if
+*    no workspace is open.
+*
+* Resolution happens in two steps:
+*
+* 1. {@link SourceUtils.normalizeSource} classifies the source, applies the
+*    fallbacks and normalizes it, synchronously and without touching the file
+*    system. The result is either an absolute URL or a workspace-relative
+*    path. Sources referring to the same data normalize to the same string,
+*    and normalizing a normalized source yields it unchanged.
+* 2. {@link SourceUtils.resolveSource} opens the file or directory that a
+*    normalized workspace-relative path refers to;
+*    {@link SourceUtils.resolveSourceFile} and
+*    {@link SourceUtils.resolveSourceDirectory} accept only one of the two,
+*    and {@link SourceUtils.openSourceFile} also opens the file.
+*    URLs need no such step and are returned as is.
+*
+* Paths use `/` as separator and may contain `.` and `..` segments. Resolving
+* against a URL follows URL semantics: `..` segments beyond the root of the
+* URL's path are dropped silently. Resolving within the workspace collapses the
+* segments and fails if the path leaves the workspace.
+*
+* A relative path whose first segment contains a colon (e.g.
+* `sample1:ch2.tif`) is taken for a URL; write it as `./sample1:ch2.tif`
+* instead.
+*/
+var SourceUtils = class SourceUtils {
+	static _pathSep = "/";
+	static _appPathPrefix = "//";
+	static _workspacePathPrefix = SourceUtils._pathSep;
+	static _urlSchemePattern = /^[a-z][a-z0-9+.-]*:/i;
+	/**
+	* Returns whether a normalized source refers to a file or directory within
+	* the workspace
+	*
+	* @param normalizedSource - The normalized source (see
+	*   {@link SourceUtils.normalizeSource})
+	* @returns `true` for workspace-relative paths, `false` for URLs and
+	*   app-relative paths
+	*/
+	static isWorkspacePath(normalizedSource) {
+		return normalizedSource.startsWith(SourceUtils._workspacePathPrefix) && !normalizedSource.startsWith(SourceUtils._appPathPrefix);
+	}
+	/**
+	* Builds a workspace-relative path from the segments of a path within the
+	* workspace, as returned by `FileSystemDirectoryHandle.resolve`
+	*
+	* @param segments - The path segments, from the workspace root down to the
+	*   file or directory
+	* @returns The workspace-relative path (with `/` prefix)
+	*/
+	static makeWorkspacePath(segments) {
+		return SourceUtils._workspacePathPrefix + segments.join(SourceUtils._pathSep);
+	}
+	/**
+	* Returns the directory that contains a normalized source
+	*
+	* @param normalizedSource - The normalized source (see
+	*   {@link SourceUtils.normalizeSource})
+	* @returns The normalized parent source and the name of the source within
+	*   it, decoded for URLs; `null` if the source is the root of its URL's path
+	*   or lies directly in the workspace, as the workspace root is no source
+	*/
+	static getParentSource(normalizedSource) {
+		if (SourceUtils.isWorkspacePath(normalizedSource)) {
+			const segments = normalizedSource.substring(SourceUtils._workspacePathPrefix.length).split(SourceUtils._pathSep);
+			const name = segments.pop();
+			if (name === void 0 || segments.length === 0) return null;
+			return {
+				parentSource: SourceUtils.makeWorkspacePath(segments),
+				name
+			};
+		}
+		const url = new URL(normalizedSource);
+		const segments = url.pathname.split(SourceUtils._pathSep).filter((segment) => segment !== "");
+		const name = segments.pop();
+		if (name === void 0) return null;
+		url.pathname = segments.join(SourceUtils._pathSep);
+		return {
+			parentSource: url.toString(),
+			name: decodeURIComponent(name)
+		};
+	}
+	/**
+	* Normalizes a source, applying the fallbacks for missing project sources
+	* and workspaces
+	*
+	* @param source - The source to normalize
+	* @param workspace - The directory handle of the open workspace, if any
+	* @param projectSource - Where the project was loaded from: its absolute URL,
+	*   the workspace-relative path of the project file (with `/` prefix), or
+	*   `null` for projects that were loaded from neither (e.g. uploaded ones)
+	* @param options - Optional base URL that app-relative paths are resolved
+	*   against (default `document.baseURI`); the application relies on the
+	*   default, and the option is what keeps normalization a pure function of
+	*   its arguments, testable without a `document`
+	* @returns The absolute URL for URLs, app-relative paths, and paths that fall
+	*   back to being app-relative or resolve against a project URL; or the
+	*   normalized workspace-relative path (with `/` prefix) for paths within the
+	*   open workspace
+	* @throws Error if the source is empty or not a valid URL, or if it cannot be
+	*   normalized as a project-relative, workspace-relative or app-relative path
+	*   (see {@link SourceUtils._normalizeProjectPath},
+	*   {@link SourceUtils._normalizeWorkspacePath} and
+	*   {@link SourceUtils._normalizeAppPath})
+	*/
+	static normalizeSource(source, workspace, projectSource, options) {
+		if (source === "") throw new Error("Empty source");
+		if (SourceUtils._urlSchemePattern.test(source)) try {
+			return new URL(source).toString();
+		} catch (error) {
+			throw new Error(`Invalid URL: ${source}`, { cause: error });
+		}
+		if (source.startsWith(SourceUtils._appPathPrefix)) return SourceUtils._normalizeAppPath(source, options);
+		if (source.startsWith(SourceUtils._workspacePathPrefix)) return SourceUtils._normalizeWorkspacePath(source, workspace, options);
+		return SourceUtils._normalizeProjectPath(source, workspace, projectSource, options);
+	}
+	/**
+	* Resolves a normalized source to an absolute URL, a file handle or a
+	* directory handle
+	*
+	* URLs are returned as is. A workspace-relative path is opened within the
+	* workspace one directory at a time, and its last segment as a file, or as a
+	* directory if it names one. No fallbacks apply here: the source has to be
+	* normalized with {@link SourceUtils.normalizeSource} first, using the same
+	* workspace. Nothing is thrown synchronously: the returned promise rejects
+	* instead.
+	*
+	* @param normalizedSource - The normalized source to resolve: an absolute URL
+	*   or a workspace-relative path (with `/` prefix), as returned by
+	*   {@link SourceUtils.normalizeSource}
+	* @param workspace - The directory handle of the open workspace, if any
+	* @param options - Optional abort signal, checked upfront and between file
+	*   system calls
+	* @returns A promise that resolves to the absolute URL, or to the file or
+	*   directory handle for sources within the workspace
+	* @throws Error if a workspace-relative path is given without an open
+	*   workspace, or if the path leaves the workspace or names its root
+	* @throws DOMException if a segment names nothing within the workspace
+	*   (`NotFoundError`), if a segment other than the last names a file
+	*   (`TypeMismatchError`), or if the operation is aborted (`AbortError`)
+	*/
+	static async resolveSource(normalizedSource, workspace, options) {
+		const { signal } = options ?? {};
+		signal?.throwIfAborted();
+		if (!SourceUtils.isWorkspacePath(normalizedSource)) return normalizedSource;
+		if (workspace === null) throw new Error(`Cannot resolve workspace-relative path without workspace: ${normalizedSource}`);
+		const segments = SourceUtils._collapseSegments(normalizedSource.substring(SourceUtils._workspacePathPrefix.length));
+		const entryName = segments.pop();
+		if (entryName === void 0) throw new Error(`Not a workspace file or directory: ${normalizedSource}`);
+		let dir = workspace;
+		for (const dirName of segments) {
+			dir = await dir.getDirectoryHandle(dirName);
+			signal?.throwIfAborted();
+		}
+		let entry;
+		try {
+			entry = await dir.getFileHandle(entryName);
+		} catch (error) {
+			if (!(error instanceof DOMException && error.name === "TypeMismatchError")) throw error;
+			signal?.throwIfAborted();
+			entry = await dir.getDirectoryHandle(entryName);
+		}
+		signal?.throwIfAborted();
+		return entry;
+	}
+	/**
+	* Resolves a normalized source to an absolute URL or a file handle
+	*
+	* Like {@link SourceUtils.resolveSource}, for sources that have to refer to
+	* a file.
+	*
+	* @param normalizedSource - See {@link SourceUtils.resolveSource}
+	* @param workspace - See {@link SourceUtils.resolveSource}
+	* @param options - See {@link SourceUtils.resolveSource}
+	* @returns A promise that resolves to the absolute URL, or to the file handle
+	*   for sources within the workspace
+	* @throws See {@link SourceUtils.resolveSource}
+	* @throws DOMException if the source refers to a directory within the
+	*   workspace (`TypeMismatchError`)
+	*/
+	static async resolveSourceFile(normalizedSource, workspace, options) {
+		const resolvedSource = await SourceUtils.resolveSource(normalizedSource, workspace, options);
+		if (typeof resolvedSource !== "string" && resolvedSource.kind !== "file") throw new DOMException(`Not a workspace file: ${normalizedSource}`, "TypeMismatchError");
+		return resolvedSource;
+	}
+	/**
+	* Resolves a normalized source to an absolute URL or an opened file
+	*
+	* Like {@link SourceUtils.resolveSourceFile}, for readers that take either
+	* a URL or a `File`: a file in the workspace is opened right away.
+	*
+	* @param normalizedSource - See {@link SourceUtils.resolveSource}
+	* @param workspace - See {@link SourceUtils.resolveSource}
+	* @param options - See {@link SourceUtils.resolveSource}; the signal is
+	*   also checked once the file is open, as opening it does not throw on
+	*   abort
+	* @returns A promise that resolves to the absolute URL, or to the opened
+	*   file for sources within the workspace
+	* @throws See {@link SourceUtils.resolveSourceFile}
+	* @throws DOMException if the file cannot be opened, e.g. because it was
+	*   removed (`NotFoundError`) or its read permission was revoked
+	*   (`NotAllowedError`)
+	* @throws The abort reason of the signal, if it is aborted once the file
+	*   is open
+	*/
+	static async openSourceFile(normalizedSource, workspace, options) {
+		const { signal } = options ?? {};
+		const resolvedSource = await SourceUtils.resolveSourceFile(normalizedSource, workspace, options);
+		if (typeof resolvedSource === "string") return { url: resolvedSource };
+		const file = await resolvedSource.getFile();
+		signal?.throwIfAborted();
+		return { file };
+	}
+	/**
+	* Resolves a normalized source to an absolute URL or a directory handle
+	*
+	* Like {@link SourceUtils.resolveSource}, for sources that have to refer to
+	* a directory.
+	*
+	* @param normalizedSource - See {@link SourceUtils.resolveSource}
+	* @param workspace - See {@link SourceUtils.resolveSource}
+	* @param options - See {@link SourceUtils.resolveSource}
+	* @returns A promise that resolves to the absolute URL, or to the directory
+	*   handle for sources within the workspace
+	* @throws See {@link SourceUtils.resolveSource}
+	* @throws DOMException if the source refers to a file within the workspace
+	*   (`TypeMismatchError`)
+	*/
+	static async resolveSourceDirectory(normalizedSource, workspace, options) {
+		const resolvedSource = await SourceUtils.resolveSource(normalizedSource, workspace, options);
+		if (typeof resolvedSource !== "string" && resolvedSource.kind !== "directory") throw new DOMException(`Not a workspace directory: ${normalizedSource}`, "TypeMismatchError");
+		return resolvedSource;
+	}
+	/**
+	* Normalizes a project-relative path
+	*
+	* Against a project URL, the path is resolved to an absolute URL. Against a
+	* workspace-relative project path, the path is resolved within the project
+	* file's directory to a workspace-relative path. Without a project source,
+	* the path is normalized as a workspace-relative path as is. Both of the
+	* latter go through {@link SourceUtils._normalizeWorkspacePath}, including
+	* its fallback for when no workspace is open.
+	*
+	* @param projectPath - The project-relative path (without prefix)
+	* @param workspace - The directory handle of the open workspace, if any
+	* @param projectSource - See {@link SourceUtils.normalizeSource}
+	* @param options - Optional base URL for the app-relative fallback (see
+	*   {@link SourceUtils._normalizeAppPath})
+	* @returns The absolute URL, or the normalized workspace-relative path
+	* @throws Error if the path does not form a valid URL with the project URL,
+	*   if it leaves the workspace, or if it cannot be normalized as a
+	*   workspace-relative path (see {@link SourceUtils._normalizeWorkspacePath})
+	*/
+	static _normalizeProjectPath(projectPath, workspace, projectSource, options) {
+		if (projectSource !== null) {
+			if (SourceUtils._urlSchemePattern.test(projectSource)) try {
+				return new URL(projectPath, projectSource).toString();
+			} catch (error) {
+				throw new Error(`Invalid project-relative path: ${projectPath}`, { cause: error });
+			}
+			const projectDirSegments = SourceUtils._collapseSegments(projectSource.substring(SourceUtils._workspacePathPrefix.length)).slice(0, -1);
+			const segments = SourceUtils._collapseSegments(projectPath, projectDirSegments);
+			return SourceUtils._normalizeWorkspacePath(SourceUtils.makeWorkspacePath(segments), workspace, options);
+		}
+		return SourceUtils._normalizeWorkspacePath(SourceUtils._workspacePathPrefix + projectPath, workspace, options);
+	}
+	/**
+	* Normalizes a workspace-relative path
+	*
+	* With an open workspace, the path's segments are collapsed and the `/`
+	* prefix is kept. Without one, the path is normalized as an app-relative
+	* path instead (see {@link SourceUtils._normalizeAppPath}), dropping its `/`
+	* prefix: `/data/points.csv` then resolves like `//data/points.csv`.
+	*
+	* @param workspacePath - The workspace-relative path (with `/` prefix)
+	* @param workspace - The directory handle of the open workspace, if any
+	* @param options - Optional base URL for the app-relative fallback (see
+	*   {@link SourceUtils._normalizeAppPath})
+	* @returns The normalized workspace-relative path, or the absolute URL if no
+	*   workspace is open
+	* @throws Error if the path lacks the `/` prefix, or if it leaves the
+	*   workspace or names its root (with an open workspace) or cannot be
+	*   normalized as an app-relative path (without one, see
+	*   {@link SourceUtils._normalizeAppPath})
+	*/
+	static _normalizeWorkspacePath(workspacePath, workspace, options) {
+		if (!workspacePath.startsWith(SourceUtils._workspacePathPrefix)) throw new Error(`Invalid workspace-relative path: ${workspacePath}`);
+		const path = workspacePath.substring(SourceUtils._workspacePathPrefix.length);
+		if (workspace !== null) {
+			const segments = SourceUtils._collapseSegments(path);
+			if (segments.length === 0) throw new Error(`Not a workspace file or directory: ${workspacePath}`);
+			return SourceUtils.makeWorkspacePath(segments);
+		}
+		return SourceUtils._normalizeAppPath(SourceUtils._appPathPrefix + path, options);
+	}
+	/**
+	* Normalizes an app-relative path to an absolute URL
+	*
+	* The path is resolved against the base URL like a relative URL, so `..`
+	* segments can lead above the application and a `/` right after the prefix
+	* makes the path absolute within the origin.
+	*
+	* @param appPath - The app-relative path (with `//` prefix)
+	* @param options - Optional base URL to resolve against (default
+	*   `document.baseURI`)
+	* @returns The absolute URL
+	* @throws Error if the path lacks the `//` prefix
+	* @throws TypeError if the path does not form a valid URL with the base URL
+	*/
+	static _normalizeAppPath(appPath, options) {
+		const { baseUrl = document.baseURI } = options ?? {};
+		if (!appPath.startsWith(SourceUtils._appPathPrefix)) throw new Error(`Invalid app-relative path: ${appPath}`);
+		const path = appPath.substring(SourceUtils._appPathPrefix.length);
+		return new URL(path, baseUrl).toString();
+	}
+	/**
+	* Splits a path into segments, dropping empty and `.` segments and
+	* collapsing `..` segments against the segments preceding them
+	*
+	* @param path - The path to split, using `/` as separator
+	* @param baseSegments - The segments of the directory the path is relative
+	*   to, which `..` segments collapse against first (default: the root)
+	* @returns The collapsed segments, empty if the path names the root itself
+	* @throws Error if the path leads above the root
+	*/
+	static _collapseSegments(path, baseSegments = []) {
+		const segments = [...baseSegments];
+		for (const segment of path.split(SourceUtils._pathSep)) {
+			if (segment === "" || segment === ".") continue;
+			if (segment === "..") {
+				if (segments.length === 0) throw new Error(`Path escapes workspace: ${path}`);
+				segments.pop();
+			} else segments.push(segment);
+		}
+		return segments;
+	}
+};
+//#endregion
+//#region src/utils/TableUtils.ts
+/**
+* Lookups into tabular data (`TableData`) by item ID
+*
+* A table annotates the items of another data object: each of its rows holds
+* the item ID it belongs to, and consumers address rows by that ID rather than
+* by position (see `ItemsData`). Looking rows up by ID needs a map from ID to
+* row index, which is linear in the size of the table to build and costly to
+* hold; {@link forEachRow} therefore builds it at most once per table, and not
+* at all in the common case that the IDs to look up are the table's own, in
+* row order. Once built, the map is retained for as long as the table's data
+* is: it is keyed by the identity of the table's ID array, so it is freed
+* together with the data, and a table that is looked up by other IDs - shapes
+* annotated by a separate table, or the items of one layer of an object -
+* keeps one entry per row alive until then. That is the price of sharing the
+* map between every consumer of the table.
+*
+* Item IDs are expected to be unique within a table (see `ItemsData`). For a
+* duplicated ID, the row-order fast path addresses each row by its own
+* position, whereas the lookup maps the ID to its last row; a table with
+* duplicated IDs is reported once, when its map is built.
+*
+* On top of the row lookup, {@link fillFromTableValues} and
+* {@link fillFromTableGroups} fill a typed array with one packed value per
+* item from a table column, one by parsing the cell values and one by mapping
+* their distinct values as groups. IDs that the table does not contain fall
+* back to a default value, with a warning.
+*/
+var TableUtils = class TableUtils {
+	/**
+	* Row indices by item ID, by the table's ID array
+	*
+	* Keyed by the array that `getIds()` returns, which stays the very same array
+	* for as long as the data is unchanged (see `ItemsData`), so an entry lives
+	* exactly as long as the data it was built from. Holds the pending build,
+	* so that concurrent lookups share it.
+	*/
+	static _rowIndicesCache = /* @__PURE__ */ new WeakMap();
+	/**
+	* Fills `packedValues` by loading values from the given table column
+	*
+	* For each ID in `ids`, the corresponding row is looked up in the table by ID
+	* (see {@link forEachRow}). The raw cell value is parsed by
+	* `parseTableValue`; if that fails, or if the table does not contain the ID,
+	* `defaultValue` is used instead.
+	*
+	* @param packedValues - Output typed array to fill, in the order of `ids`
+	* @param tableData - The table to look up values in
+	* @param ids - Ordered list of item IDs
+	* @param column - Name of the table column to load values from
+	* @param defaultValue - Value used when the ID is missing or parsing fails
+	* @param parseTableValue - Converts a raw cell value to `TValue`, or to
+	* `undefined` on failure
+	* @param packValue - Converts `TValue` to the numeric representation stored
+	* in `packedValues`
+	* @param options - Optional abort signal
+	*/
+	static async fillFromTableValues(packedValues, tableData, ids, column, defaultValue, parseTableValue, packValue, options) {
+		const { signal } = options ?? {};
+		signal?.throwIfAborted();
+		const tableValues = await tableData.loadValues(column, { signal });
+		let numMissingIds = 0;
+		let numUnparsedValues = 0;
+		await TableUtils.forEachRow(ids, tableData, (rowIndex, i) => {
+			if (rowIndex !== void 0) {
+				const parsedValue = parseTableValue(tableValues[rowIndex]);
+				if (parsedValue === void 0) numUnparsedValues++;
+				packedValues[i] = packValue(parsedValue ?? defaultValue);
+			} else {
+				numMissingIds++;
+				packedValues[i] = packValue(defaultValue);
+			}
+		}, { signal });
+		if (numMissingIds > 0) console.warn(`${numMissingIds} IDs missing in column ${column}, using default value`);
+		if (numUnparsedValues > 0) console.warn(`Failed to parse ${numUnparsedValues} values from column ${column}, using default value`);
+	}
+	/**
+	* Fills `packedValues` by grouping IDs by the given table column and mapping the groups to values
+	*
+	* For each ID in `ids`, the corresponding row is looked up in the table by ID
+	* (see {@link forEachRow}). The raw cell value is converted to a string to
+	* form the group key, which `mapGroupToValue` maps to a value; if the table
+	* does not contain the ID, `defaultValue` is used instead. Groups are
+	* resolved once per distinct cell value, i.e. `mapGroupToValue` is not
+	* called per item.
+	*
+	* @param packedValues - Output typed array to fill, in the order of `ids`
+	* @param tableData - The table to look up group keys in
+	* @param ids - Ordered list of item IDs
+	* @param column - Name of the table column to load group keys from
+	* @param defaultValue - Value used when the ID is missing
+	* @param mapGroupToValue - Maps a group key (the cell value as a string) to
+	* `TValue`
+	* @param packValue - Converts `TValue` to the numeric representation stored
+	* in `packedValues`
+	* @param options - Optional abort signal
+	*/
+	static async fillFromTableGroups(packedValues, tableData, ids, column, defaultValue, mapGroupToValue, packValue, options) {
+		const { signal } = options ?? {};
+		signal?.throwIfAborted();
+		const tableGroups = await tableData.loadValues(column, { signal });
+		let numMissingIds = 0;
+		const packedValueByTableGroup = /* @__PURE__ */ new Map();
+		await TableUtils.forEachRow(ids, tableData, (rowIndex, i) => {
+			if (rowIndex !== void 0) {
+				const tableGroup = tableGroups[rowIndex];
+				let packedValue = packedValueByTableGroup.get(tableGroup);
+				if (packedValue === void 0) {
+					packedValue = packValue(mapGroupToValue(String(tableGroup)));
+					packedValueByTableGroup.set(tableGroup, packedValue);
+				}
+				packedValues[i] = packedValue;
+			} else {
+				numMissingIds++;
+				packedValues[i] = packValue(defaultValue);
+			}
+		}, { signal });
+		if (numMissingIds > 0) console.warn(`${numMissingIds} IDs missing in column ${column}, using default value`);
+	}
+	/**
+	* Calls `callback` for every ID with the index of the table row holding that ID
+	*
+	* If `ids` is the table's own ID array, the ID at position `i` is held by
+	* row `i` and no lookup is needed. Otherwise the rows are looked up in the
+	* table's row indices (see {@link getRowIndices}); IDs the table does not
+	* contain are reported with an undefined row index.
+	*
+	* @param ids - Ordered list of item IDs
+	* @param tableData - The table to look the IDs up in
+	* @param callback - Called with the row index of each ID, or `undefined` if
+	* the table does not contain it, and the position of the ID in `ids`
+	* @param options - Optional abort signal
+	*/
+	static async forEachRow(ids, tableData, callback, options) {
+		const { signal } = options ?? {};
+		signal?.throwIfAborted();
+		if (ids === tableData.getIds()) {
+			await AsyncUtils.forEach(ids, (_, i) => callback(i, i), { signal });
+			return;
+		}
+		const rowIndices = await TableUtils.getRowIndices(tableData, { signal });
+		await AsyncUtils.forEach(ids, (id, i) => callback(rowIndices.get(id), i), { signal });
+	}
+	/**
+	* Returns the row indices of a table by item ID
+	*
+	* Built at most once per table, cooperatively yielding, and shared by all
+	* callers, which is why a caller's abort signal only detaches that caller:
+	* the build itself keeps going for the others, and for the next lookup.
+	*
+	* @param tableData - The table to return the row indices of
+	* @param options - Optional abort signal
+	* @returns The row index of every item ID of the table; for an ID occurring
+	* more than once, which is reported with a warning, the index of its last row
+	*/
+	static getRowIndices(tableData, options) {
+		const tableIds = tableData.getIds();
+		let rowIndicesPromise = TableUtils._rowIndicesCache.get(tableIds);
+		if (rowIndicesPromise === void 0) {
+			rowIndicesPromise = TableUtils._buildRowIndices(tableIds);
+			TableUtils._rowIndicesCache.set(tableIds, rowIndicesPromise);
+		}
+		return AsyncUtils.raceSignal(rowIndicesPromise, options);
+	}
+	/**
+	* Builds the row indices by item ID for the given table IDs
+	*/
+	static async _buildRowIndices(tableIds) {
+		const rowIndices = /* @__PURE__ */ new Map();
+		await AsyncUtils.forEach(tableIds, (id, i) => {
+			rowIndices.set(id, i);
+		});
+		if (rowIndices.size !== tableIds.length) console.warn(`${tableIds.length - rowIndices.size} duplicated item IDs in table, using the last row of each`);
+		return rowIndices;
+	}
+};
+//#endregion
+//#region src/utils/TransformUtils.ts
+/**
+* Utility methods for converting between {@link SimilarityTransform}
+* objects and `gl-matrix` {@link mat3} matrices
+*/
+var TransformUtils = class {
+	/**
+	* Decomposes a 3×3 similarity matrix into a {@link SimilarityTransform}
+	*
+	* Extracts flip, uniform scale, rotation (in degrees), and translation
+	* from a column-major `gl-matrix` {@link mat3}. A negative 2D determinant
+	* indicates a horizontal reflection.
+	*
+	* If `pivot` is given, flip and rotation are expressed about `pivot`
+	* (in the input coordinates of `m`) instead of the origin, while scale
+	* stays about the origin. Flip, scale, and rotation are unaffected; only
+	* the translation changes to `m(pivot) - scale * pivot`, i.e. the position
+	* of the scaled content before it is flipped and rotated about its (scaled)
+	* pivot. This matches viewers that place an image by its top-left corner
+	* and then flip/rotate it about its center.
+	*
+	* @param m - The source matrix
+	* @param pivot - Optional point about which flip and rotation are expressed
+	* @returns The decomposed transform
+	*/
+	static decompose(m, pivot) {
+		const flip = m[0] * m[4] - m[3] * m[1] < 0;
+		const c0 = flip ? -m[0] : m[0];
+		const c1 = flip ? -m[1] : m[1];
+		const scale = Math.hypot(c0, c1);
+		const rotation = Math.atan2(c1, c0) * 180 / Math.PI;
+		const translation = {
+			x: m[6],
+			y: m[7]
+		};
+		if (pivot !== void 0) {
+			const { x: cx, y: cy } = pivot;
+			translation.x = m[0] * cx + m[3] * cy + m[6] - scale * cx;
+			translation.y = m[1] * cx + m[4] * cy + m[7] - scale * cy;
+		}
+		return {
+			flip,
+			scale,
+			rotation,
+			translation
+		};
+	}
+	/**
+	* Builds a 3×3 similarity matrix from a (partial) {@link SimilarityTransform}
+	*
+	* Applies, in order: flip/scale, rotation, and translation.
+	*
+	* If `pivot` is given, flip and rotation are applied about `pivot` (in the
+	* source coordinates of the transform) instead of the origin, while scale
+	* stays about the origin. The translation is then the position of the
+	* scaled content before it is flipped and rotated about its (scaled)
+	* pivot. This is the inverse of {@link decompose} called with
+	* the same pivot.
+	*
+	* @param tf - The transform components (all optional)
+	* @param pivot - Optional point about which flip and rotation are applied
+	* @returns The composed matrix
+	*/
+	static compose(tf, pivot) {
+		const m = mat3.create();
+		if (tf.translation !== void 0) mat3.translate(m, m, [tf.translation.x, tf.translation.y]);
+		if (pivot !== void 0) {
+			const scale = tf.scale ?? 1;
+			mat3.translate(m, m, [scale * pivot.x, scale * pivot.y]);
+		}
+		if (tf.rotation !== void 0) mat3.rotate(m, m, Math.PI * tf.rotation / 180);
+		if (tf.flip) mat3.scale(m, m, [-1, 1]);
+		if (pivot !== void 0) {
+			const scale = tf.scale ?? 1;
+			mat3.translate(m, m, [-scale * pivot.x, -scale * pivot.y]);
+		}
+		if (tf.scale !== void 0) mat3.scale(m, m, [tf.scale, tf.scale]);
+		return m;
+	}
+	/**
+	* Transforms an axis-aligned rectangle and returns the axis-aligned bounding box of the transformed corners
+	*
+	* @param rect - The rectangle to transform
+	* @param m - The transformation matrix to apply to the rectangle corners
+	* @returns The axis-aligned bounding box of the transformed rectangle
+	*/
+	static transformBoundingBox(rect, m) {
+		const { x, y, width, height } = rect;
+		const p0 = vec2.fromValues(x, y);
+		const p1 = vec2.fromValues(x + width, y);
+		const p2 = vec2.fromValues(x, y + height);
+		const p3 = vec2.fromValues(x + width, y + height);
+		vec2.transformMat3(p0, p0, m);
+		vec2.transformMat3(p1, p1, m);
+		vec2.transformMat3(p2, p2, m);
+		vec2.transformMat3(p3, p3, m);
+		const xMin = Math.min(p0[0], p1[0], p2[0], p3[0]);
+		const yMin = Math.min(p0[1], p1[1], p2[1], p3[1]);
+		const xMax = Math.max(p0[0], p1[0], p2[0], p3[0]);
+		const yMax = Math.max(p0[1], p1[1], p2[1], p3[1]);
+		return {
+			x: xMin,
+			y: yMin,
+			width: xMax - xMin,
+			height: yMax - yMin
+		};
+	}
+};
+//#endregion
+//#region src/assets/palettes/batlow.txt?raw
+var batlow_default = "0.005193 0.098238 0.349842\n0.009065 0.104487 0.350933\n0.012963 0.110779 0.351992\n0.016530 0.116913 0.353070\n0.019936 0.122985 0.354120\n0.023189 0.129035 0.355182\n0.026291 0.135044 0.356210\n0.029245 0.140964 0.357239\n0.032053 0.146774 0.358239\n0.034853 0.152558 0.359233\n0.037449 0.158313 0.360216\n0.039845 0.163978 0.361187\n0.042104 0.169557 0.362151\n0.044069 0.175053 0.363084\n0.045905 0.180460 0.364007\n0.047665 0.185844 0.364915\n0.049378 0.191076 0.365810\n0.050795 0.196274 0.366684\n0.052164 0.201323 0.367524\n0.053471 0.206357 0.368370\n0.054721 0.211234 0.369184\n0.055928 0.216046 0.369974\n0.057033 0.220754 0.370750\n0.058032 0.225340 0.371509\n0.059164 0.229842 0.372252\n0.060167 0.234299 0.372978\n0.061052 0.238625 0.373691\n0.062060 0.242888 0.374386\n0.063071 0.247085 0.375050\n0.063982 0.251213 0.375709\n0.064936 0.255264 0.376362\n0.065903 0.259257 0.376987\n0.066899 0.263188 0.377594\n0.067921 0.267056 0.378191\n0.069002 0.270922 0.378774\n0.070001 0.274713 0.379342\n0.071115 0.278497 0.379895\n0.072192 0.282249 0.380434\n0.073440 0.285942 0.380957\n0.074595 0.289653 0.381452\n0.075833 0.293321 0.381922\n0.077136 0.296996 0.382376\n0.078517 0.300622 0.382814\n0.079984 0.304252 0.383224\n0.081553 0.307858 0.383598\n0.083082 0.311461 0.383936\n0.084778 0.315043 0.384240\n0.086503 0.318615 0.384506\n0.088353 0.322167 0.384731\n0.090281 0.325685 0.384910\n0.092304 0.329220 0.385040\n0.094462 0.332712 0.385116\n0.096618 0.336161 0.385134\n0.099015 0.339621 0.385090\n0.101481 0.343036 0.384981\n0.104078 0.346410 0.384801\n0.106842 0.349774 0.384548\n0.109695 0.353098 0.384217\n0.112655 0.356391 0.383807\n0.115748 0.359638 0.383310\n0.118992 0.362849 0.382713\n0.122320 0.366030 0.382026\n0.125889 0.369160 0.381259\n0.129519 0.372238 0.380378\n0.133298 0.375282 0.379395\n0.137212 0.378282 0.378315\n0.141260 0.381240 0.377135\n0.145432 0.384130 0.375840\n0.149706 0.386975 0.374449\n0.154073 0.389777 0.372934\n0.158620 0.392531 0.371320\n0.163246 0.395237 0.369609\n0.167952 0.397889 0.367784\n0.172788 0.400496 0.365867\n0.177752 0.403041 0.363833\n0.182732 0.405551 0.361714\n0.187886 0.408003 0.359484\n0.193050 0.410427 0.357177\n0.198310 0.412798 0.354767\n0.203676 0.415116 0.352253\n0.209075 0.417412 0.349677\n0.214555 0.419661 0.347019\n0.220112 0.421864 0.344261\n0.225707 0.424049 0.341459\n0.231362 0.426197 0.338572\n0.237075 0.428325 0.335634\n0.242795 0.430418 0.332635\n0.248617 0.432493 0.329571\n0.254452 0.434529 0.326434\n0.260320 0.436556 0.323285\n0.266241 0.438555 0.320085\n0.272168 0.440541 0.316831\n0.278171 0.442524 0.313552\n0.284175 0.444484 0.310243\n0.290214 0.446420 0.306889\n0.296294 0.448357 0.303509\n0.302379 0.450282 0.300122\n0.308517 0.452205 0.296721\n0.314648 0.454107 0.293279\n0.320834 0.456006 0.289841\n0.327007 0.457900 0.286377\n0.333235 0.459794 0.282937\n0.339469 0.461685 0.279468\n0.345703 0.463563 0.275998\n0.351976 0.465440 0.272492\n0.358277 0.467331 0.269037\n0.364589 0.469213 0.265543\n0.370922 0.471085 0.262064\n0.377291 0.472952 0.258588\n0.383675 0.474842 0.255131\n0.390070 0.476711 0.251665\n0.396505 0.478587 0.248212\n0.402968 0.480466 0.244731\n0.409455 0.482351 0.241314\n0.415967 0.484225 0.237895\n0.422507 0.486113 0.234493\n0.429094 0.488011 0.231096\n0.435714 0.489890 0.227728\n0.442365 0.491795 0.224354\n0.449052 0.493684 0.221074\n0.455774 0.495585 0.217774\n0.462539 0.497497 0.214518\n0.469368 0.499393 0.211318\n0.476221 0.501314 0.208148\n0.483123 0.503216 0.205037\n0.490081 0.505137 0.201976\n0.497089 0.507058 0.198994\n0.504153 0.508984 0.196118\n0.511253 0.510898 0.193296\n0.518425 0.512822 0.190566\n0.525637 0.514746 0.187990\n0.532907 0.516662 0.185497\n0.540225 0.518584 0.183099\n0.547599 0.520486 0.180884\n0.555024 0.522391 0.178854\n0.562506 0.524293 0.176964\n0.570016 0.526186 0.175273\n0.577582 0.528058 0.173775\n0.585199 0.529927 0.172493\n0.592846 0.531777 0.171449\n0.600520 0.533605 0.170648\n0.608240 0.535423 0.170104\n0.615972 0.537231 0.169826\n0.623739 0.539002 0.169814\n0.631513 0.540752 0.170075\n0.639301 0.542484 0.170622\n0.647098 0.544183 0.171465\n0.654889 0.545863 0.172603\n0.662691 0.547503 0.174044\n0.670477 0.549127 0.175747\n0.678244 0.550712 0.177803\n0.685995 0.552274 0.180056\n0.693720 0.553797 0.182610\n0.701421 0.555294 0.185478\n0.709098 0.556772 0.188546\n0.716731 0.558205 0.191851\n0.724322 0.559628 0.195408\n0.731878 0.561011 0.199174\n0.739393 0.562386 0.203179\n0.746850 0.563725 0.207375\n0.754268 0.565033 0.211761\n0.761629 0.566344 0.216322\n0.768942 0.567630 0.221045\n0.776208 0.568899 0.225930\n0.783416 0.570162 0.230962\n0.790568 0.571421 0.236160\n0.797665 0.572682 0.241490\n0.804709 0.573928 0.246955\n0.811692 0.575187 0.252572\n0.818610 0.576462 0.258303\n0.825472 0.577725 0.264197\n0.832272 0.579026 0.270211\n0.838999 0.580339 0.276353\n0.845657 0.581672 0.282631\n0.852247 0.583037 0.289036\n0.858747 0.584440 0.295572\n0.865168 0.585882 0.302255\n0.871505 0.587352 0.309112\n0.877741 0.588873 0.316081\n0.883878 0.590450 0.323195\n0.889900 0.592087 0.330454\n0.895809 0.593765 0.337865\n0.901590 0.595507 0.345429\n0.907242 0.597319 0.353142\n0.912746 0.599191 0.360986\n0.918103 0.601126 0.368999\n0.923300 0.603137 0.377139\n0.928323 0.605212 0.385404\n0.933176 0.607369 0.393817\n0.937850 0.609582 0.402345\n0.942332 0.611867 0.411006\n0.946612 0.614218 0.419767\n0.950697 0.616649 0.428624\n0.954574 0.619137 0.437582\n0.958244 0.621671 0.446604\n0.961696 0.624282 0.455702\n0.964943 0.626934 0.464860\n0.967983 0.629639 0.474057\n0.970804 0.632394 0.483290\n0.973424 0.635183 0.492547\n0.975835 0.638012 0.501826\n0.978052 0.640868 0.511090\n0.980079 0.643752 0.520350\n0.981918 0.646664 0.529602\n0.983574 0.649590 0.538819\n0.985066 0.652522 0.547998\n0.986392 0.655470 0.557142\n0.987567 0.658422 0.566226\n0.988596 0.661378 0.575265\n0.989496 0.664329 0.584246\n0.990268 0.667280 0.593174\n0.990926 0.670230 0.602031\n0.991479 0.673165 0.610835\n0.991935 0.676091 0.619575\n0.992305 0.679007 0.628251\n0.992595 0.681914 0.636869\n0.992813 0.684815 0.645423\n0.992967 0.687705 0.653934\n0.993064 0.690579 0.662398\n0.993111 0.693451 0.670810\n0.993112 0.696314 0.679177\n0.993074 0.699161 0.687519\n0.993002 0.702006 0.695831\n0.992900 0.704852 0.704114\n0.992771 0.707689 0.712380\n0.992619 0.710530 0.720639\n0.992447 0.713366 0.728892\n0.992258 0.716210 0.737146\n0.992054 0.719049 0.745403\n0.991837 0.721893 0.753673\n0.991607 0.724754 0.761959\n0.991367 0.727614 0.770270\n0.991116 0.730489 0.778606\n0.990855 0.733373 0.786976\n0.990586 0.736265 0.795371\n0.990307 0.739184 0.803810\n0.990018 0.742102 0.812285\n0.989720 0.745039 0.820804\n0.989411 0.747997 0.829372\n0.989089 0.750968 0.837979\n0.988754 0.753949 0.846627\n0.988406 0.756949 0.855332\n0.988046 0.759964 0.864078\n0.987672 0.762996 0.872864\n0.987280 0.766047 0.881699\n0.986868 0.769105 0.890573\n0.986435 0.772184 0.899493\n0.985980 0.775272 0.908448\n0.985503 0.778378 0.917444\n0.985002 0.781495 0.926468\n0.984473 0.784624 0.935531\n0.983913 0.787757 0.944626\n0.983322 0.790905 0.953748\n0.982703 0.794068 0.962895\n0.982048 0.797228 0.972070\n0.981354 0.800406 0.981267\n";
+//#endregion
+//#region src/assets/palettes/batlowS.txt?raw
+var batlowS_default = "0.005193 0.098238 0.349842\n0.981354 0.800406 0.981267\n0.511253 0.510898 0.193296\n0.133298 0.375282 0.379395\n0.946612 0.614218 0.419767\n0.066899 0.263188 0.377594\n0.992900 0.704852 0.704114\n0.302379 0.450282 0.300122\n0.754268 0.565033 0.211761\n0.402968 0.480466 0.244731\n0.989089 0.750968 0.837979\n0.631513 0.540752 0.170075\n0.987567 0.658422 0.566226\n0.209075 0.417412 0.349677\n0.049378 0.191076 0.365810\n0.088353 0.322167 0.384731\n0.858747 0.584440 0.295572\n0.973424 0.635183 0.492547\n0.167952 0.397889 0.367784\n0.570016 0.526186 0.175273\n0.351976 0.465440 0.272492\n0.106842 0.349774 0.384548\n0.991367 0.727614 0.770270\n0.693720 0.553797 0.182610\n0.032053 0.146774 0.358239\n0.075833 0.293321 0.381922\n0.254452 0.434529 0.326434\n0.907242 0.597319 0.353142\n0.059164 0.229842 0.372252\n0.985980 0.775272 0.908448\n0.992595 0.681914 0.636869\n0.455774 0.495585 0.217774\n0.811692 0.575187 0.252572\n0.662691 0.547503 0.174044\n0.987672 0.762996 0.872864\n0.187886 0.408003 0.359484\n0.992258 0.716210 0.737146\n0.019936 0.122985 0.354120\n0.429094 0.488011 0.231096\n0.071115 0.278497 0.379895\n0.231362 0.426197 0.338572\n0.081553 0.307858 0.383598\n0.783416 0.570162 0.230962\n0.883878 0.590450 0.323195\n0.278171 0.442524 0.313552\n0.054721 0.211234 0.369184\n0.042104 0.169557 0.362151\n0.063071 0.247085 0.375050\n0.118992 0.362849 0.382713\n0.096618 0.336161 0.385134\n0.983913 0.787757 0.944626\n0.981918 0.646664 0.529602\n0.990926 0.670230 0.602031\n0.149706 0.386975 0.374449\n0.377291 0.472952 0.258588\n0.540225 0.518584 0.183099\n0.990307 0.739184 0.803810\n0.993111 0.693451 0.670810\n0.961696 0.624282 0.455702\n0.483123 0.503216 0.205037\n0.600520 0.533605 0.170648\n0.928323 0.605212 0.385404\n0.327007 0.457900 0.286377\n0.724322 0.559628 0.195408\n0.832272 0.579026 0.270211\n0.978052 0.640868 0.511090\n0.993074 0.699161 0.687519\n0.954574 0.619137 0.437582\n0.364589 0.469213 0.265543\n0.220112 0.421864 0.344261\n0.045905 0.180460 0.364007\n0.989496 0.664329 0.584246\n0.061052 0.238625 0.373691\n0.012963 0.110779 0.351992\n0.158620 0.392531 0.371320\n0.988406 0.756949 0.855332\n0.797665 0.572682 0.241490\n0.314648 0.454107 0.293279\n0.992967 0.687705 0.653934\n0.768942 0.567630 0.221045\n0.647098 0.544183 0.171465\n0.390070 0.476711 0.251665\n0.985002 0.781495 0.926468\n0.985066 0.652522 0.547998\n0.026291 0.135044 0.356210\n0.078517 0.300622 0.382814\n0.469368 0.499393 0.211318\n0.585199 0.529927 0.172493\n0.141260 0.381240 0.377135\n0.415967 0.484225 0.237895\n0.290214 0.446420 0.306889\n0.073440 0.285942 0.380957\n0.986868 0.769105 0.890573\n0.242795 0.430418 0.332635\n0.991935 0.676091 0.619575\n0.052164 0.201323 0.367524\n0.442365 0.491795 0.224354\n0.064936 0.255264 0.376362\n0.198310 0.412798 0.354767\n0.989720 0.745039 0.820804\n";
+//#endregion
+//#region src/assets/palettes/distinct.txt?raw
+var distinct_default = "230 25 75\n60 180 75\n255 225 25\n67 99 216\n245 130 49\n145 30 180\n66 212 244\n240 50 230\n191 239 69\n250 190 212\n70 153 144\n220 190 255\n154 99 36\n255 250 200\n128 0 0\n170 255 195\n128 128 0\n255 216 177\n0 0 117\n169 169 169\n";
+//#endregion
+//#region src/palettes.ts
+/** Ordered palette of marker shapes, for distinguishing categorical groups */
+var markerPalette = [
+	Marker.Cross,
+	Marker.Diamond,
+	Marker.Square,
+	Marker.TriangleUp,
+	Marker.Star,
+	Marker.Clobber,
+	Marker.Disc,
+	Marker.HBar,
+	Marker.VBar,
+	Marker.TailedArrow,
+	Marker.TriangleDown,
+	Marker.Ring,
+	Marker.X,
+	Marker.Arrow,
+	Marker.Gaussian
+];
+/** Number of colors sampled from each continuous D3 color scheme */
+var sampledColorPaletteSize = 256;
+/**
+* Builds a color palette by sampling a continuous D3 color scheme
+*
+* @param id - Color palette ID, persisted in project configs
+* @param name - Human-readable color palette name
+* @param colorScheme - Maps a position within `[0, 1]` to a CSS color string
+* @returns The color palette, holding `sampledColorPaletteSize` colors
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function sampledColorPalette(id, name, colorScheme) {
+	return {
+		id,
+		name,
+		colors: ColorUtils.sampleColorScheme(colorScheme, sampledColorPaletteSize)
+	};
+}
+/**
+* Builds a color palette from a list of hex colors
+*
+* @param id - Color palette ID, persisted in project configs
+* @param name - Human-readable color palette name
+* @param hexColors - The colors making up the palette, in order
+* @returns The color palette
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function hexColorPalette(id, name, hexColors) {
+	return {
+		id,
+		name,
+		colors: hexColors.map((hex) => ColorUtils.fromHex(hex))
+	};
+}
+/** Color palettes suitable for continuous data */
+var continuousColorPalettes = [
+	/* @__PURE__ */ sampledColorPalette("viridis", "Viridis", interpolateViridis),
+	/* @__PURE__ */ sampledColorPalette("magma", "Magma", interpolateMagma),
+	/* @__PURE__ */ sampledColorPalette("inferno", "Inferno", interpolateInferno),
+	/* @__PURE__ */ sampledColorPalette("plasma", "Plasma", interpolatePlasma),
+	/* @__PURE__ */ sampledColorPalette("cividis", "Cividis", interpolateCividis),
+	/* @__PURE__ */ sampledColorPalette("turbo", "Turbo", interpolateTurbo),
+	/* @__PURE__ */ sampledColorPalette("blues", "Blues", interpolateBlues),
+	/* @__PURE__ */ sampledColorPalette("brbg", "BrBG", interpolateBrBG),
+	/* @__PURE__ */ sampledColorPalette("bugn", "BuGn", interpolateBuGn),
+	/* @__PURE__ */ sampledColorPalette("bupu", "BuPu", interpolateBuPu),
+	/* @__PURE__ */ sampledColorPalette("cool", "Cool", interpolateCool),
+	/* @__PURE__ */ sampledColorPalette("cubehelix", "Cubehelix", interpolateCubehelixDefault),
+	/* @__PURE__ */ sampledColorPalette("gnbu", "GnBu", interpolateGnBu),
+	/* @__PURE__ */ sampledColorPalette("greens", "Greens", interpolateGreens),
+	/* @__PURE__ */ sampledColorPalette("greys", "Greys", interpolateGreys),
+	/* @__PURE__ */ sampledColorPalette("oranges", "Oranges", interpolateOranges),
+	/* @__PURE__ */ sampledColorPalette("orrd", "OrRd", interpolateOrRd),
+	/* @__PURE__ */ sampledColorPalette("piyg", "PiYG", interpolatePiYG),
+	/* @__PURE__ */ sampledColorPalette("prgn", "PRGn", interpolatePRGn),
+	/* @__PURE__ */ sampledColorPalette("pubu", "PuBu", interpolatePuBu),
+	/* @__PURE__ */ sampledColorPalette("pubugn", "PuBuGn", interpolatePuBuGn),
+	/* @__PURE__ */ sampledColorPalette("puor", "PuOr", interpolatePuOr),
+	/* @__PURE__ */ sampledColorPalette("purd", "PuRd", interpolatePuRd),
+	/* @__PURE__ */ sampledColorPalette("purples", "Purples", interpolatePurples),
+	/* @__PURE__ */ sampledColorPalette("rainbow", "Rainbow", interpolateRainbow),
+	/* @__PURE__ */ sampledColorPalette("rdbu", "RdBu", interpolateRdBu),
+	/* @__PURE__ */ sampledColorPalette("rdgy", "RdGy", interpolateRdGy),
+	/* @__PURE__ */ sampledColorPalette("rdpu", "RdPu", interpolateRdPu),
+	/* @__PURE__ */ sampledColorPalette("rdylbu", "RdYlBu", interpolateRdYlBu),
+	/* @__PURE__ */ sampledColorPalette("rdylgn", "RdYlGn", interpolateRdYlGn),
+	/* @__PURE__ */ sampledColorPalette("reds", "Reds", interpolateReds),
+	/* @__PURE__ */ sampledColorPalette("sinebow", "Sinebow", interpolateSinebow),
+	/* @__PURE__ */ sampledColorPalette("spectral", "Spectral", interpolateSpectral),
+	/* @__PURE__ */ sampledColorPalette("warm", "Warm", interpolateWarm),
+	/* @__PURE__ */ sampledColorPalette("ylgn", "YlGn", interpolateYlGn),
+	/* @__PURE__ */ sampledColorPalette("ylgnbu", "YlGnBu", interpolateYlGnBu),
+	/* @__PURE__ */ sampledColorPalette("ylorbr", "YlOrBr", interpolateYlOrBr),
+	/* @__PURE__ */ sampledColorPalette("ylorrd", "YlOrRd", interpolateYlOrRd),
+	{
+		id: "batlow",
+		name: "Batlow",
+		colors: /* @__PURE__ */ ColorUtils.parsePalette(batlow_default)
+	}
+];
+/** Color palettes suitable for categorical data */
+var categoricalColorPalettes = [
+	{
+		id: "distinct",
+		name: "Distinct",
+		colors: /* @__PURE__ */ ColorUtils.parsePalette(distinct_default, { maxValue: 255 })
+	},
+	/* @__PURE__ */ hexColorPalette("category10", "Category 10", schemeCategory10),
+	/* @__PURE__ */ hexColorPalette("observable10", "Observable 10", schemeObservable10),
+	/* @__PURE__ */ hexColorPalette("tableau10", "Tableau 10", schemeTableau10),
+	/* @__PURE__ */ hexColorPalette("accent", "Accent", schemeAccent),
+	/* @__PURE__ */ hexColorPalette("dark2", "Dark 2", schemeDark2),
+	/* @__PURE__ */ hexColorPalette("paired", "Paired", schemePaired),
+	/* @__PURE__ */ hexColorPalette("pastel1", "Pastel 1", schemePastel1),
+	/* @__PURE__ */ hexColorPalette("pastel2", "Pastel 2", schemePastel2),
+	/* @__PURE__ */ hexColorPalette("set1", "Set 1", schemeSet1),
+	/* @__PURE__ */ hexColorPalette("set2", "Set 2", schemeSet2),
+	/* @__PURE__ */ hexColorPalette("set3", "Set 3", schemeSet3),
+	{
+		id: "batlowS",
+		name: "Batlow",
+		colors: /* @__PURE__ */ ColorUtils.parsePalette(batlowS_default)
+	}
+];
+/** All available color palettes, continuous and categorical */
+var colorPalettes = /* @__PURE__ */ continuousColorPalettes.concat(categoricalColorPalettes);
+/**
+* Looks up a color palette by ID
+*
+* @param colorPaletteId - The ID of the color palette
+* @returns The color palette, or `undefined` if no palette has the ID
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function findColorPalette(colorPaletteId) {
+	return colorPalettes.find((colorPalette) => colorPalette.id === colorPaletteId);
+}
+//#endregion
+export { ArrayUtils, AsyncUtils, BitUtils, ColorUtils, ConfigUtils, GeometryUtils, HashUtils, ImageChannelViewMode, ImageUtils, JSONUtils, Marker, MathUtils, NumberUtils, ProjectUtils, RandomUtils, SourceUtils, TableUtils, TransformUtils, annotatedDataSourceDefaults, categoricalColorPalettes, colorPalettes, continuousColorPalettes, createAnnotatedDataSource, createDataObject, createDataSource, createImage, createImageDataSource, createLabels, createLabelsDataSource, createLayer, createModel, createPoints, createPointsDataSource, createProject, createRenderedDataObject, createRenderedItemsDataObject, createRenderedRasterDataObject, createShapes, createShapesDataSource, createTable, createTableDataSource, dataObjectDefaults, dataSourceDefaults, defaultLabelColor, defaultLabelColorPalette, defaultLabelOpacity, defaultLabelVisibility, defaultPointColor, defaultPointMarker, defaultPointOpacity, defaultPointSize, defaultPointSizeUnit, defaultPointVisibility, defaultRandomSeed, defaultShapeFillColor, defaultShapeFillOpacity, defaultShapeFillVisibility, defaultShapeOpacity, defaultShapeStrokeColor, defaultShapeStrokeOpacity, defaultShapeStrokeVisibility, defaultShapeVisibility, findColorPalette, getActiveConfigSource, identityTransform, imageDataSourceDefaults, imageDefaults, isConstantConfig, isFromConfig, isGroupByConfig, isRandomConfig, labelsDataSourceDefaults, labelsDefaults, layerDefaults, markerPalette, modelDefaults, pointsDataSourceDefaults, pointsDefaults, projectDefaults, renderedDataObjectDefaults, renderedItemsDataObjectDefaults, renderedRasterDataObjectDefaults, shapesDataSourceDefaults, shapesDefaults, tableDataSourceDefaults, tableDefaults };