@statelyai/layout 0.1.2 → 0.2.0

package/dist/{spore-BeKUA1Mb.mjs → layout-engine-WbC0YjjT.mjs}

@@ -1,4 +1,4 @@
-import { F as placePorts, O as getPolylineMidpoint, z as JavaRandom } from "./layered-COIyXvwb.mjs";
+import { B as JavaRandom, I as placePorts, k as getPolylineMidpoint, n as layeredAlgorithm } from "./layered-Bz2nWmVp.mjs";
 import { getNodeSize } from "@statelyai/graph/layout";
 
 //#region src/fixed.ts
@@ -68,6 +68,14 @@ const fixedAlgorithm = {
 	}
 };
 
+//#endregion
+//#region src/internal/elkjs-compatibility.ts
+const elkjs0111ResultPolicy = Symbol("elkjs0111ResultPolicy");
+function setElkjs0111ResultPolicy(graph, policy) {
+	Object.defineProperty(graph, elkjs0111ResultPolicy, { value: policy });
+	return graph;
+}
+
 //#endregion
 //#region src/box.ts
 function getPadding$3(value) {
@@ -193,6 +201,25 @@ const boxAlgorithm = {
 		return getBoxLayout(graph, options ?? {});
 	}
 };
+/** Pinned behavior used only by the elkjs 0.11.1 compatibility adapter. */
+const elkjs0111BoxAlgorithm = {
+	...boxAlgorithm,
+	layout(graph, options = {}) {
+		const result = getBoxLayout(graph, options);
+		const padding = getPadding$3(options.padding);
+		return setElkjs0111ResultPolicy(result, {
+			providerBounds: result.nodes.length === 0 ? {
+				width: 0,
+				height: 0
+			} : {
+				width: Math.max(...result.nodes.map((node) => node.x + node.width)) + padding.right,
+				height: Math.max(...result.nodes.map((node) => node.y + node.height)) + padding.bottom
+			},
+			preserveEdgeSections: true,
+			skipBoundsNormalization: true
+		});
+	}
+};
 
 //#endregion
 //#region src/packing.ts
@@ -259,9 +286,36 @@ const rectanglePackingAlgorithm = {
 		return getRectanglePackingLayout(graph, options ?? {});
 	}
 };
+/** Pinned output policy used only by the elkjs 0.11.1 compatibility adapter. */
+const elkjs0111RectanglePackingAlgorithm = {
+	...rectanglePackingAlgorithm,
+	layout(graph, options = {}) {
+		const result = getRectanglePackingLayout(graph, options);
+		const padding = getPadding$2(options.padding);
+		return setElkjs0111ResultPolicy(result, {
+			providerBounds: result.nodes.length === 0 ? {
+				width: 0,
+				height: 0
+			} : {
+				width: Math.max(...result.nodes.map((node) => node.x + node.width)) + padding.right,
+				height: Math.max(...result.nodes.map((node) => node.y + node.height)) + padding.bottom
+			},
+			preserveEdgeSections: true,
+			skipBoundsNormalization: true
+		});
+	}
+};
 
 //#endregion
 //#region src/random.ts
