likec4 1.57.0 → 1.58.0

package/dist/vite-plugin/internal/index.mjs

@@ -1 +1,946 @@
-import"./chunks/rolldown-runtime.mjs";import{i as e,n as t,r as n,t as r}from"./chunks/libs/nanostores.mjs";import{t as i}from"./chunks/libs/@nanostores/react.mjs";import{t as a}from"./chunks/libs/birpc.mjs";import{n as o,t as s}from"./chunks/libs/fast-equals.mjs";import{t as c}from"./chunks/libs/remeda.mjs";import{LikeC4Model as l}from"@likec4/core/model";import{useMemo as u}from"react";function createRpc(e){return a({},{timeout:120*1e3,post:t=>e.send(`likec4:rpc`,t),on:t=>e.on(`likec4:rpc`,t),onTimeoutError(e){return e===`applySemanticLayout`},onGeneralError(e,t){console.error(`RPC error in ${t}`,{error:e})},onFunctionError:(e,t)=>{console.error(`RPC error in ${t}`,{error:e})}})}function createHooksForModel(e){let t=n(e,e=>l.create(e));function updateModel(t){let n=e.get(),r={...t,views:c(t.views,e=>{let t=n.views[e.id];return s(t,e)?t:e})};o(r.views,n.views)&&s(r,n)||e.set(r)}let r=n(t,e=>[...e.views()].map(e=>e.$layouted));function useLikeC4Model(){return i(t)}function useLikeC4Views(){return i(r)}function useLikeC4View(e){return i(u(()=>n(t,t=>t.findView(e)?.$layouted??null),[e]))}return{updateModel,$likec4model:t,useLikeC4Model,useLikeC4Views,useLikeC4View}}export{e as atom,t as batched,n as computed,createHooksForModel,createRpc,r as map,i as useStore};
+import { LikeC4Model } from "@likec4/core/model";
+import { useCallback, useMemo, useRef, useSyncExternalStore } from "react";
+
+//#region ../../node_modules/.pnpm/nanostores@1.3.0/node_modules/nanostores/atom/index.js
+let listenerQueue = [];
+let lqIndex = 0;
+const QUEUE_ITEMS_PER_LISTENER = 4;
+const nanostoresGlobal = globalThis.nanostoresGlobal ||= { epoch: 0 };
+const atom = /* @__NO_SIDE_EFFECTS__ */ (initialValue) => {
+	let listeners = [];
+	let $atom = {
+		get() {
+			if (!$atom.lc) $atom.listen(() => {})();
+			return $atom.value;
+		},
+		init: initialValue,
+		lc: 0,
+		listen(listener) {
+			$atom.lc = listeners.push(listener);
+			return () => {
+				for (let i = lqIndex + QUEUE_ITEMS_PER_LISTENER; i < listenerQueue.length;) if (listenerQueue[i] === listener) listenerQueue.splice(i, QUEUE_ITEMS_PER_LISTENER);
+				else i += QUEUE_ITEMS_PER_LISTENER;
+				let index = listeners.indexOf(listener);
+				if (~index) {
+					listeners.splice(index, 1);
+					if (!--$atom.lc) $atom.off();
+				}
+			};
+		},
+		notify(oldValue, changedKey) {
+			nanostoresGlobal.epoch++;
+			let runListenerQueue = !listenerQueue.length;
+			for (let listener of listeners) listenerQueue.push(listener, $atom.value, oldValue, changedKey);
+			if (runListenerQueue) {
+				for (lqIndex = 0; lqIndex < listenerQueue.length; lqIndex += QUEUE_ITEMS_PER_LISTENER) listenerQueue[lqIndex](listenerQueue[lqIndex + 1], listenerQueue[lqIndex + 2], listenerQueue[lqIndex + 3]);
+				listenerQueue.length = 0;
+			}
+		},
+		off() {},
+		set(newValue) {
+			let oldValue = $atom.value;
+			if (oldValue !== newValue) {
+				$atom.value = newValue;
+				$atom.notify(oldValue);
+			}
+		},
+		subscribe(listener) {
+			let unbind = $atom.listen(listener);
+			listener($atom.value);
+			return unbind;
+		},
+		value: initialValue
+	};
+	return $atom;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/nanostores@1.3.0/node_modules/nanostores/lifecycle/index.js
+const MOUNT = 5;
+const UNMOUNT = 6;
+const REVERT_MUTATION = 10;
+let on = (object, listener, eventKey, mutateStore) => {
+	object.events = object.events || {};
+	if (!object.events[eventKey + REVERT_MUTATION]) object.events[eventKey + REVERT_MUTATION] = mutateStore((eventProps) => {
+		object.events[eventKey].reduceRight((event, l) => (l(event), event), {
+			shared: {},
+			...eventProps
+		});
+	});
+	object.events[eventKey] = object.events[eventKey] || [];
+	object.events[eventKey].push(listener);
+	return () => {
+		let currentListeners = object.events[eventKey];
+		let index = currentListeners.indexOf(listener);
+		currentListeners.splice(index, 1);
+		if (!currentListeners.length) {
+			delete object.events[eventKey];
+			object.events[eventKey + REVERT_MUTATION]();
+			delete object.events[eventKey + REVERT_MUTATION];
+		}
+	};
+};
+const STORE_UNMOUNT_DELAY = 1e3;
+let onMount = ($store, initialize) => {
+	let listener = (payload) => {
+		let destroy = initialize(payload);
+		if (destroy) $store.events[UNMOUNT].push(destroy);
+	};
+	return on($store, listener, MOUNT, (runListeners) => {
+		let originListen = $store.listen;
+		$store.listen = (...args) => {
+			if (!$store.lc && !$store.active) {
+				$store.active = true;
+				runListeners();
+			}
+			return originListen(...args);
+		};
+		let originOff = $store.off;
+		$store.events[UNMOUNT] = [];
+		$store.off = () => {
+			originOff();
+			setTimeout(() => {
+				if ($store.active && !$store.lc) {
+					$store.active = false;
+					for (let destroy of $store.events[UNMOUNT]) destroy();
+					$store.events[UNMOUNT] = [];
+				}
+			}, STORE_UNMOUNT_DELAY);
+		};
+		return () => {
+			$store.listen = originListen;
+			$store.off = originOff;
+		};
+	});
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/nanostores@1.3.0/node_modules/nanostores/computed/index.js
+let computedStore = (stores, cb, batched) => {
+	if (!Array.isArray(stores)) stores = [stores];
+	let previousArgs;
+	let currentEpoch;
+	let set = () => {
+		if (currentEpoch === nanostoresGlobal.epoch) return;
+		currentEpoch = nanostoresGlobal.epoch;
+		let args = stores.map(($store) => $store.get());
+		if (!previousArgs || args.some((arg, i) => arg !== previousArgs[i])) {
+			previousArgs = args;
+			let value = cb(...args);
+			if (value && value.then && value.t) value.then((asyncValue) => {
+				if (previousArgs === args) $computed.set(asyncValue);
+			});
+			else {
+				$computed.set(value);
+				currentEpoch = nanostoresGlobal.epoch;
+			}
+		}
+	};
+	let $computed = /* @__PURE__ */ atom(void 0);
+	let get = $computed.get;
+	$computed.get = () => {
+		set();
+		return get();
+	};
+	let timer;
+	let run = batched ? () => {
+		clearTimeout(timer);
+		timer = setTimeout(set);
+	} : set;
+	onMount($computed, () => {
+		let unbinds = stores.map(($store) => $store.listen(run));
+		set();
+		return () => {
+			for (let unbind of unbinds) unbind();
+		};
+	});
+	return $computed;
+};
+const computed = /* @__NO_SIDE_EFFECTS__ */ (stores, fn) => computedStore(stores, fn);
+const batched = /* @__NO_SIDE_EFFECTS__ */ (stores, fn) => computedStore(stores, fn, true);
+
+//#endregion
+//#region ../../node_modules/.pnpm/nanostores@1.3.0/node_modules/nanostores/listen-keys/index.js
+function listenKeys($store, keys, listener) {
+	let keysSet = new Set(keys).add(void 0);
+	return $store.listen((value, oldValue, changed) => {
+		if (keysSet.has(changed)) listener(value, oldValue, changed);
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/nanostores@1.3.0/node_modules/nanostores/map/index.js
+const map = /* @__NO_SIDE_EFFECTS__ */ (initial = {}) => {
+	let $map = /* @__PURE__ */ atom(initial);
+	$map.setKey = function(key, value) {
+		let oldMap = $map.value;
+		if (typeof value === "undefined" && key in $map.value) {
+			$map.value = { ...$map.value };
+			delete $map.value[key];
+			$map.notify(oldMap, key);
+		} else if ($map.value[key] !== value) {
+			$map.value = {
+				...$map.value,
+				[key]: value
+			};
+			$map.notify(oldMap, key);
+		}
+	};
+	return $map;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@nanostores+react@1.1.0_nanostores@1.3.0_react@19.2.7/node_modules/@nanostores/react/index.js
+let emit = (snapshotRef, onChange) => (value) => {
+	if (snapshotRef.current === value) return;
+	snapshotRef.current = value;
+	onChange();
+};
+function useStore(store, { keys, deps = [store, keys], ssr } = {}) {
+	let snapshotRef = useRef();
+	snapshotRef.current = store.get();
+	let subscribe = useCallback((onChange) => {
+		emit(snapshotRef, onChange)(store.value);
+		return keys?.length > 0 ? listenKeys(store, keys, emit(snapshotRef, onChange)) : store.listen(emit(snapshotRef, onChange));
+	}, deps);
+	let get = () => snapshotRef.current;
+	let server = get;
+	if (ssr && "init" in store) server = ssr === "initial" ? () => store.init : ssr;
+	return useSyncExternalStore(subscribe, get, server);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/birpc@4.0.0/node_modules/birpc/dist/index.mjs
+const TYPE_REQUEST = "q";
+const TYPE_RESPONSE = "s";
+function createPromiseWithResolvers() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		}),
+		resolve,
+		reject
+	};
+}
+const random = Math.random.bind(Math);
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+	let id = "";
+	let i = size;
+	while (i--) id += urlAlphabet[random() * 64 | 0];
+	return id;
+}
+const DEFAULT_TIMEOUT = 6e4;
+const defaultSerialize = (i) => i;
+const defaultDeserialize = defaultSerialize;
+const { clearTimeout: clearTimeout$1, setTimeout: setTimeout$1 } = globalThis;
+function createBirpc($functions, options) {
+	const { post, on, off = () => {}, eventNames = [], serialize = defaultSerialize, deserialize = defaultDeserialize, resolver, bind = "rpc", timeout = DEFAULT_TIMEOUT, proxify = true } = options;
+	let $closed = false;
+	const _rpcPromiseMap = /* @__PURE__ */ new Map();
+	let _promiseInit;
+	let rpc;
+	async function _call(method, args, event, optional) {
+		if ($closed) throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+		const req = {
+			m: method,
+			a: args,
+			t: TYPE_REQUEST
+		};
+		if (optional) req.o = true;
+		const send = async (_req) => post(serialize(_req));
+		if (event) {
+			await send(req);
+			return;
+		}
+		if (_promiseInit) try {
+			await _promiseInit;
+		} finally {
+			_promiseInit = void 0;
+		}
+		let { promise, resolve, reject } = createPromiseWithResolvers();
+		const id = nanoid();
+		req.i = id;
+		let timeoutId;
+		async function handler(newReq = req) {
+			if (timeout >= 0) {
+				timeoutId = setTimeout$1(() => {
+					try {
+						if (options.onTimeoutError?.call(rpc, method, args) !== true) throw new Error(`[birpc] timeout on calling "${method}"`);
+					} catch (e) {
+						reject(e);
+					}
+					_rpcPromiseMap.delete(id);
+				}, timeout);
+				if (typeof timeoutId === "object") timeoutId = timeoutId.unref?.();
+			}
+			_rpcPromiseMap.set(id, {
+				resolve,
+				reject,
+				timeoutId,
+				method
+			});
+			await send(newReq);
+			return promise;
+		}
+		try {
+			if (options.onRequest) await options.onRequest.call(rpc, req, handler, resolve);
+			else await handler();
+		} catch (e) {
+			if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+			return;
+		} finally {
+			clearTimeout$1(timeoutId);
+			_rpcPromiseMap.delete(id);
+		}
+		return promise;
+	}
+	const builtinMethods = {
+		$call: (method, ...args) => _call(method, args, false),
+		$callOptional: (method, ...args) => _call(method, args, false, true),
+		$callEvent: (method, ...args) => _call(method, args, true),
+		$callRaw: (options$1) => _call(options$1.method, options$1.args, options$1.event, options$1.optional),
+		$rejectPendingCalls,
+		get $closed() {
+			return $closed;
+		},
+		get $meta() {
+			return options.meta;
+		},
+		$close,
+		$functions
+	};
+	if (proxify) rpc = new Proxy({}, { get(_, method) {
+		if (Object.prototype.hasOwnProperty.call(builtinMethods, method)) return builtinMethods[method];
+		if (method === "then" && !eventNames.includes("then") && !("then" in $functions)) return void 0;
+		const sendEvent = (...args) => _call(method, args, true);
+		if (eventNames.includes(method)) {
+			sendEvent.asEvent = sendEvent;
+			return sendEvent;
+		}
+		const sendCall = (...args) => _call(method, args, false);
+		sendCall.asEvent = sendEvent;
+		return sendCall;
+	} });
+	else rpc = builtinMethods;
+	function $close(customError) {
+		$closed = true;
+		_rpcPromiseMap.forEach(({ reject, method }) => {
+			const error = /* @__PURE__ */ new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+			if (customError) {
+				customError.cause ??= error;
+				return reject(customError);
+			}
+			reject(error);
+		});
+		_rpcPromiseMap.clear();
+		off(onMessage);
+	}
+	function $rejectPendingCalls(handler) {
+		const handlerResults = Array.from(_rpcPromiseMap.values()).map(({ method, reject }) => {
+			if (!handler) return reject(/* @__PURE__ */ new Error(`[birpc]: rejected pending call "${method}".`));
+			return handler({
+				method,
+				reject
+			});
+		});
+		_rpcPromiseMap.clear();
+		return handlerResults;
+	}
+	async function onMessage(data, ...extra) {
+		let msg;
+		try {
+			msg = deserialize(data);
+		} catch (e) {
+			if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+			return;
+		}
+		if (msg.t === TYPE_REQUEST) {
+			const { m: method, a: args, o: optional } = msg;
+			let result, error;
+			let fn = await (resolver ? resolver.call(rpc, method, $functions[method]) : $functions[method]);
+			if (optional) fn ||= () => void 0;
+			if (!fn) error = /* @__PURE__ */ new Error(`[birpc] function "${method}" not found`);
+			else try {
+				result = await fn.apply(bind === "rpc" ? rpc : $functions, args);
+			} catch (e) {
+				error = e;
+			}
+			if (msg.i) {
+				if (error && options.onFunctionError) {
+					if (options.onFunctionError.call(rpc, error, method, args) === true) return;
+				}
+				if (!error) try {
+					await post(serialize({
+						t: TYPE_RESPONSE,
+						i: msg.i,
+						r: result
+					}), ...extra);
+					return;
+				} catch (e) {
+					error = e;
+					if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+				}
+				try {
+					await post(serialize({
+						t: TYPE_RESPONSE,
+						i: msg.i,
+						e: error
+					}), ...extra);
+				} catch (e) {
+					if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+				}
+			}
+		} else {
+			const { i: ack, r: result, e: error } = msg;
+			const promise = _rpcPromiseMap.get(ack);
+			if (promise) {
+				clearTimeout$1(promise.timeoutId);
+				if (error) promise.reject(error);
+				else promise.resolve(result);
+			}
+			_rpcPromiseMap.delete(ack);
+		}
+	}
+	_promiseInit = on(onMessage);
+	return rpc;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/fast-equals@6.0.0/node_modules/fast-equals/dist/es/index.mjs
+const { getOwnPropertyNames, getOwnPropertySymbols } = Object;
+const { hasOwnProperty } = Object.prototype;
+/**
+* Combine two comparators into a single comparators.
+*/
+function combineComparators(comparatorA, comparatorB) {
+	return function isEqual(a, b, state) {
+		return comparatorA(a, b, state) && comparatorB(a, b, state);
+	};
+}
+/**
+* Wrap the provided `areItemsEqual` method to manage the circular state, allowing
+* for circular references to be safely included in the comparison without creating
+* stack overflows.
+*/
+function createIsCircular(areItemsEqual) {
+	return function isCircular(a, b, state) {
+		if (!a || !b || typeof a !== "object" || typeof b !== "object") return areItemsEqual(a, b, state);
+		const { cache } = state;
+		const cachedA = cache.get(a);
+		const cachedB = cache.get(b);
+		if (cachedA && cachedB) return cachedA === b && cachedB === a;
+		cache.set(a, b);
+		cache.set(b, a);
+		const result = areItemsEqual(a, b, state);
+		cache.delete(a);
+		cache.delete(b);
+		return result;
+	};
+}
+/**
+* Get the properties to strictly examine, which include both own properties that are
+* not enumerable and symbol properties.
+*/
+function getStrictProperties(object) {
+	return getOwnPropertyNames(object).concat(getOwnPropertySymbols(object));
+}
+/**
+* Whether the object contains the property passed as an own property.
+*/
+const hasOwn = Object.hasOwn || ((object, property) => hasOwnProperty.call(object, property));
+const PREACT_VNODE = "__v";
+const PREACT_OWNER = "__o";
+const REACT_OWNER = "_owner";
+const { getOwnPropertyDescriptor, keys } = Object;
+/**
+* Whether the values passed are equal based on a [SameValue](https://262.ecma-international.org/7.0/#sec-samevalue) basis.
+* Simplified, this maps to if the two values are referentially equal to one another (`a === b`) or both are `NaN`.
+*
+* @note
+* When available in the environment, this is just a re-export of the global
+* [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is) method.
+*/
+const sameValueEqual = Object.is || function sameValueEqual(a, b) {
+	return a === b ? a !== 0 || 1 / a === 1 / b : a !== a && b !== b;
+};
+/**
+* Whether the values passed are equal based on a
+* [Strict Equality Comparison](https://262.ecma-international.org/7.0/#sec-strict-equality-comparison) basis.
+* Simplified, this maps to if the two values are referentially equal to one another (`a === b`).
+*
+* @note
+* This is mainly available as a convenience function, such as being a default when a function to determine equality between
+* two objects is used.
+*/
+function strictEqual(a, b) {
+	return a === b;
+}
+/**
+* Whether the array buffers are equal in value.
+*/
+function areArrayBuffersEqual(a, b) {
+	return a.byteLength === b.byteLength && areTypedArraysEqual(new Uint8Array(a), new Uint8Array(b));
+}
+/**
+* Whether the arrays are equal in value.
+*/
+function areArraysEqual(a, b, state) {
+	let index = a.length;
+	if (b.length !== index) return false;
+	while (index-- > 0) if (!state.equals(a[index], b[index], index, index, a, b, state)) return false;
+	return true;
+}
+/**
+* Whether the dataviews are equal in value.
+*/
+function areDataViewsEqual(a, b) {
+	return a.byteLength === b.byteLength && areTypedArraysEqual(new Uint8Array(a.buffer, a.byteOffset, a.byteLength), new Uint8Array(b.buffer, b.byteOffset, b.byteLength));
+}
+/**
+* Whether the dates passed are equal in value.
+*/
+function areDatesEqual(a, b) {
+	return sameValueEqual(a.getTime(), b.getTime());
+}
+/**
+* Whether the errors passed are equal in value.
+*/
+function areErrorsEqual(a, b) {
+	return a.name === b.name && a.message === b.message && a.cause === b.cause && a.stack === b.stack;
+}
+/**
+* Whether the `Map`s are equal in value.
+*/
+function areMapsEqual(a, b, state) {
+	const size = a.size;
+	if (size !== b.size) return false;
+	if (!size) return true;
+	const matchedIndices = new Array(size);
+	const aIterable = a.entries();
+	let aResult;
+	let bResult;
+	let index = 0;
+	while (aResult = aIterable.next()) {
+		if (aResult.done) break;
+		const bIterable = b.entries();
+		let hasMatch = false;
+		let matchIndex = 0;
+		while (bResult = bIterable.next()) {
+			if (bResult.done) break;
+			if (matchedIndices[matchIndex]) {
+				matchIndex++;
+				continue;
+			}
+			const aEntry = aResult.value;
+			const bEntry = bResult.value;
+			if (state.equals(aEntry[0], bEntry[0], index, matchIndex, a, b, state) && state.equals(aEntry[1], bEntry[1], aEntry[0], bEntry[0], a, b, state)) {
+				hasMatch = matchedIndices[matchIndex] = true;
+				break;
+			}
+			matchIndex++;
+		}
+		if (!hasMatch) return false;
+		index++;
+	}
+	return true;
+}
+/**
+* Whether the objects are equal in value.
+*/
+function areObjectsEqual(a, b, state) {
+	const properties = keys(a);
+	let index = properties.length;
+	if (keys(b).length !== index) return false;
+	while (index-- > 0) if (!isPropertyEqual(a, b, state, properties[index])) return false;
+	return true;
+}
+/**
+* Whether the objects are equal in value with strict property checking.
+*/
+function areObjectsEqualStrict(a, b, state) {
+	const properties = getStrictProperties(a);
+	let index = properties.length;
+	if (getStrictProperties(b).length !== index) return false;
+	let property;
+	let descriptorA;
+	let descriptorB;
+	while (index-- > 0) {
+		property = properties[index];
+		if (!isPropertyEqual(a, b, state, property)) return false;
+		descriptorA = getOwnPropertyDescriptor(a, property);
+		descriptorB = getOwnPropertyDescriptor(b, property);
+		if ((descriptorA || descriptorB) && (!descriptorA || !descriptorB || descriptorA.configurable !== descriptorB.configurable || descriptorA.enumerable !== descriptorB.enumerable || descriptorA.writable !== descriptorB.writable)) return false;
+	}
+	return true;
+}
+/**
+* Whether the primitive wrappers passed are equal in value.
+*/
+function arePrimitiveWrappersEqual(a, b) {
+	return sameValueEqual(a.valueOf(), b.valueOf());
+}
+/**
+* Whether the regexps passed are equal in value.
+*/
+function areRegExpsEqual(a, b) {
+	return a.source === b.source && a.flags === b.flags;
+}
+/**
+* Whether the `Set`s are equal in value.
+*/
+function areSetsEqual(a, b, state) {
+	const size = a.size;
+	if (size !== b.size) return false;
+	if (!size) return true;
+	const matchedIndices = new Array(size);
+	const aIterable = a.values();
+	let aResult;
+	let bResult;
+	while (aResult = aIterable.next()) {
+		if (aResult.done) break;
+		const bIterable = b.values();
+		let hasMatch = false;
+		let matchIndex = 0;
+		while (bResult = bIterable.next()) {
+			if (bResult.done) break;
+			if (!matchedIndices[matchIndex] && state.equals(aResult.value, bResult.value, aResult.value, bResult.value, a, b, state)) {
+				hasMatch = matchedIndices[matchIndex] = true;
+				break;
+			}
+			matchIndex++;
+		}
+		if (!hasMatch) return false;
+	}
+	return true;
+}
+/**
+* Whether the TypedArray instances are equal in value.
+*/
+function areTypedArraysEqual(a, b) {
+	let index = a.byteLength;
+	if (b.byteLength !== index || a.byteOffset !== b.byteOffset) return false;
+	while (index-- > 0) if (a[index] !== b[index]) return false;
+	return true;
+}
+/**
+* Whether the URL instances are equal in value.
+*/
+function areUrlsEqual(a, b) {
+	return a.hostname === b.hostname && a.pathname === b.pathname && a.protocol === b.protocol && a.port === b.port && a.hash === b.hash && a.username === b.username && a.password === b.password;
+}
+function isPropertyEqual(a, b, state, property) {
+	if ((property === REACT_OWNER || property === PREACT_OWNER || property === PREACT_VNODE) && (a.$$typeof || b.$$typeof)) return true;
+	return hasOwn(b, property) && state.equals(a[property], b[property], property, property, a, b, state);
+}
+const toString = Object.prototype.toString;
+/**
+* Create a comparator method based on the type-specific equality comparators passed.
+*/
+function createEqualityComparator(config) {
+	const supportedComparatorMap = createSupportedComparatorMap(config);
+	const { areArraysEqual, areDatesEqual, areFunctionsEqual, areMapsEqual, areNumbersEqual, areObjectsEqual, areRegExpsEqual, areSetsEqual, getUnsupportedCustomComparator } = config;
+	/**
+	* compare the value of the two objects and return true if they are equivalent in values
+	*/
+	return function comparator(a, b, state) {
+		if (a === b) return true;
+		if (a == null || b == null) return false;
+		const type = typeof a;
+		if (type !== typeof b) return false;
+		if (type !== "object") {
+			if (type === "number" || type === "bigint") return areNumbersEqual(a, b, state);
+			if (type === "function") return areFunctionsEqual(a, b, state);
+			return false;
+		}
+		const constructor = a.constructor;
+		if (constructor !== b.constructor) return false;
+		if (constructor === Object) return areObjectsEqual(a, b, state);
+		if (constructor === Array) return areArraysEqual(a, b, state);
+		if (constructor === Date) return areDatesEqual(a, b, state);
+		if (constructor === RegExp) return areRegExpsEqual(a, b, state);
+		if (constructor === Map) return areMapsEqual(a, b, state);
+		if (constructor === Set) return areSetsEqual(a, b, state);
+		if (constructor === Promise) return false;
+		if (Array.isArray(a)) return areArraysEqual(a, b, state);
+		const tag = toString.call(a);
+		const supportedComparator = supportedComparatorMap[tag];
+		if (supportedComparator) return supportedComparator(a, b, state);
+		const unsupportedCustomComparator = getUnsupportedCustomComparator && getUnsupportedCustomComparator(a, b, state, tag);
+		if (unsupportedCustomComparator) return unsupportedCustomComparator(a, b, state);
+		return false;
+	};
+}
+/**
+* Create the configuration object used for building comparators.
+*/
+function createEqualityComparatorConfig({ circular, createCustomConfig, strict }) {
+	let config = {
+		areArrayBuffersEqual,
+		areArraysEqual: strict ? areObjectsEqualStrict : areArraysEqual,
+		areDataViewsEqual,
+		areDatesEqual,
+		areErrorsEqual,
+		areFunctionsEqual: strictEqual,
+		areMapsEqual: strict ? combineComparators(areMapsEqual, areObjectsEqualStrict) : areMapsEqual,
+		areNumbersEqual: sameValueEqual,
+		areObjectsEqual: strict ? areObjectsEqualStrict : areObjectsEqual,
+		arePrimitiveWrappersEqual,
+		areRegExpsEqual,
+		areSetsEqual: strict ? combineComparators(areSetsEqual, areObjectsEqualStrict) : areSetsEqual,
+		areTypedArraysEqual: strict ? combineComparators(areTypedArraysEqual, areObjectsEqualStrict) : areTypedArraysEqual,
+		areUrlsEqual,
+		getUnsupportedCustomComparator: void 0
+	};
+	if (createCustomConfig) config = Object.assign({}, config, createCustomConfig(config));
+	if (circular) {
+		const areArraysEqual = createIsCircular(config.areArraysEqual);
+		const areMapsEqual = createIsCircular(config.areMapsEqual);
+		const areObjectsEqual = createIsCircular(config.areObjectsEqual);
+		const areSetsEqual = createIsCircular(config.areSetsEqual);
+		config = Object.assign({}, config, {
+			areArraysEqual,
+			areMapsEqual,
+			areObjectsEqual,
+			areSetsEqual
+		});
+	}
+	return config;
+}
+/**
+* Default equality comparator pass-through, used as the standard `isEqual` creator for
+* use inside the built comparator.
+*/
+function createInternalEqualityComparator(compare) {
+	return function(a, b, _indexOrKeyA, _indexOrKeyB, _parentA, _parentB, state) {
+		return compare(a, b, state);
+	};
+}
+/**
+* Create the `isEqual` function used by the consuming application.
+*/
+function createIsEqual({ circular, comparator, createState, equals, strict }) {
+	if (createState) return function isEqual(a, b) {
+		const { cache = circular ? /* @__PURE__ */ new WeakMap() : void 0, meta } = createState();
+		return comparator(a, b, {
+			cache,
+			equals,
+			meta,
+			strict
+		});
+	};
+	if (circular) return function isEqual(a, b) {
+		return comparator(a, b, {
+			cache: /* @__PURE__ */ new WeakMap(),
+			equals,
+			meta: void 0,
+			strict
+		});
+	};
+	const state = {
+		cache: void 0,
+		equals,
+		meta: void 0,
+		strict
+	};
+	return function isEqual(a, b) {
+		return comparator(a, b, state);
+	};
+}
+/**
+* Create a map of `toString()` values to their respective handlers for `tag`-based lookups.
+*/
+function createSupportedComparatorMap({ areArrayBuffersEqual, areArraysEqual, areDataViewsEqual, areDatesEqual, areErrorsEqual, areFunctionsEqual, areMapsEqual, areNumbersEqual, areObjectsEqual, arePrimitiveWrappersEqual, areRegExpsEqual, areSetsEqual, areTypedArraysEqual, areUrlsEqual }) {
+	return {
+		"[object Arguments]": areObjectsEqual,
+		"[object Array]": areArraysEqual,
+		"[object ArrayBuffer]": areArrayBuffersEqual,
+		"[object AsyncGeneratorFunction]": areFunctionsEqual,
+		"[object BigInt]": areNumbersEqual,
+		"[object BigInt64Array]": areTypedArraysEqual,
+		"[object BigUint64Array]": areTypedArraysEqual,
+		"[object Boolean]": arePrimitiveWrappersEqual,
+		"[object DataView]": areDataViewsEqual,
+		"[object Date]": areDatesEqual,
+		"[object Error]": areErrorsEqual,
+		"[object Float16Array]": areTypedArraysEqual,
+		"[object Float32Array]": areTypedArraysEqual,
+		"[object Float64Array]": areTypedArraysEqual,
+		"[object Function]": areFunctionsEqual,
+		"[object GeneratorFunction]": areFunctionsEqual,
+		"[object Int8Array]": areTypedArraysEqual,
+		"[object Int16Array]": areTypedArraysEqual,
+		"[object Int32Array]": areTypedArraysEqual,
+		"[object Map]": areMapsEqual,
+		"[object Number]": arePrimitiveWrappersEqual,
+		"[object Object]": (a, b, state) => typeof a.then !== "function" && typeof b.then !== "function" && areObjectsEqual(a, b, state),
+		"[object RegExp]": areRegExpsEqual,
+		"[object Set]": areSetsEqual,
+		"[object String]": arePrimitiveWrappersEqual,
+		"[object URL]": areUrlsEqual,
+		"[object Uint8Array]": areTypedArraysEqual,
+		"[object Uint8ClampedArray]": areTypedArraysEqual,
+		"[object Uint16Array]": areTypedArraysEqual,
+		"[object Uint32Array]": areTypedArraysEqual
+	};
+}
+/**
+* Whether the items passed are deeply-equal in value.
+*/
+const deepEqual = createCustomEqual();
+/**
+* Whether the items passed are deeply-equal in value based on strict comparison.
+*/
+const strictDeepEqual = createCustomEqual({ strict: true });
+/**
+* Whether the items passed are deeply-equal in value, including circular references.
+*/
+const circularDeepEqual = createCustomEqual({ circular: true });
+/**
+* Whether the items passed are deeply-equal in value, including circular references,
+* based on strict comparison.
+*/
+const strictCircularDeepEqual = createCustomEqual({
+	circular: true,
+	strict: true
+});
+/**
+* Whether the items passed are shallowly-equal in value.
+*/
+const shallowEqual = createCustomEqual({ createInternalComparator: () => sameValueEqual });
+/**
+* Whether the items passed are shallowly-equal in value based on strict comparison
+*/
+const strictShallowEqual = createCustomEqual({
+	strict: true,
+	createInternalComparator: () => sameValueEqual
+});
+/**
+* Whether the items passed are shallowly-equal in value, including circular references.
+*/
+const circularShallowEqual = createCustomEqual({
+	circular: true,
+	createInternalComparator: () => sameValueEqual
+});
+/**
+* Whether the items passed are shallowly-equal in value, including circular references,
+* based on strict comparison.
+*/
+const strictCircularShallowEqual = createCustomEqual({
+	circular: true,
+	createInternalComparator: () => sameValueEqual,
+	strict: true
+});
+/**
+* Create a custom equality comparison method.
+*
+* This can be done to create very targeted comparisons in extreme hot-path scenarios
+* where the standard methods are not performant enough, but can also be used to provide
+* support for legacy environments that do not support expected features like
+* `RegExp.prototype.flags` out of the box.
+*/
+function createCustomEqual(options = {}) {
+	const { circular = false, createInternalComparator: createCustomInternalComparator, createState, strict = false } = options;
+	const comparator = createEqualityComparator(createEqualityComparatorConfig(options));
+	return createIsEqual({
+		circular,
+		comparator,
+		createState,
+		equals: createCustomInternalComparator ? createCustomInternalComparator(comparator) : createInternalEqualityComparator(comparator),
+		strict
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.37.0/node_modules/remeda/dist/lazyDataLastImpl-DtF3cihj.js
+function e(e, t, n) {
+	let r = (n) => e(n, ...t);
+	return n === void 0 ? r : Object.assign(r, {
+		lazy: n,
+		lazyArgs: t
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.37.0/node_modules/remeda/dist/purry.js
+function t$1(t, n, r) {
+	let i = t.length - n.length;
+	if (i === 0) return t(...n);
+	if (i === 1) return e(t, n, r);
+	throw Error(`Wrong number of arguments`);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.37.0/node_modules/remeda/dist/mapValues.js
+function t(...t) {
+	return t$1(n, t);
+}
+function n(e, t) {
+	let n = {};
+	for (let [r, i] of Object.entries(e)) n[r] = t(i, r, e);
+	return n;
+}
+
+//#endregion
+//#region ../vite-plugin/src/internal.ts
+/**
+* This module is used by the Vite plugin to generate the virtual modules
+*/
+/**
+* Create a PluginRPC instance for the LikeC4 Vite plugin
+* used by the Vite plugin in virtual modules
+*/
+function createRpc(options) {
+	return createBirpc({}, {
+		timeout: 120 * 1e3,
+		post: (data) => options.send("likec4:rpc", data),
+		on: (fn) => options.on("likec4:rpc", fn),
+		onTimeoutError(functionName) {
+			return functionName === "applySemanticLayout";
+		},
+		onGeneralError(error, functionName) {
+			console.error(`RPC error in ${functionName}`, { error });
+		},
+		onFunctionError: (error, functionName) => {
+			console.error(`RPC error in ${functionName}`, { error });
+		}
+	});
+}
+function createHooksForModel($atom) {
+	const $likec4model = /* @__PURE__ */ computed($atom, (data) => LikeC4Model.create(data));
+	function updateModel(data) {
+		const current = $atom.get();
+		const next = {
+			...data,
+			views: t(data.views, (next) => {
+				const currentView = current.views[next.id];
+				return deepEqual(currentView, next) ? currentView : next;
+			})
+		};
+		if (shallowEqual(next.views, current.views) && deepEqual(next, current)) return;
+		$atom.set(next);
+	}
+	const $likec4views = /* @__PURE__ */ computed($likec4model, (model) => [...model.views()].map((v) => v.$layouted));
+	function useLikeC4Model() {
+		return useStore($likec4model);
+	}
+	function useLikeC4Views() {
+		return useStore($likec4views);
+	}
+	function useLikeC4View(viewId) {
+		return useStore(useMemo(() => /* @__PURE__ */ computed($likec4model, (model) => model.findView(viewId)?.$layouted ?? null), [viewId]));
+	}
+	return {
+		updateModel,
+		$likec4model,
+		useLikeC4Model,
+		useLikeC4Views,
+		useLikeC4View
+	};
+}
+
+//#endregion
+export { atom, batched, computed, createHooksForModel, createRpc, map, useStore };