@marimo-team/marimo-export 0.0.0 → 0.0.1

package/dist/loader-CDfnJ5Yb.mjs

@@ -0,0 +1,441 @@
+//#region ../portable-json/src/types.ts
+const MAX_JSON_VALUES = 1e5;
+//#endregion
+//#region ../portable-json/src/convert.ts
+const MAX_DIAGNOSTIC_PATH = 512;
+const TRUNCATED_PATH = "...";
+/** Return a detached portable JSON value. */
+function portableJsonValue(input, path = "value") {
+	return convertValue(input, path, 0, {
+		active: /* @__PURE__ */ new WeakSet(),
+		count: 0
+	});
+}
+/** Return a detached portable JSON object. */
+function portableJsonObject(input, path = "value") {
+	const value = portableJsonValue(input, path);
+	if (!isJsonObject(value)) throw new TypeError(`${path} must be an object.`);
+	return value;
+}
+function convertValue(input, path, depth, state) {
+	if (depth > 256) throw new TypeError(`${path} exceeds the maximum JSON nesting depth.`);
+	countValue(state, path);
+	if (input === null) return null;
+	if (isBoolean(input)) return input;
+	if (isString(input)) return unicodeScalar(input, path);
+	if (isNumber(input)) return portableNumber(input, path);
+	if (Array.isArray(input)) return convertArray(input, path, depth, state);
+	if (!isJsonObject(input)) throw new TypeError(`${path} must be JSON-compatible.`);
+	return convertObject(input, path, depth, state);
+}
+function convertArray(input, path, depth, state) {
+	enterContainer(input, path, state);
+	try {
+		if (input.length > 1e5 - state.count) throw new TypeError(`${path} exceeds the maximum JSON value count.`);
+		const values = [];
+		for (let index = 0; index < input.length; index += 1) {
+			if (!Object.hasOwn(input, index)) throw new TypeError(`${childPath(path, `[${index}]`)} must be present.`);
+			values.push(convertValue(input[index], childPath(path, `[${index}]`), depth + 1, state));
+		}
+		return Object.freeze(values);
+	} finally {
+		state.active.delete(input);
+	}
+}
+function convertObject(input, path, depth, state) {
+	enterContainer(input, path, state);
+	try {
+		return Object.freeze(Object.fromEntries(Object.entries(input).map(([key, item]) => {
+			const keyPath = childPath(path, "<object key>");
+			countValue(state, keyPath);
+			unicodeScalar(key, keyPath);
+			return [key, convertValue(item, childPath(path, key), depth + 1, state)];
+		})));
+	} finally {
+		state.active.delete(input);
+	}
+}
+function enterContainer(value, path, state) {
+	if (state.active.has(value)) throw new TypeError(`${path} contains a cyclic container.`);
+	state.active.add(value);
+}
+function countValue(state, path) {
+	state.count += 1;
+	if (state.count > 1e5) throw new TypeError(`${path} exceeds the maximum JSON value count.`);
+}
+function portableNumber(value, path) {
+	if (!Number.isFinite(value)) throw new TypeError(`${path} must not contain NaN or infinity.`);
+	if (Number.isInteger(value) && !Number.isSafeInteger(value)) throw new TypeError(`${path} integer must be within the JavaScript safe range.`);
+	return Object.is(value, -0) ? 0 : value;
+}
+function unicodeScalar(value, path) {
+	for (let index = 0; index < value.length; index += 1) {
+		const code = value.charCodeAt(index);
+		if (code >= 55296 && code <= 56319) {
+			const next = value.charCodeAt(index + 1);
+			if (next >= 56320 && next <= 57343) {
+				index += 1;
+				continue;
+			}
+			throw new TypeError(`${path} must contain Unicode scalar values.`);
+		}
+		if (code >= 56320 && code <= 57343) throw new TypeError(`${path} must contain Unicode scalar values.`);
+	}
+	return value;
+}
+function isBoolean(value) {
+	return Object.prototype.toString.call(value) === "[object Boolean]";
+}
+function isString(value) {
+	return Object.prototype.toString.call(value) === "[object String]";
+}
+function isNumber(value) {
+	return Object.prototype.toString.call(value) === "[object Number]";
+}
+function isJsonObject(value) {
+	return value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
+}
+function childPath(path, segment) {
+	if (path === TRUNCATED_PATH || path.length >= MAX_DIAGNOSTIC_PATH) return TRUNCATED_PATH;
+	const shown = boundedSegment(segment, MAX_DIAGNOSTIC_PATH - path.length - 1);
+	return shown.length === 0 ? TRUNCATED_PATH : `${path}.${shown}`;
+}
+function boundedSegment(value, maximumLength) {
+	if (maximumLength < 2) return "";
+	const quoted = JSON.stringify(value);
+	if (quoted.length <= maximumLength) return quoted;
+	if (maximumLength < 5) return "\"\"";
+	return `${quoted.slice(0, maximumLength - 4)}..."`;
+}
+//#endregion
+//#region src/value-types.ts
+function isPrimitiveWithPrototype(value, prototype) {
+	const boxed = Object(value);
+	return boxed !== value && Object.getPrototypeOf(boxed) === prototype;
+}
+function isStringValue(value) {
+	return isPrimitiveWithPrototype(value, String.prototype);
+}
+function isNumberValue(value) {
+	return isPrimitiveWithPrototype(value, Number.prototype);
+}
+function isJsonString(value) {
+	return isStringValue(value);
+}
+function isJsonNumber(value) {
+	return isNumberValue(value);
+}
+function isJsonBoolean(value) {
+	return isBooleanValue(value);
+}
+function isBooleanValue(value) {
+	return isPrimitiveWithPrototype(value, Boolean.prototype);
+}
+function isRecordValue(value) {
+	return value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
+}
+function isPropertyOwner(value) {
+	return value !== null && Object(value) === value;
+}
+function isCallableValue(value) {
+	try {
+		Function.prototype.toString.call(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/types.ts
+const NOTEBOOK_EXPORT_ERROR_BRAND = Symbol.for("@marimo-team/marimo-export.NotebookExportError.v1");
+const NOTEBOOK_EXPORT_ERROR_CODE_SET = /* @__PURE__ */ new Set([
+	"abort",
+	"asset_invalid",
+	"decode_failed",
+	"integrity_failed",
+	"loader_ambiguous",
+	"loader_invalid",
+	"loader_unavailable",
+	"output_not_found",
+	"output_representation_changed",
+	"export_invalid",
+	"export_noncanonical",
+	"read_failed",
+	"read_limit_exceeded",
+	"state_input_invalid",
+	"state_not_found",
+	"state_unavailable"
+]);
+var NotebookExportError = class extends Error {
+	code;
+	details;
+	cause;
+	constructor(code, message, options = {}) {
+		if (!isStringValue(code) || !NOTEBOOK_EXPORT_ERROR_CODE_SET.has(code)) throw new TypeError("NotebookExportError code must be a known code.");
+		if (!isStringValue(message)) throw new TypeError("NotebookExportError message must be a string.");
+		super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+		Object.defineProperty(this, NOTEBOOK_EXPORT_ERROR_BRAND, { value: true });
+		this.name = "NotebookExportError";
+		this.code = code;
+		this.cause = options.cause;
+		this.details = options.details === void 0 ? void 0 : portableJsonObject(options.details);
+		Object.freeze(this);
+	}
+};
+function isNotebookExportError(value) {
+	if (!isPropertyOwner(value)) return false;
+	try {
+		if (!(NOTEBOOK_EXPORT_ERROR_BRAND in value) || !("code" in value)) return false;
+		if (!("details" in value) || !("name" in value) || !("message" in value)) return false;
+		const code = value.code;
+		const details = value.details;
+		if (value[NOTEBOOK_EXPORT_ERROR_BRAND] !== true || value.name !== "NotebookExportError" || !isStringValue(value.message) || !isStringValue(code) || !NOTEBOOK_EXPORT_ERROR_CODE_SET.has(code)) return false;
+		if (details !== void 0) portableJsonObject(details, "NotebookExportError.details");
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/media-type.ts
+const TOKEN = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u;
+const PRINTABLE_ASCII = /^[\u0020-\u007e]+$/u;
+const encoder = new TextEncoder();
+function parseMediaType(raw) {
+	try {
+		if (encoder.encode(raw).byteLength > 1024 || !PRINTABLE_ASCII.test(raw) || raw !== raw.trim()) throw new TypeError("Media type must contain at most 1,024 printable ASCII bytes.");
+		return new MediaTypeParser(raw).parse();
+	} catch (error) {
+		if (isNotebookExportError(error)) throw error;
+		throw new NotebookExportError("export_invalid", "Export media type is invalid.", { cause: error });
+	}
+}
+var MediaTypeParser = class {
+	#raw;
+	#offset = 0;
+	constructor(raw) {
+		this.#raw = raw;
+	}
+	parse() {
+		const type = this.token().toLowerCase();
+		this.expect("/");
+		const subtype = this.token().toLowerCase();
+		const parameters = /* @__PURE__ */ new Map();
+		this.whitespace();
+		while (!this.done) {
+			this.expect(";");
+			this.whitespace();
+			const name = this.token().toLowerCase();
+			this.whitespace();
+			this.expect("=");
+			this.whitespace();
+			const value = this.peek() === "\"" ? this.quoted() : this.token();
+			if (parameters.has(name)) throw new TypeError("Media type parameter is repeated.");
+			parameters.set(name, value);
+			this.whitespace();
+		}
+		return Object.freeze({
+			raw: this.#raw,
+			essence: `${type}/${subtype}`,
+			type,
+			subtype,
+			parameters: new FrozenMap(parameters)
+		});
+	}
+	token() {
+		const start = this.#offset;
+		while (!this.done && TOKEN.test(this.#raw[this.#offset])) this.#offset += 1;
+		if (this.#offset === start) throw new TypeError("Media type token is missing.");
+		return this.#raw.slice(start, this.#offset);
+	}
+	quoted() {
+		this.expect("\"");
+		let result = "";
+		while (!this.done) {
+			const character = this.#raw[this.#offset++];
+			if (character === "\"") return result;
+			if (character === "\\") {
+				if (this.done) throw new TypeError("Media type quoted string is truncated.");
+				result += this.#raw[this.#offset++];
+				continue;
+			}
+			if (character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127) throw new TypeError("Media type quoted string contains a control character.");
+			result += character;
+		}
+		throw new TypeError("Media type quoted string is unterminated.");
+	}
+	whitespace() {
+		while (this.peek() === " " || this.peek() === "	") this.#offset += 1;
+	}
+	expect(value) {
+		if (this.#raw[this.#offset] !== value) throw new TypeError(`Expected ${value}.`);
+		this.#offset += 1;
+	}
+	peek() {
+		return this.#raw[this.#offset];
+	}
+	get done() {
+		return this.#offset >= this.#raw.length;
+	}
+};
+var FrozenMap = class {
+	#map;
+	constructor(map) {
+		this.#map = map;
+		Object.freeze(this);
+	}
+	get size() {
+		return this.#map.size;
+	}
+	get(key) {
+		return this.#map.get(key);
+	}
+	has(key) {
+		return this.#map.has(key);
+	}
+	entries() {
+		return this.#map.entries();
+	}
+	keys() {
+		return this.#map.keys();
+	}
+	values() {
+		return this.#map.values();
+	}
+	forEach = (callbackfn, thisArg) => {
+		for (const [key, value] of this.#map) callbackfn.call(thisArg, value, key, this);
+	};
+	[Symbol.iterator]() {
+		return this.#map[Symbol.iterator]();
+	}
+};
+//#endregion
+//#region src/loader.ts
+const CODECS = /* @__PURE__ */ new Set([
+	"marimo.scalar.v1",
+	"marimo.json.v1",
+	"marimo.output.v1",
+	"marimo.cell.v1",
+	"numpy.npy.v1",
+	"apache.arrow.file.v1",
+	"marimo.blob-asset.msgpack.v1"
+]);
+function defineOutputLoader(loader) {
+	if (!isRecordValue(loader) || !CODECS.has(loader.codec) || !hasCallableMember(loader, "accepts") || !hasCallableMember(loader, "load")) throw new TypeError("OutputLoader must define a supported codec, accepts, and load.");
+	return Object.freeze(loader);
+}
+function defineBlobAssetLoader(definition) {
+	if (!isRecordValue(definition) || !hasCallableMember(definition, "load")) throw new TypeError("BlobAssetLoader must define mediaTypes and load.");
+	let accepts;
+	if (isMediaTypePredicate(definition.mediaTypes)) accepts = definition.mediaTypes;
+	else {
+		const values = isMediaTypeString(definition.mediaTypes) ? [definition.mediaTypes] : definition.mediaTypes;
+		if (!Array.isArray(values) || values.length === 0) throw new TypeError("BlobAssetLoader mediaTypes must not be empty.");
+		const essences = new Set(values.map((value) => parseMediaType(value).essence));
+		accepts = (mediaType) => essences.has(mediaType.essence);
+	}
+	return defineOutputLoader({
+		codec: "marimo.blob-asset.msgpack.v1",
+		accepts: (_descriptor, mediaType) => accepts(mediaType),
+		load: (input) => definition.load(input)
+	});
+}
+function resolveOutputLoader(output, loaders) {
+	if (!Array.isArray(loaders)) throw new TypeError("loaders must be an array.");
+	const matches = [];
+	for (const loader of loaders) {
+		if (!isRecordValue(loader) || loader.codec !== output.codec) continue;
+		if (!hasCallableMember(loader, "accepts") || !hasCallableMember(loader, "load")) throw invalidLoader(output, /* @__PURE__ */ new TypeError("Loader methods are missing."));
+		let accepted;
+		try {
+			accepted = loader.accepts(output.descriptor, output.mediaType);
+		} catch (error) {
+			throw invalidLoader(output, error);
+		}
+		if (!isBooleanValue(accepted)) throw invalidLoader(output, /* @__PURE__ */ new TypeError("Loader accepts must return a boolean."));
+		if (accepted) matches.push(loader);
+	}
+	if (matches.length === 0) throw new NotebookExportError("loader_unavailable", `No OutputLoader accepts ${output.codec} with ${output.mediaType.essence}.`, { details: {
+		output: output.name,
+		codec: output.codec,
+		mediaType: output.mediaType.raw
+	} });
+	if (matches.length > 1) throw new NotebookExportError("loader_ambiguous", `Multiple OutputLoaders accept ${output.codec} with ${output.mediaType.essence}.`, { details: {
+		output: output.name,
+		codec: output.codec,
+		mediaType: output.mediaType.raw,
+		matches: matches.length
+	} });
+	return matches[0];
+}
+function scalarLoader() {
+	return defineOutputLoader({
+		codec: "marimo.scalar.v1",
+		accepts: () => true,
+		load: ({ payload }) => payload
+	});
+}
+function imageLoader() {
+	return defineBlobAssetLoader({
+		mediaTypes: (mediaType) => mediaType.type === "image",
+		load: ({ payload }) => Object.freeze({ async mount(element, options = {}) {
+			options.signal?.throwIfAborted();
+			const blob = new Blob([payload.data.slice()], { type: payload.mediaType.raw });
+			const url = URL.createObjectURL(blob);
+			const image = document.createElement("img");
+			image.src = url;
+			image.alt = payload.filename ?? "";
+			image.decoding = "async";
+			let disposed = false;
+			const dispose = () => {
+				if (disposed) return;
+				disposed = true;
+				options.signal?.removeEventListener("abort", dispose);
+				image.remove();
+				URL.revokeObjectURL(url);
+			};
+			options.signal?.addEventListener("abort", dispose, { once: true });
+			if (options.signal?.aborted) {
+				dispose();
+				options.signal.throwIfAborted();
+			}
+			try {
+				element.append(image);
+				return Object.freeze({ dispose });
+			} catch (error) {
+				dispose();
+				throw error;
+			}
+		} })
+	});
+}
+function invalidLoader(output, cause) {
+	return new NotebookExportError("loader_invalid", "OutputLoader validation failed.", {
+		cause,
+		details: {
+			output: output.name,
+			codec: output.codec,
+			mediaType: output.mediaType.raw
+		}
+	});
+}
+function isMediaTypePredicate(value) {
+	return isCallableValue(value);
+}
+function isMediaTypeString(value) {
+	return isStringValue(value);
+}
+function hasCallableMember(value, name) {
+	let owner = value;
+	while (owner !== null) {
+		const descriptor = Object.getOwnPropertyDescriptor(owner, name);
+		if (descriptor !== void 0) {
+			if ("value" in descriptor) return isCallableValue(descriptor.value);
+			return isCallableValue(descriptor.get?.call(value));
+		}
+		owner = Object.getPrototypeOf(owner);
+	}
+	return false;
+}
+//#endregion
+export { portableJsonValue as _, scalarLoader as a, isNotebookExportError as c, isJsonNumber as d, isJsonString as f, portableJsonObject as g, isStringValue as h, resolveOutputLoader as i, isCallableValue as l, isRecordValue as m, defineOutputLoader as n, parseMediaType as o, isPropertyOwner as p, imageLoader as r, NotebookExportError as s, defineBlobAssetLoader as t, isJsonBoolean as u, MAX_JSON_VALUES as v };