+const nativeBehavior = {
+	elkjs0111EdgeTargetBug: false,
+	preserveProviderBounds: false
+};
+const elkjs0111Behavior = {
+	elkjs0111EdgeTargetBug: true,
+	preserveProviderBounds: true
+};
 function getPadding$1(value) {
 	if (typeof value === "number") return {
 		top: value,
@@ -299,6 +353,9 @@ function borderPoint(source, target) {
 }
 /** Seeded random distribution using Java's 48-bit `Random` sequence. */
 function getRandomLayout(graph, options = {}) {
+	return getRandomLayoutWithBehavior(graph, options, nativeBehavior);
+}
+function getRandomLayoutWithBehavior(graph, options, behavior) {
 	if (graph.nodes.length === 0) return getFixedLayout(graph, options);
 	const random = new JavaRandom(options.seed && options.seed !== 0 ? options.seed : Date.now());
 	const aspectRatio = Math.fround(options.aspectRatio ?? 1.6);
@@ -328,10 +385,49 @@ function getRandomLayout(graph, options = {}) {
 	const nodeById = new Map(nodes.map((node) => [node.id, node]));
 	const totalWidth = drawWidth + padding.left + padding.right;
 	const totalHeight = drawHeight + padding.top + padding.bottom;
-	const edges = graph.edges.map((edge) => {
+	const layoutEdge = (edge) => {
 		const source = nodeById.get(edge.sourceId);
 		const target = nodeById.get(edge.targetId);
 		if (!source || !target) return edge;
+		if (behavior.elkjs0111EdgeTargetBug) {
+			const start$1 = {
+				x: source.x + source.width,
+				y: source.y + source.height / 2
+			};
+			const end$1 = {
+				x: source.x + source.width / 2,
+				y: source.y + source.height
+			};
+			const bendCount$1 = random.nextInt(5) + 1;
+			const xDifference = end$1.x - start$1.x;
+			const yDifference = end$1.y - start$1.y;
+			const maximumDeviation$1 = Math.hypot(xDifference, yDifference) * Math.fround(.2);
+			const xIncrement = xDifference / (bendCount$1 + 1);
+			const yIncrement = yDifference / (bendCount$1 + 1);
+			let x = start$1.x;
+			let y = start$1.y;
+			const points$1 = [start$1];
+			for (let index = 0; index < bendCount$1; index++) {
+				x += xIncrement;
+				y += yIncrement;
+				let randomX = x + random.nextFloat() * maximumDeviation$1 - maximumDeviation$1 / 2;
+				if (randomX < 0) randomX = 1;
+				else if (randomX > totalWidth) randomX = totalWidth - 1;
+				let randomY = y + random.nextFloat() * maximumDeviation$1 - maximumDeviation$1 / 2;
+				if (randomY < 0) randomY = 1;
+				else if (randomY > totalHeight) randomY = totalHeight - 1;
+				points$1.push({
+					x: randomX,
+					y: randomY
+				});
+			}
+			points$1.push(end$1);
+			return {
+				...edge,
+				points: points$1,
+				routing: "polyline"
+			};
+		}
 		const start = borderPoint(source, target);
 		const end = borderPoint(target, source);
 		const bendCount = random.nextInt(5) + (source === target ? 1 : 0);
@@ -350,12 +446,18 @@ function getRandomLayout(graph, options = {}) {
 			points,
 			routing: "polyline"
 		};
-	});
-	return getFixedLayout({
+	};
+	const edges = behavior.elkjs0111EdgeTargetBug ? graph.nodes.flatMap((node) => graph.edges.filter((edge) => edge.sourceId === node.id).map(layoutEdge)) : graph.edges.map(layoutEdge);
+	const result = getFixedLayout({
 		...graph,
 		nodes,
 		edges
 	}, { direction: options.direction ?? graph.direction });
+	if (behavior.preserveProviderBounds) setElkjs0111ResultPolicy(result, { providerBounds: {
+		width: drawWidth + 2 * (padding.left + padding.right),
+		height: drawHeight + 2 * (padding.top + padding.bottom)
+	} });
+	return result;
 }
 const randomAlgorithm = {
 	id: "random",
@@ -371,6 +473,13 @@ const randomAlgorithm = {
 		return getRandomLayout(graph, options ?? {});
 	}
 };
+/** Pinned behavior used only by the elkjs 0.11.1 compatibility adapter. */
+const elkjs0111RandomAlgorithm = {
+	...randomAlgorithm,
+	layout(graph, options) {
+		return getRandomLayoutWithBehavior(graph, options ?? {}, elkjs0111Behavior);
+	}
+};
 
 //#endregion
 //#region src/spore.ts
@@ -454,4 +563,49 @@ const sporeCompactionAlgorithm = algorithm("sporeCompaction", true);
 const sporeOverlapRemovalAlgorithm = algorithm("sporeOverlap", false);
 
 //#endregion
-export { getRandomLayout as a, rectanglePackingAlgorithm as c, fixedAlgorithm as d, getFixedLayout as f, sporeOverlapRemovalAlgorithm as i, boxAlgorithm as l, getSporeOverlapRemovalLayout as n, randomAlgorithm as o, sporeCompactionAlgorithm as r, getRectanglePackingLayout as s, getSporeCompactionLayout as t, getBoxLayout as u };
+//#region src/internal/layout-engine.ts
+const builtInLayoutAlgorithms = {
+	box: boxAlgorithm,
+	fixed: fixedAlgorithm,
+	layered: layeredAlgorithm,
+	random: randomAlgorithm,
+	rectpacking: rectanglePackingAlgorithm,
+	sporeCompaction: sporeCompactionAlgorithm,
+	sporeOverlap: sporeOverlapRemovalAlgorithm
+};
+const elkjs0111LayoutAlgorithms = {
+	...builtInLayoutAlgorithms,
+	box: elkjs0111BoxAlgorithm,
+	random: elkjs0111RandomAlgorithm,
+	rectpacking: elkjs0111RectanglePackingAlgorithm
+};
+function getBuiltInLayoutAlgorithm(id) {
+	if (!Object.hasOwn(builtInLayoutAlgorithms, id)) return void 0;
+	return builtInLayoutAlgorithms[id];
+}
+/** Execute one algorithm through the shared engine seam. */
+function executeLayoutAlgorithm({ algorithm: algorithm$1, graph, options, context }) {
+	return algorithm$1.layout(graph, options, context);
+}
+function createDirectExecutionContext() {
+	return {
+		scope: { mode: "full" },
+		diagnostics: [],
+		measurePhase(_id, run) {
+			return run();
+		},
+		throwIfAborted() {}
+	};
+}
+/** Execute through the pinned elkjs 0.11.1 compatibility policy. */
+function executeElkjs0111Layout({ algorithm: algorithm$1, graph, options }) {
+	return executeLayoutAlgorithm({
+		algorithm: elkjs0111LayoutAlgorithms[algorithm$1],
+		graph,
+		options,
+		context: createDirectExecutionContext()
+	});
+}
+
+//#endregion
+export { getFixedLayout as _, getSporeCompactionLayout as a, sporeOverlapRemovalAlgorithm as c, getRectanglePackingLayout as d, rectanglePackingAlgorithm as f, fixedAlgorithm as g, elkjs0111ResultPolicy as h, getBuiltInLayoutAlgorithm as i, getRandomLayout as l, getBoxLayout as m, executeElkjs0111Layout as n, getSporeOverlapRemovalLayout as o, boxAlgorithm as p, executeLayoutAlgorithm as r, sporeCompactionAlgorithm as s, builtInLayoutAlgorithms as t, randomAlgorithm as u };

package/dist/public-types-B8rAALJq.d.mts

@@ -0,0 +1,109 @@
+//#region src/elkjs/public-types.d.ts
+/*******************************************************************************
+ * Copyright (c) 2019 TypeFox and others.
+ *
+ * Adapted from elkjs 0.11.1 typings/elk-api.d.ts.
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+interface LayoutOptions {
+  [key: string]: string;
+}
+interface ElkPoint {
+  x: number;
+  y: number;
+}
+interface ElkGraphElement {
+  id?: string;
+  labels?: ElkLabel[];
+  layoutOptions?: LayoutOptions;
+}
+interface ElkShape extends ElkGraphElement {
+  x?: number;
+  y?: number;
+  width?: number;
+  height?: number;
+}
+interface ElkNode extends ElkShape {
+  id: string;
+  children?: ElkNode[];
+  ports?: ElkPort[];
+  edges?: ElkExtendedEdge[];
+}
+interface ElkPort extends ElkShape {
+  id: string;
+}
+interface ElkLabel extends ElkShape {
+  text?: string;
+}
+/** @deprecated Use ElkExtendedEdge directly. */
+interface ElkEdge extends ElkGraphElement {
+  id: string;
+  container?: string;
+  junctionPoints?: ElkPoint[];
+}
+/** @deprecated Use ElkExtendedEdge instead. */
+interface ElkPrimitiveEdge extends ElkEdge {
+  source: string;
+  sourcePort?: string;
+  target: string;
+  targetPort?: string;
+  sourcePoint?: ElkPoint;
+  targetPoint?: ElkPoint;
+  bendPoints?: ElkPoint[];
+}
+interface ElkExtendedEdge extends ElkEdge {
+  sources: string[];
+  targets: string[];
+  sections?: ElkEdgeSection[];
+}
+interface ElkEdgeSection extends ElkGraphElement {
+  id: string;
+  startPoint: ElkPoint;
+  endPoint: ElkPoint;
+  bendPoints?: ElkPoint[];
+  incomingShape?: string;
+  outgoingShape?: string;
+  incomingSections?: string[];
+  outgoingSections?: string[];
+}
+interface ElkLayoutArguments {
+  layoutOptions?: LayoutOptions;
+  logging?: boolean;
+  measureExecutionTime?: boolean;
+}
+interface ElkCommonDescription {
+  id?: string;
+  name?: string;
+  description?: string;
+}
+interface ElkLayoutAlgorithmDescription extends ElkCommonDescription {
+  category?: string;
+  knownOptions?: string[];
+  supportedFeatures?: string[];
+}
+interface ElkLayoutOptionDescription extends ElkCommonDescription {
+  group?: string;
+  type?: string;
+  targets?: string[];
+}
+interface ElkLayoutCategoryDescription extends ElkCommonDescription {
+  knownLayouters?: string[];
+}
+type LaidOutElkNode<T extends ElkNode> = Omit<T, "children"> & {
+  children?: Array<NonNullable<T["children"]>[number] & ElkNode>;
+};
+interface ELK {
+  layout<T extends ElkNode>(graph: T, args?: ElkLayoutArguments): Promise<LaidOutElkNode<T>>;
+  knownLayoutAlgorithms(): Promise<ElkLayoutAlgorithmDescription[]>;
+  knownLayoutOptions(): Promise<ElkLayoutOptionDescription[]>;
+  knownLayoutCategories(): Promise<ElkLayoutCategoryDescription[]>;
+  terminateWorker(): void;
+}
+interface ELKConstructorArguments {
+  defaultLayoutOptions?: LayoutOptions;
+  algorithms?: string[];
+  workerUrl?: string;
+  workerFactory?: (url?: string) => Worker;
+}
+//#endregion
+export { ElkShape as _, ElkEdgeSection as a, ElkLabel as c, ElkLayoutCategoryDescription as d, ElkLayoutOptionDescription as f, ElkPrimitiveEdge as g, ElkPort as h, ElkEdge as i, ElkLayoutAlgorithmDescription as l, ElkPoint as m, ELKConstructorArguments as n, ElkExtendedEdge as o, ElkNode as p, ElkCommonDescription as r, ElkGraphElement as s, ELK as t, ElkLayoutArguments as u, LaidOutElkNode as v, LayoutOptions as y };

package/dist/public-types-CVB0hXGk.d.cts

@@ -0,0 +1,109 @@
+//#region src/elkjs/public-types.d.ts
+/*******************************************************************************
+ * Copyright (c) 2019 TypeFox and others.
+ *
+ * Adapted from elkjs 0.11.1 typings/elk-api.d.ts.
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+interface LayoutOptions {
+  [key: string]: string;
+}
+interface ElkPoint {
+  x: number;
+  y: number;
+}
+interface ElkGraphElement {
+  id?: string;
+  labels?: ElkLabel[];
+  layoutOptions?: LayoutOptions;
+}
+interface ElkShape extends ElkGraphElement {
+  x?: number;
+  y?: number;
+  width?: number;
+  height?: number;
+}
+interface ElkNode extends ElkShape {
+  id: string;
+  children?: ElkNode[];
+  ports?: ElkPort[];
+  edges?: ElkExtendedEdge[];
+}
+interface ElkPort extends ElkShape {
+  id: string;
+}
+interface ElkLabel extends ElkShape {
+  text?: string;
+}
+/** @deprecated Use ElkExtendedEdge directly. */
+interface ElkEdge extends ElkGraphElement {
+  id: string;
+  container?: string;
+  junctionPoints?: ElkPoint[];
+}
+/** @deprecated Use ElkExtendedEdge instead. */
+interface ElkPrimitiveEdge extends ElkEdge {
+  source: string;
+  sourcePort?: string;
+  target: string;
+  targetPort?: string;
+  sourcePoint?: ElkPoint;
+  targetPoint?: ElkPoint;
+  bendPoints?: ElkPoint[];
+}
+interface ElkExtendedEdge extends ElkEdge {
+  sources: string[];
+  targets: string[];
+  sections?: ElkEdgeSection[];
+}
+interface ElkEdgeSection extends ElkGraphElement {
+  id: string;
+  startPoint: ElkPoint;
+  endPoint: ElkPoint;
+  bendPoints?: ElkPoint[];
+  incomingShape?: string;
+  outgoingShape?: string;
+  incomingSections?: string[];
+  outgoingSections?: string[];
+}
+interface ElkLayoutArguments {
+  layoutOptions?: LayoutOptions;
+  logging?: boolean;
+  measureExecutionTime?: boolean;
+}
+interface ElkCommonDescription {
+  id?: string;
+  name?: string;
+  description?: string;
+}
+interface ElkLayoutAlgorithmDescription extends ElkCommonDescription {
+  category?: string;
+  knownOptions?: string[];
+  supportedFeatures?: string[];
+}
+interface ElkLayoutOptionDescription extends ElkCommonDescription {
+  group?: string;
+  type?: string;
+  targets?: string[];
+}
+interface ElkLayoutCategoryDescription extends ElkCommonDescription {
+  knownLayouters?: string[];
+}
+type LaidOutElkNode<T extends ElkNode> = Omit<T, "children"> & {
+  children?: Array<NonNullable<T["children"]>[number] & ElkNode>;
+};
+interface ELK {
+  layout<T extends ElkNode>(graph: T, args?: ElkLayoutArguments): Promise<LaidOutElkNode<T>>;
+  knownLayoutAlgorithms(): Promise<ElkLayoutAlgorithmDescription[]>;
+  knownLayoutOptions(): Promise<ElkLayoutOptionDescription[]>;
+  knownLayoutCategories(): Promise<ElkLayoutCategoryDescription[]>;
+  terminateWorker(): void;
+}
+interface ELKConstructorArguments {
+  defaultLayoutOptions?: LayoutOptions;
+  algorithms?: string[];
+  workerUrl?: string;
+  workerFactory?: (url?: string) => Worker;
+}
+//#endregion
+export { ElkShape as _, ElkEdgeSection as a, ElkLabel as c, ElkLayoutCategoryDescription as d, ElkLayoutOptionDescription as f, ElkPrimitiveEdge as g, ElkPort as h, ElkEdge as i, ElkLayoutAlgorithmDescription as l, ElkPoint as m, ELKConstructorArguments as n, ElkExtendedEdge as o, ElkNode as p, ElkCommonDescription as r, ElkGraphElement as s, ELK as t, ElkLayoutArguments as u, LaidOutElkNode as v, LayoutOptions as y };

package/dist/worker-client-D3HMK33r.cjs

@@ -0,0 +1,98 @@
+
+//#region src/elkjs/worker-client.ts
+var PromisedWorker = class {
+	#worker;
+	#resolvers = /* @__PURE__ */ new Map();
+	#id = 0;
+	#failure;
+	constructor(worker) {
+		this.#worker = worker;
+		worker.onmessage = (event) => {
+			const resolver = this.#resolvers.get(event.data.id);
+			if (!resolver) return;
+			this.#resolvers.delete(event.data.id);
+			if (event.data.error !== void 0) resolver.reject(event.data.error);
+			else resolver.resolve(event.data.data);
+		};
+		worker.onerror = (event) => this.#rejectAll(event.error ?? event.message);
+		worker.onmessageerror = (event) => this.#rejectAll(event.data);
+	}
+	postMessage(message) {
+		if (this.#failure) return Promise.reject(this.#failure);
+		const id = this.#id++;
+		return new Promise((resolve, reject) => {
+			this.#resolvers.set(id, {
+				resolve,
+				reject
+			});
+			this.#worker.postMessage({
+				...message,
+				id
+			});
+		});
+	}
+	terminate() {
+		this.#worker.terminate();
+	}
+	#rejectAll(reason) {
+		const error = reason instanceof Error ? reason : new Error(String(reason ?? "Worker failed"));
+		this.#failure = error;
+		for (const resolver of this.#resolvers.values()) resolver.reject(error);
+		this.#resolvers.clear();
+	}
+};
+var WorkerELK = class {
+	#defaultLayoutOptions;
+	#worker;
+	#ready;
+	constructor({ defaultLayoutOptions = {}, algorithms, workerFactory, workerUrl } = {}) {
+		if (workerUrl === void 0 && workerFactory === void 0) throw new Error("Cannot construct an ELK without both 'workerUrl' and 'workerFactory'.");
+		const worker = (workerFactory ?? ((url) => new globalThis.Worker(url)))(workerUrl);
+		if (!worker || typeof worker.postMessage !== "function") throw new TypeError("Created worker does not provide the required 'postMessage' function.");
+		this.#defaultLayoutOptions = defaultLayoutOptions;
+		this.#worker = new PromisedWorker(worker);
+		this.#ready = this.#worker.postMessage({
+			cmd: "register",
+			algorithms
+		});
+	}
+	async layout(graph, args = {}) {
+		if (!graph) throw new Error("Missing mandatory parameter 'graph'.");
+		await this.#ready;
+		return this.#worker.postMessage({
+			cmd: "layout",
+			graph,
+			layoutOptions: {
+				...this.#defaultLayoutOptions,
+				...args.layoutOptions
+			},
+			options: {
+				logging: args.logging ?? false,
+				measureExecutionTime: args.measureExecutionTime ?? false
+			}
+		});
+	}
+	async knownLayoutAlgorithms() {
+		await this.#ready;
+		return this.#worker.postMessage({ cmd: "algorithms" });
+	}
+	async knownLayoutOptions() {
+		await this.#ready;
+		return this.#worker.postMessage({ cmd: "options" });
+	}
+	async knownLayoutCategories() {
+		await this.#ready;
+		return this.#worker.postMessage({ cmd: "categories" });
+	}
+	terminateWorker() {
+		this.#worker.terminate();
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'WorkerELK', {
+  enumerable: true,
+  get: function () {
+    return WorkerELK;
+  }
+});

