@marimo-team/marimo-export 0.0.0 → 0.0.1

package/dist/loader/arrow.d.mts

@@ -0,0 +1,10 @@
+import { j as OutputLoader } from "../types-D52GHn1Q.mjs";
+import { ExtractionOptions, Table } from "@uwdata/flechette";
+//#region ../loader-arrow/src/index.d.ts
+interface ArrowTableLoaderOptions {
+  readonly extraction?: ExtractionOptions;
+}
+/** Decode a verified Arrow IPC file as a Flechette table. */
+declare function arrowTableLoader(options?: ArrowTableLoaderOptions): OutputLoader<"apache.arrow.file.v1", Table>;
+//#endregion
+export { ArrowTableLoaderOptions, arrowTableLoader };

package/dist/loader/arrow.mjs

@@ -0,0 +1,38 @@
+import { n as defineOutputLoader } from "../loader-CDfnJ5Yb.mjs";
+import { CompressionType, setCompressionCodec, tableFromIPC } from "@uwdata/flechette";
+import { compress, decompress } from "lz4js";
+//#region ../loader-arrow/src/index.ts
+const MAX_DECOMPRESSED_BUFFER_BYTES = 536870912;
+/** Decode a verified Arrow IPC file as a Flechette table. */
+function arrowTableLoader(options = {}) {
+	const extraction = {
+		useBigInt: true,
+		...options.extraction
+	};
+	return defineOutputLoader({
+		codec: "apache.arrow.file.v1",
+		accepts: (_descriptor, mediaType) => mediaType.essence === "application/vnd.apache.arrow.file",
+		load({ payload, signal }) {
+			signal?.throwIfAborted();
+			registerLz4();
+			const table = tableFromIPC(payload, extraction);
+			signal?.throwIfAborted();
+			return table;
+		}
+	});
+}
+function registerLz4() {
+	setCompressionCodec(CompressionType.LZ4_FRAME, {
+		decode(bytes, uncompressedLength) {
+			if (!Number.isSafeInteger(uncompressedLength) || uncompressedLength < 0 || uncompressedLength > MAX_DECOMPRESSED_BUFFER_BYTES) throw new TypeError("Arrow LZ4 buffer exceeds the decompression limit.");
+			const result = decompress(bytes, uncompressedLength);
+			if (result.byteLength !== uncompressedLength) throw new TypeError("Arrow LZ4 buffer length does not match its declaration.");
+			return result;
+		},
+		encode(bytes) {
+			return compress(bytes);
+		}
+	});
+}
+//#endregion
+export { arrowTableLoader };

package/dist/loader/html.d.mts

@@ -0,0 +1,6 @@
+import { s as BlobAssetLoader } from "../types-D52GHn1Q.mjs";
+//#region src/loader/html.d.ts
+/** Decode a UTF-8 HTML BlobAsset into an inert string. */
+declare const htmlLoader: () => BlobAssetLoader<string>;
+//#endregion
+export { htmlLoader };

package/dist/loader/html.mjs

@@ -0,0 +1,10 @@
+import { t as defineBlobAssetLoader } from "../loader-CDfnJ5Yb.mjs";
+import { n as hasUtf8Charset, t as decodeUtf8Blob } from "../utf8-DI-jI2Nm.mjs";
+//#region src/loader/html.ts
+/** Decode a UTF-8 HTML BlobAsset into an inert string. */
+const htmlLoader = () => defineBlobAssetLoader({
+	mediaTypes: (mediaType) => mediaType.essence === "text/html" && hasUtf8Charset(mediaType),
+	load: decodeUtf8Blob
+});
+//#endregion
+export { htmlLoader };

package/dist/loader/json.d.mts

@@ -0,0 +1,6 @@
+import { H as JsonValue, j as OutputLoader } from "../types-D52GHn1Q.mjs";
+//#region src/loader/json.d.ts
+/** Return one detached, immutable JSON projection. */
+declare const jsonLoader: () => OutputLoader<"marimo.json.v1", JsonValue>;
+//#endregion
+export { jsonLoader };

package/dist/loader/json.mjs

@@ -0,0 +1,15 @@
+import { _ as portableJsonValue, n as defineOutputLoader } from "../loader-CDfnJ5Yb.mjs";
+//#region src/loader/json.ts
+/** Return one detached, immutable JSON projection. */
+const jsonLoader = () => defineOutputLoader({
+	codec: "marimo.json.v1",
+	accepts: (_descriptor, mediaType) => mediaType.essence === "application/vnd.marimo.json.v1+json",
+	load: ({ payload, signal }) => {
+		signal?.throwIfAborted();
+		const value = portableJsonValue(payload);
+		signal?.throwIfAborted();
+		return value;
+	}
+});
+//#endregion
+export { jsonLoader };