package/dist/worker-client-DAT_z2OR.d.mts

@@ -0,0 +1,19 @@
+import { d as ElkLayoutCategoryDescription, f as ElkLayoutOptionDescription, l as ElkLayoutAlgorithmDescription, n as ELKConstructorArguments, p as ElkNode, t as ELK, u as ElkLayoutArguments, v as LaidOutElkNode } from "./public-types-B8rAALJq.mjs";
+
+//#region src/elkjs/worker-client.d.ts
+declare class WorkerELK implements ELK {
+  #private;
+  constructor({
+    defaultLayoutOptions,
+    algorithms,
+    workerFactory,
+    workerUrl
+  }?: ELKConstructorArguments);
+  layout<T extends ElkNode>(graph: T, args?: ElkLayoutArguments): Promise<LaidOutElkNode<T>>;
+  knownLayoutAlgorithms(): Promise<ElkLayoutAlgorithmDescription[]>;
+  knownLayoutOptions(): Promise<ElkLayoutOptionDescription[]>;
+  knownLayoutCategories(): Promise<ElkLayoutCategoryDescription[]>;
+  terminateWorker(): void;
+}
+//#endregion
+export { WorkerELK as t };

package/dist/worker-client-DVhklF6A.d.cts

@@ -0,0 +1,19 @@
+import { d as ElkLayoutCategoryDescription, f as ElkLayoutOptionDescription, l as ElkLayoutAlgorithmDescription, n as ELKConstructorArguments, p as ElkNode, t as ELK, u as ElkLayoutArguments, v as LaidOutElkNode } from "./public-types-CVB0hXGk.cjs";
+
+//#region src/elkjs/worker-client.d.ts
+declare class WorkerELK implements ELK {
+  #private;
+  constructor({
+    defaultLayoutOptions,
+    algorithms,
+    workerFactory,
+    workerUrl
+  }?: ELKConstructorArguments);
+  layout<T extends ElkNode>(graph: T, args?: ElkLayoutArguments): Promise<LaidOutElkNode<T>>;
+  knownLayoutAlgorithms(): Promise<ElkLayoutAlgorithmDescription[]>;
+  knownLayoutOptions(): Promise<ElkLayoutOptionDescription[]>;
+  knownLayoutCategories(): Promise<ElkLayoutCategoryDescription[]>;
+  terminateWorker(): void;
+}
+//#endregion
+export { WorkerELK as t };

package/dist/worker-client-DkwS4sHx.mjs

@@ -0,0 +1,92 @@
+//#region src/elkjs/worker-client.ts
+var PromisedWorker = class {
+	#worker;
+	#resolvers = /* @__PURE__ */ new Map();
+	#id = 0;
+	#failure;
+	constructor(worker) {
+		this.#worker = worker;
+		worker.onmessage = (event) => {
+			const resolver = this.#resolvers.get(event.data.id);
+			if (!resolver) return;
+			this.#resolvers.delete(event.data.id);
+			if (event.data.error !== void 0) resolver.reject(event.data.error);
+			else resolver.resolve(event.data.data);
+		};
+		worker.onerror = (event) => this.#rejectAll(event.error ?? event.message);
+		worker.onmessageerror = (event) => this.#rejectAll(event.data);
+	}
+	postMessage(message) {
+		if (this.#failure) return Promise.reject(this.#failure);
+		const id = this.#id++;
+		return new Promise((resolve, reject) => {
+			this.#resolvers.set(id, {
+				resolve,
+				reject
+			});
+			this.#worker.postMessage({
+				...message,
+				id
+			});
+		});
+	}
+	terminate() {
+		this.#worker.terminate();
+	}
+	#rejectAll(reason) {
+		const error = reason instanceof Error ? reason : new Error(String(reason ?? "Worker failed"));
+		this.#failure = error;
+		for (const resolver of this.#resolvers.values()) resolver.reject(error);
+		this.#resolvers.clear();
+	}
+};
+var WorkerELK = class {
+	#defaultLayoutOptions;
+	#worker;
+	#ready;
+	constructor({ defaultLayoutOptions = {}, algorithms, workerFactory, workerUrl } = {}) {
+		if (workerUrl === void 0 && workerFactory === void 0) throw new Error("Cannot construct an ELK without both 'workerUrl' and 'workerFactory'.");
+		const worker = (workerFactory ?? ((url) => new globalThis.Worker(url)))(workerUrl);
+		if (!worker || typeof worker.postMessage !== "function") throw new TypeError("Created worker does not provide the required 'postMessage' function.");
+		this.#defaultLayoutOptions = defaultLayoutOptions;
+		this.#worker = new PromisedWorker(worker);
+		this.#ready = this.#worker.postMessage({
+			cmd: "register",
+			algorithms
+		});
+	}
+	async layout(graph, args = {}) {
+		if (!graph) throw new Error("Missing mandatory parameter 'graph'.");
+		await this.#ready;
+		return this.#worker.postMessage({
+			cmd: "layout",
+			graph,
+			layoutOptions: {
+				...this.#defaultLayoutOptions,
+				...args.layoutOptions
+			},
+			options: {
+				logging: args.logging ?? false,
+				measureExecutionTime: args.measureExecutionTime ?? false
+			}
+		});
+	}
+	async knownLayoutAlgorithms() {
+		await this.#ready;
+		return this.#worker.postMessage({ cmd: "algorithms" });
+	}
+	async knownLayoutOptions() {
+		await this.#ready;
+		return this.#worker.postMessage({ cmd: "options" });
+	}
+	async knownLayoutCategories() {
+		await this.#ready;
+		return this.#worker.postMessage({ cmd: "categories" });
+	}
+	terminateWorker() {
+		this.#worker.terminate();
+	}
+};
+
+//#endregion
+export { WorkerELK as t };