package/dist/loader/marimo-cell.d.mts

@@ -0,0 +1,7 @@
+import { j as OutputLoader } from "../types-D52GHn1Q.mjs";
+import { o as MarimoCellSnapshot } from "../marimo-snapshot-Df66Xan0.mjs";
+//#region src/loader/marimo-cell.d.ts
+/** Decode one inert complete-cell snapshot. */
+declare const marimoCellLoader: () => OutputLoader<"marimo.cell.v1", MarimoCellSnapshot>;
+//#endregion
+export { marimoCellLoader };

package/dist/loader/marimo-cell.mjs

@@ -0,0 +1,16 @@
+import { n as defineOutputLoader } from "../loader-CDfnJ5Yb.mjs";
+import { t as parseMarimoCellSnapshot } from "../marimo-snapshot--nNjqcq_.mjs";
+//#region src/loader/marimo-cell.ts
+/** Decode one inert complete-cell snapshot. */
+const marimoCellLoader = () => defineOutputLoader({
+	codec: "marimo.cell.v1",
+	accepts: (_descriptor, mediaType) => mediaType.essence === "application/vnd.marimo.cell.v1+json",
+	load: ({ payload, signal }) => {
+		signal?.throwIfAborted();
+		const snapshot = parseMarimoCellSnapshot(payload);
+		signal?.throwIfAborted();
+		return snapshot;
+	}
+});
+//#endregion
+export { marimoCellLoader };

package/dist/loader/marimo-output.d.mts

@@ -0,0 +1,7 @@
+import { j as OutputLoader } from "../types-D52GHn1Q.mjs";
+import { m as MarimoOutputSnapshot } from "../marimo-snapshot-Df66Xan0.mjs";
+//#region src/loader/marimo-output.d.ts
+/** Decode one inert Marimo output snapshot. */
+declare const marimoOutputLoader: () => OutputLoader<"marimo.output.v1", MarimoOutputSnapshot>;
+//#endregion
+export { marimoOutputLoader };

package/dist/loader/marimo-output.mjs

@@ -0,0 +1,16 @@
+import { n as defineOutputLoader } from "../loader-CDfnJ5Yb.mjs";
+import { n as parseMarimoOutputSnapshot } from "../marimo-snapshot--nNjqcq_.mjs";
+//#region src/loader/marimo-output.ts
+/** Decode one inert Marimo output snapshot. */
+const marimoOutputLoader = () => defineOutputLoader({
+	codec: "marimo.output.v1",
+	accepts: (_descriptor, mediaType) => mediaType.essence === "application/vnd.marimo.output.v1+json",
+	load: ({ payload, signal }) => {
+		signal?.throwIfAborted();
+		const snapshot = parseMarimoOutputSnapshot(payload);
+		signal?.throwIfAborted();
+		return snapshot;
+	}
+});
+//#endregion
+export { marimoOutputLoader };

package/dist/loader/numpy.d.mts

@@ -0,0 +1,19 @@
+import { j as OutputLoader } from "../types-D52GHn1Q.mjs";
+//#region ../loader-numpy/src/index.d.ts
+type NumpyDTypeKind = "boolean" | "signed-integer" | "unsigned-integer" | "floating-point" | "complex-floating-point";
+interface NumpyDType {
+  readonly descriptor: string;
+  readonly kind: NumpyDTypeKind;
+  readonly itemSize: number;
+  readonly byteOrder: "little" | "big" | "not-applicable";
+}
+interface NumpyArray {
+  readonly data: ArrayBufferView;
+  readonly shape: readonly number[];
+  readonly dtype: NumpyDType;
+  readonly fortranOrder: boolean;
+}
+/** Decode a verified portable NPY asset. */
+declare function numpyLoader(): OutputLoader<"numpy.npy.v1", NumpyArray>;
+//#endregion
+export { NumpyArray, NumpyDType, NumpyDTypeKind, numpyLoader };

package/dist/loader/numpy.mjs

@@ -0,0 +1,168 @@
+import { n as defineOutputLoader } from "../loader-CDfnJ5Yb.mjs";
+//#region ../loader-numpy/src/index.ts
+const MAGIC = [
+	147,
+	78,
+	85,
+	77,
+	80,
+	89
+];
+const MAX_HEADER_BYTES = 1048576;
+const MAX_TYPED_ARRAY_LENGTH = 4294967295;
+const decoderLatin1 = new TextDecoder("latin1", { fatal: true });
+const decoderUtf8 = new TextDecoder("utf-8", { fatal: true });
+const hostLittleEndian = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
+/** Decode a verified portable NPY asset. */
+function numpyLoader() {
+	return defineOutputLoader({
+		codec: "numpy.npy.v1",
+		accepts: (_descriptor, mediaType) => mediaType.essence === "application/x-npy",
+		load({ payload, signal }) {
+			signal?.throwIfAborted();
+			const result = decodeNpy(payload);
+			signal?.throwIfAborted();
+			return result;
+		}
+	});
+}
+function decodeNpy(bytes) {
+	if (bytes.byteLength < 10 || MAGIC.some((value, index) => bytes[index] !== value)) throw new TypeError("NPY payload has invalid magic.");
+	const major = bytes[6];
+	const minor = bytes[7];
+	if (minor !== 0 || major !== 1 && major !== 2 && major !== 3) throw new TypeError(`NPY version ${major}.${minor} is unsupported.`);
+	const lengthBytes = major === 1 ? 2 : 4;
+	const headerStart = 8 + lengthBytes;
+	if (bytes.byteLength < headerStart) throw new TypeError("NPY header is truncated.");
+	const headerLength = lengthBytes === 2 ? readUint16(bytes, 8) : readUint32(bytes, 8);
+	if (headerLength === 0 || headerLength > MAX_HEADER_BYTES) throw new TypeError("NPY header length is outside the supported range.");
+	const headerEnd = headerStart + headerLength;
+	if (!Number.isSafeInteger(headerEnd) || headerEnd > bytes.byteLength) throw new TypeError("NPY header is truncated.");
+	const headerBytes = bytes.subarray(headerStart, headerEnd);
+	const parsed = parseHeader((major === 3 ? decoderUtf8 : decoderLatin1).decode(headerBytes).trim());
+	const dtype = parseDtype(parsed.descriptor);
+	const count = elementCount(parsed.shape);
+	if (headerEnd + safeProduct(count, dtype.itemSize, "NPY payload size") !== bytes.byteLength) throw new TypeError("NPY payload length does not match its shape and dtype.");
+	const data = decodePayload(bytes.subarray(headerEnd), count, dtype);
+	return Object.freeze({
+		data,
+		shape: Object.freeze(parsed.shape),
+		dtype: Object.freeze(dtype),
+		fortranOrder: parsed.fortranOrder
+	});
+}
+function parseHeader(header) {
+	const match = /^\{\s*['"]descr['"]\s*:\s*(['"])([^'"]+)\1\s*,\s*['"]fortran_order['"]\s*:\s*(True|False)\s*,\s*['"]shape['"]\s*:\s*\(([^)]*)\)\s*,?\s*\}$/u.exec(header);
+	if (match === null) throw new TypeError("NPY header literal is invalid.");
+	const dimensions = match[4].trim();
+	const shape = dimensions.length === 0 ? [] : dimensions.split(",").map((value) => value.trim()).filter((value) => value.length > 0).map((value) => {
+		if (!/^\d+$/u.test(value)) throw new TypeError("NPY shape is invalid.");
+		const dimension = Number(value);
+		if (!Number.isSafeInteger(dimension)) throw new TypeError("NPY shape is unsafe.");
+		return dimension;
+	});
+	return {
+		descriptor: match[2],
+		fortranOrder: match[3] === "True",
+		shape
+	};
+}
+function parseDtype(descriptor) {
+	const match = /^([<>=|])([?biufc])(\d*)$/u.exec(descriptor);
+	if (match === null) throw new TypeError(`NPY dtype ${JSON.stringify(descriptor)} is unsupported.`);
+	const marker = match[1];
+	const code = match[2];
+	const itemSize = Number(match[3] || "1");
+	if (!Number.isSafeInteger(itemSize) || itemSize <= 0) throw new TypeError("NPY dtype has an invalid item size.");
+	const kind = dtypeKind(code);
+	if (!(code === "?" && itemSize === 1 || code === "b" && itemSize === 1 || (code === "i" || code === "u") && [
+		1,
+		2,
+		4,
+		8
+	].includes(itemSize) || code === "f" && [
+		2,
+		4,
+		8
+	].includes(itemSize) || code === "c" && [8, 16].includes(itemSize))) throw new TypeError(`NPY dtype ${JSON.stringify(descriptor)} is unsupported.`);
+	if (marker === "|" && itemSize !== 1) throw new TypeError("NPY no-endian dtype must use one-byte items.");
+	return {
+		descriptor,
+		kind,
+		itemSize,
+		byteOrder: itemSize === 1 ? "not-applicable" : marker === ">" ? "big" : marker === "<" ? "little" : hostLittleEndian ? "little" : "big"
+	};
+}
+function dtypeKind(code) {
+	if (code === "?" || code === "b") return "boolean";
+	if (code === "i") return "signed-integer";
+	if (code === "u") return "unsigned-integer";
+	if (code === "f") return "floating-point";
+	return "complex-floating-point";
+}
+function elementCount(shape) {
+	let count = 1;
+	for (const dimension of shape) count = safeProduct(count, dimension, "NPY shape");
+	return count;
+}
+function safeProduct(left, right, label) {
+	const result = left * right;
+	if (!Number.isSafeInteger(result) || result < 0) throw new TypeError(`${label} is unsafe.`);
+	return result;
+}
+function decodePayload(bytes, count, dtype) {
+	const code = dtype.descriptor[1];
+	if (count > MAX_TYPED_ARRAY_LENGTH) throw new TypeError("NPY array is too large.");
+	if (dtype.itemSize === 1) {
+		const copy = bytes.slice();
+		if (code === "i") return new Int8Array(copy.buffer);
+		return copy;
+	}
+	const littleEndian = dtype.byteOrder === "little";
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	if (code === "i") {
+		if (dtype.itemSize === 2) return fillNumbers(Int16Array, count, (offset) => view.getInt16(offset, littleEndian));
+		if (dtype.itemSize === 4) return fillNumbers(Int32Array, count, (offset) => view.getInt32(offset, littleEndian));
+		return fillBigInts(BigInt64Array, count, (offset) => view.getBigInt64(offset, littleEndian));
+	}
+	if (code === "u") {
+		if (dtype.itemSize === 2) return fillNumbers(Uint16Array, count, (offset) => view.getUint16(offset, littleEndian));
+		if (dtype.itemSize === 4) return fillNumbers(Uint32Array, count, (offset) => view.getUint32(offset, littleEndian));
+		return fillBigInts(BigUint64Array, count, (offset) => view.getBigUint64(offset, littleEndian));
+	}
+	if (code === "f") {
+		if (dtype.itemSize === 2) return fillNumbers(Float32Array, count, (offset) => decodeFloat16(view.getUint16(offset, littleEndian)), 2);
+		if (dtype.itemSize === 4) return fillNumbers(Float32Array, count, (offset) => view.getFloat32(offset, littleEndian));
+		return fillNumbers(Float64Array, count, (offset) => view.getFloat64(offset, littleEndian));
+	}
+	const components = safeProduct(count, 2, "NPY complex component count");
+	if (components > MAX_TYPED_ARRAY_LENGTH) throw new TypeError("NPY array is too large.");
+	if (dtype.itemSize === 8) return fillNumbers(Float32Array, components, (offset) => view.getFloat32(offset, littleEndian));
+	return fillNumbers(Float64Array, components, (offset) => view.getFloat64(offset, littleEndian));
+}
+function fillNumbers(Constructor, length, read, sourceStride = Constructor.BYTES_PER_ELEMENT) {
+	const result = new Constructor(length);
+	for (let index = 0; index < length; index += 1) result[index] = read(index * sourceStride);
+	return result;
+}
+function fillBigInts(Constructor, length, read) {
+	const result = new Constructor(length);
+	for (let index = 0; index < length; index += 1) result[index] = read(index * Constructor.BYTES_PER_ELEMENT);
+	return result;
+}
+function decodeFloat16(value) {
+	const sign = (value & 32768) === 0 ? 1 : -1;
+	const exponent = value >>> 10 & 31;
+	const fraction = value & 1023;
+	if (exponent === 0) return sign * 2 ** -14 * (fraction / 1024);
+	if (exponent === 31) return fraction === 0 ? sign * Infinity : NaN;
+	return sign * 2 ** (exponent - 15) * (1 + fraction / 1024);
+}
+function readUint16(bytes, offset) {
+	return bytes[offset] | bytes[offset + 1] << 8;
+}
+function readUint32(bytes, offset) {
+	return bytes[offset] + bytes[offset + 1] * 256 + bytes[offset + 2] * 65536 + bytes[offset + 3] * 16777216;
+}
+//#endregion
+export { numpyLoader };

package/dist/loader/parquet.d.mts

@@ -0,0 +1,14 @@
+import { s as BlobAssetLoader } from "../types-D52GHn1Q.mjs";
+import { Compressors, ParquetReadOptions } from "hyparquet";
+//#region ../loader-parquet/src/index.d.ts
+interface ParquetRowsLoaderOptions extends Omit<ParquetReadOptions, "file" | "onComplete" | "rowFormat"> {
+  readonly compressors?: Compressors;
+}
+type ParquetValue = null | boolean | number | bigint | string | Date | Uint8Array | readonly ParquetValue[] | ParquetRow;
+interface ParquetRow {
+  readonly [column: string]: ParquetValue;
+}
+/** Read a verified Parquet BlobAsset into row objects. */
+declare function parquetRowsLoader(options?: ParquetRowsLoaderOptions): BlobAssetLoader<readonly ParquetRow[]>;
+//#endregion
+export { type ParquetRow, type ParquetRowsLoaderOptions, type ParquetValue, parquetRowsLoader };

package/dist/loader/parquet.mjs

@@ -0,0 +1,43 @@
+import { t as defineBlobAssetLoader } from "../loader-CDfnJ5Yb.mjs";
+import { parquetReadObjects } from "hyparquet";
+//#region ../loader-parquet/src/index.ts
+/** Read a verified Parquet BlobAsset into row objects. */
+function parquetRowsLoader(options = {}) {
+	return parquetRowsLoaderWith(parquetReadObjects, options);
+}
+/** @internal */
+function parquetRowsLoaderWith(readObjects, options = {}) {
+	const defaults = { ...options };
+	return defineBlobAssetLoader({
+		mediaTypes: ["application/vnd.apache.parquet", "application/x-parquet"],
+		async load({ payload, signal }) {
+			signal?.throwIfAborted();
+			const data = payload.data.slice();
+			const rows = await raceAbort(readObjects({
+				...defaults,
+				file: data.buffer
+			}), signal);
+			signal?.throwIfAborted();
+			return Object.freeze(rows);
+		}
+	});
+}
+async function raceAbort(task, signal) {
+	if (signal === void 0) return task;
+	signal.throwIfAborted();
+	let onAbort;
+	const aborted = new Promise((_resolve, reject) => {
+		onAbort = () => reject(abortReason(signal));
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+	try {
+		return await Promise.race([task, aborted]);
+	} finally {
+		if (onAbort !== void 0) signal.removeEventListener("abort", onAbort);
+	}
+}
+function abortReason(signal) {
+	return signal.reason instanceof Error ? signal.reason : Object.assign(/* @__PURE__ */ new Error("Parquet load was cancelled."), { name: "AbortError" });
+}
+//#endregion
+export { parquetRowsLoader };

package/dist/loader/text.d.mts

@@ -0,0 +1,6 @@
+import { s as BlobAssetLoader } from "../types-D52GHn1Q.mjs";
+//#region src/loader/text.d.ts
+/** Decode a UTF-8 text BlobAsset. */
+declare const textLoader: () => BlobAssetLoader<string>;
+//#endregion
+export { textLoader };

package/dist/loader/text.mjs

@@ -0,0 +1,10 @@
+import { t as defineBlobAssetLoader } from "../loader-CDfnJ5Yb.mjs";
+import { n as hasUtf8Charset, t as decodeUtf8Blob } from "../utf8-DI-jI2Nm.mjs";
+//#region src/loader/text.ts
+/** Decode a UTF-8 text BlobAsset. */
+const textLoader = () => defineBlobAssetLoader({
+	mediaTypes: (mediaType) => mediaType.type === "text" && mediaType.essence !== "text/html" && hasUtf8Charset(mediaType),
+	load: decodeUtf8Blob
+});
+//#endregion
+export { textLoader };

package/dist/loader/vegalite.d.mts

@@ -0,0 +1,18 @@
+import { B as JsonObject, S as MountedView, s as BlobAssetLoader } from "../types-D52GHn1Q.mjs";
+import { EmbedOptions, Result } from "vega-embed";
+//#region ../loader-vegalite/src/index.d.ts
+type VegaLiteSpec = Readonly<JsonObject>;
+type VegaLiteMountOptions = EmbedOptions & {
+  readonly signal?: AbortSignal;
+};
+interface MountedVegaLite extends MountedView {
+  readonly result: Result;
+}
+interface VegaLiteChart {
+  readonly spec: VegaLiteSpec;
+  mount(element: HTMLElement, options?: VegaLiteMountOptions): Promise<MountedVegaLite>;
+}
+/** Load an exported Vega-Lite value and prepare it for browser mounting. */
+declare function vegaLiteLoader(defaults?: EmbedOptions): BlobAssetLoader<VegaLiteChart>;
+//#endregion
+export { type MountedVegaLite, type VegaLiteChart, type VegaLiteMountOptions, type VegaLiteSpec, vegaLiteLoader };

package/dist/loader/vegalite.mjs

@@ -0,0 +1,98 @@
+import { g as portableJsonObject, t as defineBlobAssetLoader } from "../loader-CDfnJ5Yb.mjs";
+//#region ../loader-vegalite/src/index.ts
+const MEDIA_TYPE = /^application\/vnd\.vegalite\.v[1-9]\d*\+json$/u;
+const OWNED_CLASSES = ["vega-embed", "has-actions"];
+/** Load an exported Vega-Lite value and prepare it for browser mounting. */
+function vegaLiteLoader(defaults = {}) {
+	return vegaLiteLoaderWith(async () => (await import("vega-embed")).default, defaults);
+}
+/** @internal */
+function vegaLiteLoaderWith(loadEmbed, defaults = {}) {
+	const defaultOptions = { ...defaults };
+	return defineBlobAssetLoader({
+		mediaTypes: (mediaType) => MEDIA_TYPE.test(mediaType.essence),
+		load(input) {
+			return loadChart(input, defaultOptions, loadEmbed);
+		}
+	});
+}
+async function loadChart(input, defaults, loadEmbed) {
+	input.signal?.throwIfAborted();
+	const template = portableJsonObject(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(input.payload.data)), "Vega-Lite output");
+	input.signal?.throwIfAborted();
+	return Object.freeze({
+		spec: template,
+		async mount(element, options = {}) {
+			const { signal, ...embedOptions } = options;
+			signal?.throwIfAborted();
+			const container = element.ownerDocument.createElement("div");
+			element.replaceChildren(container);
+			let embedTask;
+			let result;
+			try {
+				const embed = await raceAbort(loadEmbed(), signal, "Vega-Lite mount was cancelled.");
+				signal?.throwIfAborted();
+				embedTask = embed(container, visualizationSpec(template), {
+					renderer: "canvas",
+					...defaults,
+					...embedOptions
+				});
+				result = await raceAbort(embedTask, signal, "Vega-Lite mount was cancelled.");
+				signal?.throwIfAborted();
+			} catch (error) {
+				if (embedTask !== void 0) embedTask.then((lateResult) => finalizeLate(lateResult, container), () => void 0);
+				clearMount(container);
+				throw error;
+			}
+			let disposed = false;
+			return Object.freeze({
+				result,
+				dispose() {
+					if (disposed) return;
+					disposed = true;
+					try {
+						result.finalize();
+					} finally {
+						clearMount(container);
+					}
+				}
+			});
+		}
+	});
+}
+async function raceAbort(task, signal, message) {
+	if (signal === void 0) return task;
+	signal.throwIfAborted();
+	let onAbort;
+	const aborted = new Promise((_resolve, reject) => {
+		onAbort = () => reject(abortReason(signal, message));
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+	try {
+		return await Promise.race([task, aborted]);
+	} finally {
+		if (onAbort !== void 0) signal.removeEventListener("abort", onAbort);
+	}
+}
+function abortReason(signal, message) {
+	return signal.reason instanceof Error ? signal.reason : Object.assign(new Error(message), { name: "AbortError" });
+}
+function finalizeLate(result, container) {
+	try {
+		result.finalize();
+	} catch (error) {
+		console.error("Vega-Lite finalized after its mount was cancelled.", error);
+	} finally {
+		clearMount(container);
+	}
+}
+function clearMount(container) {
+	container.replaceChildren();
+	container.classList.remove(...OWNED_CLASSES);
+	container.remove();
+}
+function visualizationSpec(value) {
+	return structuredClone(value);
+}
+//#endregion
+export { vegaLiteLoader };