likec4 1.59.4 → 1.61.0

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

@@ -1,7 +1,8 @@
-import { LikeC4Model } from "@likec4/core/model";
+import { t as __name } from "./chunks/rolldown-runtime.mjs";
 import { useCallback, useMemo, useRef, useSyncExternalStore } from "react";
+import { LikeC4Model as LikeC4Model$1 } from "@likec4/core/model";
 
-//#region ../../node_modules/.pnpm/nanostores@1.5.3/node_modules/nanostores/atom/index.js
+// ../../node_modules/.pnpm/nanostores@1.5.5/node_modules/nanostores/atom/index.js
 let listenerQueue = [];
 let lqIndex = 0;
 let batchSeen = null;
@@ -13,6 +14,11 @@ let drainQueue = () => {
 	while (lqIndex < listenerQueue.length) {
 		i = lqIndex;
 		lqIndex += QUEUE_ITEMS_PER_LISTENER;
+		let pendingStores = batchSeen?.get(listenerQueue[i]);
+		if (pendingStores) {
+			if (!pendingStores.has(listenerQueue[i + 1])) continue;
+			pendingStores.clear();
+		}
 		try {
 			listenerQueue[i](listenerQueue[i + 1].value, listenerQueue[i + 2], listenerQueue[i + 3]);
 		} catch (e) {
@@ -35,7 +41,8 @@ const atom = /* @__NO_SIDE_EFFECTS__ */ (initialValue) => {
 		listen(listener) {
 			$atom.lc = listeners.push(listener);
 			return () => {
-				for (let i = lqIndex; i < listenerQueue.length;) if (listenerQueue[i] === listener) listenerQueue.splice(i, QUEUE_ITEMS_PER_LISTENER);
+				batchSeen?.get(listener)?.delete($atom);
+				for (let i = lqIndex; i < listenerQueue.length;) if (listenerQueue[i] === listener && listenerQueue[i + 1] === $atom) listenerQueue.splice(i, QUEUE_ITEMS_PER_LISTENER);
 				else i += QUEUE_ITEMS_PER_LISTENER;
 				let index = listeners.indexOf(listener);
 				if (~index) {
@@ -48,8 +55,12 @@ const atom = /* @__NO_SIDE_EFFECTS__ */ (initialValue) => {
 			nanostoresGlobal.epoch++;
 			let runListenerQueue = !listenerQueue.length && !batchSeen;
 			for (let listener of listeners) {
-				if (batchSeen?.has(listener)) continue;
-				batchSeen?.add(listener);
+				if (batchSeen) {
+					let pendingStores = batchSeen.get(listener);
+					if (!pendingStores) batchSeen.set(listener, pendingStores = /* @__PURE__ */ new Set());
+					if (pendingStores.has($atom)) continue;
+					pendingStores.add($atom);
+				}
 				listenerQueue.push(listener, $atom, oldValue, batchSeen ? void 0 : changedKey);
 			}
 			if (runListenerQueue) drainQueue();
@@ -72,8 +83,7 @@ const atom = /* @__NO_SIDE_EFFECTS__ */ (initialValue) => {
 	return $atom;
 };
 
-//#endregion
-//#region ../../node_modules/.pnpm/nanostores@1.5.3/node_modules/nanostores/lifecycle/index.js
+// ../../node_modules/.pnpm/nanostores@1.5.5/node_modules/nanostores/lifecycle/index.js
 const MOUNT = 5;
 const UNMOUNT = 6;
 const REVERT_MUTATION = 10;
@@ -133,8 +143,7 @@ let onMount = ($store, initialize) => {
 	});
 };
 
-//#endregion
-//#region ../../node_modules/.pnpm/nanostores@1.5.3/node_modules/nanostores/computed/index.js
+// ../../node_modules/.pnpm/nanostores@1.5.5/node_modules/nanostores/computed/index.js
 let computedStore = (stores, cb, batched) => {
 	if (!Array.isArray(stores)) stores = [stores];
 	let previousArgs;
@@ -178,8 +187,7 @@ let computedStore = (stores, cb, batched) => {
 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.5.3/node_modules/nanostores/deep-map/path.js
+// ../../node_modules/.pnpm/nanostores@1.5.5/node_modules/nanostores/deep-map/path.js
 function getPath(obj, path) {
 	let allKeys = getAllKeysFromPath(path);
 	let res = obj;
@@ -201,17 +209,16 @@ function getKeyAndIndicesFromKey(key) {
 	return [key];
 }
 
-//#endregion
-//#region ../../node_modules/.pnpm/nanostores@1.5.3/node_modules/nanostores/listen-keys/index.js
+// ../../node_modules/.pnpm/nanostores@1.5.5/node_modules/nanostores/listen-keys/index.js
 function listenKeys($store, keys, listener) {
 	let keysSet = new Set(keys);
 	return $store.listen((value, oldValue, changed) => {
-		if (changed === void 0 ? keys.some((key) => oldValue === void 0 || value[key] !== oldValue[key] || getPath(value, key) !== getPath(oldValue, key)) : keysSet.has(changed) || keysSet.has(changed.split(/\.|\[/)[0])) listener(value, oldValue, changed);
+		let pathChanged = (key) => !Object.is(getPath(value, key), getPath(oldValue, key));
+		if (changed === void 0 ? keys.some((key) => oldValue === void 0 || ($store.eqKey ? !$store.eqKey(oldValue[key], value[key], key) : pathChanged(key))) : keysSet.has(changed) || typeof changed === "string" && (keysSet.has(changed.split(/\.|\[/)[0]) || !$store.eqKey && oldValue !== void 0 && keys.some(pathChanged))) listener(value, oldValue, changed);
 	});
 }
 
-//#endregion
-//#region ../../node_modules/.pnpm/nanostores@1.5.3/node_modules/nanostores/map/index.js
+// ../../node_modules/.pnpm/nanostores@1.5.5/node_modules/nanostores/map/index.js
 const map = /* @__NO_SIDE_EFFECTS__ */ (initial = {}) => {
 	let $map = /* @__PURE__ */ atom(initial);
 	$map.eqKey = Object.is;
@@ -232,8 +239,7 @@ const map = /* @__NO_SIDE_EFFECTS__ */ (initial = {}) => {
 	return $map;
 };
 
-//#endregion
-//#region ../../node_modules/.pnpm/@nanostores+react@1.1.0_nanostores@1.5.3_react@19.2.8/node_modules/@nanostores/react/index.js
+// ../../node_modules/.pnpm/@nanostores+react@2.0.1_nanostores@1.5.5_react@19.3.1/node_modules/@nanostores/react/index.js
 let emit = (snapshotRef, onChange) => (value) => {
 	if (snapshotRef.current === value) return;
 	snapshotRef.current = value;
@@ -252,8 +258,7 @@ function useStore(store, { keys, deps = [store, keys], ssr } = {}) {
 	return useSyncExternalStore(subscribe, get, server);
 }
 
-//#endregion
-//#region ../../node_modules/.pnpm/birpc@4.2.0/node_modules/birpc/dist/index.mjs
+// ../../node_modules/.pnpm/birpc@4.2.0/node_modules/birpc/dist/index.mjs
 function createPromiseWithResolvers() {
 	let resolve;
 	let reject;
@@ -401,7 +406,8 @@ function createBirpc($functions, options) {
 		}
 		if (msg.t === "q") {
 			const { m: method, a: args, o: optional } = msg;
-			let result, error;
+			let result;
+			let 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`);
@@ -450,10 +456,28 @@ function createBirpc($functions, options) {
 	return rpc;
 }
 
-//#endregion
-//#region ../../node_modules/.pnpm/fast-equals@6.0.3/node_modules/fast-equals/dist/es/index.mjs
-const { getOwnPropertyNames, getOwnPropertySymbols } = Object;
-const { hasOwnProperty } = Object.prototype;
+// ../../node_modules/.pnpm/fast-equals@6.2.2/node_modules/fast-equals/dist/es/index.mjs
+const { getOwnPropertyDescriptor, getOwnPropertyNames, getOwnPropertySymbols } = Object;
+const { hasOwnProperty, toString: toString$1 } = Object.prototype;
+const OBJECT_TAG = "[object Object]";
+/**
+* Whether the own properties from `end` onward are equal with strict property checking, where the
+* caller has already verified that both objects have the same number of own properties.
+*/
+function areStrictPropertiesEqual(a, b, state, properties, end) {
+	let index = properties.length;
+	let property;
+	let descriptorA;
+	let descriptorB;
+	while (index-- > end) {
+		property = properties[index];
+		if (!isReactProperty(a, b, property) && (!hasOwn(b, property) || !state.equals(a[property], b[property], property, property, a, b, state))) 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;
+}
 /**
 * Combine two comparators into a single comparators.
 */
@@ -491,14 +515,51 @@ function getStrictProperties(object) {
 	return symbols.length ? getOwnPropertyNames(object).concat(symbols) : getOwnPropertyNames(object);
 }
 /**
+* Identify the element type of TypedArrays across realms and subclasses.
+*/
+const getTypedArrayTag = getOwnPropertyDescriptor(Object.getPrototypeOf(Int8Array.prototype), Symbol.toStringTag).get;
+/**
 * 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 HAS_FLOAT_16_ARRAY = typeof Float16Array !== "undefined";
-const { getOwnPropertyDescriptor, keys } = Object;
+/**
+* Whether a null-prototype object is being compared with a plain object. Only one side can be
+* null-prototype when the constructors differ. The other side must be a plain object by
+* constructor, or by tag when it comes from another realm.
+*/
+function isNullPrototypeComparable(a, b) {
+	const aConstructor = a.constructor;
+	const bConstructor = b.constructor;
+	if (aConstructor == null) return bConstructor === Object || toString$1.call(b) === OBJECT_TAG;
+	if (bConstructor == null) return aConstructor === Object || toString$1.call(a) === OBJECT_TAG;
+	return false;
+}
+/**
+* Whether the property passed is a property specific to React/Preact elements. These are ignored in comparison, as they
+* are deeply circular and will return frequent false negatives for the comparison that matters, which is often the
+* React element's aspects (`props`, `type`, etc.).
+*/
+function isReactProperty(a, b, property) {
+	return (property === "_owner" || property === "__o" || property === "__v") && !!(a.$$typeof || b.$$typeof);
+}
+/**
+* Reorder a serialized query string so that params holding the same pairs compare as equal
+* regardless of the order they appear in.
+*
+* @note
+* The serializer percent-encodes `&` and `=` wherever they appear inside a name or a value, so
+* splitting on `&` recovers exactly the pairs and nothing else.
+*/
+function sortSearchParams(serialized) {
+	return serialized.split("&").sort().join("&");
+}
+/**
+* Above this many keys, out-of-position keys are checked with `propertyIsEnumerable` rather than by
+* scanning the other object's keys. Measured in V8: scanning wins up to 50 keys and loses from 100.
+*/
+const MAX_SCANNED_PROPERTIES = 64;
+const { keys } = Object;
+const { propertyIsEnumerable } = Object.prototype;
 /**
 * 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`.
@@ -554,13 +615,49 @@ function areDatesEqual(a, b) {
 *
 * @note
 * `name`, `message` and `stack` are own properties but are not enumerable, so they are compared
-* explicitly. `cause` is compared by value rather than by reference, matching how every other
-* nested value in the comparison is treated. Own enumerable properties (which custom `Error`
-* subclasses commonly add) are compared by composing this with the object comparator in the
-* comparator config, so that the strict and circular variants apply to them as well.
+* explicitly. `cause` and `errors` are compared by value rather than by reference, matching how
+* every other nested value in the comparison is treated. They are compared exactly once, regardless
+* of whether they were assigned (enumerable) or set by the constructor (non-enumerable). Other own
+* enumerable properties (which custom `Error` subclasses commonly add) are compared afterward.
+*
+* The own property comparison is inlined rather than extracted, which measured faster in V8 when
+* recursing through `cause`. Keep the bytecode under V8's 460-byte TurboFan inlining limit (383 bytes
+* at time of writing; check with `node --print-bytecode --print-bytecode-filter=areErrorsEqual`), or
+* this stops being inlined into its callers.
 */
 function areErrorsEqual(a, b, state) {
-	return a.name === b.name && a.message === b.message && a.stack === b.stack && state.equals(a.cause, b.cause, "cause", "cause", a, b, state);
+	if (a.name !== b.name || a.message !== b.message || a.stack !== b.stack) return false;
+	const causeA = a.cause;
+	const causeB = b.cause;
+	if (causeA !== causeB && !state.equals(causeA, causeB, "cause", "cause", a, b, state)) return false;
+	const errorsA = a.errors;
+	const errorsB = b.errors;
+	if (errorsA !== errorsB && !state.equals(errorsA, errorsB, "errors", "errors", a, b, state)) return false;
+	const propertiesA = keys(a);
+	const propertiesB = keys(b);
+	let index = propertiesA.length;
+	if (!index && !propertiesB.length) return true;
+	let compared = 0;
+	let property;
+	while (index-- > 0) {
+		property = propertiesA[index];
+		if (property === "cause" || property === "errors") continue;
+		if (property !== propertiesB[index] && !propertyIsEnumerable.call(b, property) || !state.equals(a[property], b[property], property, property, a, b, state)) return false;
+		++compared;
+	}
+	const remaining = propertiesB.length - compared;
+	return !remaining || remaining === (propertyIsEnumerable.call(b, "cause") ? 1 : 0) + (propertyIsEnumerable.call(b, "errors") ? 1 : 0);
+}
+/**
+* Whether the errors passed are equal in value.
+*
+* @note
+* `name`, `message` and `stack` are own properties but are not enumerable, so they are compared
+* explicitly. `cause` and `errors` are own properties, so `areObjectsEqualStrict` compares them along
+* with every other own property; they are not compared explicitly to avoid comparing them twice.
+*/
+function areErrorsEqualStrict(a, b, state) {
+	return a.name === b.name && a.message === b.message && a.stack === b.stack && areObjectsEqualStrict(a, b, state);
 }
 /**
 * Whether the `Map`s are equal in value.
@@ -569,7 +666,7 @@ function areMapsEqual(a, b, state) {
 	const size = a.size;
 	if (size !== b.size) return false;
 	if (!size) return true;
-	const matchedIndices = new Uint8Array(size);
+	const matchedIndices = new Array(size);
 	const aIterable = a.entries();
 	let aResult;
 	let bResult;
@@ -577,7 +674,7 @@ function areMapsEqual(a, b, state) {
 	while (aResult = aIterable.next()) {
 		if (aResult.done) break;
 		const bIterable = b.entries();
-		let hasMatch = 0;
+		let hasMatch = false;
 		let matchIndex = 0;
 		while (bResult = bIterable.next()) {
 			if (bResult.done) break;
@@ -588,7 +685,7 @@ function areMapsEqual(a, b, state) {
 			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] = 1;
+				hasMatch = matchedIndices[matchIndex] = true;
 				break;
 			}
 			matchIndex++;
@@ -603,9 +700,16 @@ function areMapsEqual(a, b, state) {
 */
 function areObjectsEqual(a, b, state) {
 	const properties = keys(a);
+	const propertiesB = keys(b);
 	let index = properties.length;
-	if (keys(b).length !== index) return false;
-	while (index-- > 0) if (!isPropertyEqual(a, b, state, properties[index])) return false;
+	if (propertiesB.length !== index) return false;
+	const isScannable = index <= MAX_SCANNED_PROPERTIES;
+	let property;
+	while (index-- > 0) {
+		property = properties[index];
+		if (isReactProperty(a, b, property)) continue;
+		if (property !== propertiesB[index] && !(isScannable ? propertiesB.includes(property) : propertyIsEnumerable.call(b, property)) || !state.equals(a[property], b[property], property, property, a, b, state)) return false;
+	}
 	return true;
 }
 /**
@@ -613,19 +717,7 @@ function areObjectsEqual(a, b, state) {
 */
 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;
+	return getStrictProperties(b).length === properties.length && areStrictPropertiesEqual(a, b, state, properties, 0);
 }
 /**
 * Whether the primitive wrappers passed are equal in value.
@@ -640,25 +732,38 @@ function areRegExpsEqual(a, b) {
 	return a.source === b.source && a.flags === b.flags;
 }
 /**
+* Whether the search params passed are equal in value.
+*
+* @note
+* Order is not significant, matching how the other unordered collections in the library are
+* compared. Repeated keys are, so this is a comparison of multisets rather than of sets:
+* `a=1&a=2` is equal to `a=2&a=1`, but not to `a=1&a=1`.
+*/
+function areSearchParamsEqual(a, b) {
+	const serializedA = a.toString();
+	const serializedB = b.toString();
+	return serializedA === serializedB || sortSearchParams(serializedA) === sortSearchParams(serializedB);
+}
+/**
 * 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 Uint8Array(size);
+	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 = 0;
+		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] = 1;
+				hasMatch = matchedIndices[matchIndex] = true;
 				break;
 			}
 			matchIndex++;
@@ -673,7 +778,8 @@ function areSetsEqual(a, b, state) {
 function areTypedArraysEqual(a, b) {
 	let index = a.length;
 	if (b.length !== index || a.byteOffset !== b.byteOffset) return false;
-	if (a instanceof Float64Array || a instanceof Float32Array || HAS_FLOAT_16_ARRAY && a instanceof Float16Array) {
+	const tag = getTypedArrayTag.call(a);
+	if (tag === "Float64Array" || tag === "Float32Array" || tag === "Float16Array") {
 		while (index-- > 0) if (a[index] !== b[index] && (a[index] === a[index] || b[index] === b[index])) return false;
 		return true;
 	}
@@ -681,47 +787,57 @@ function areTypedArraysEqual(a, b) {
 	return true;
 }
 /**
-* Whether the URL instances are equal in value.
-*/
-function areUrlsEqual(a, b) {
-	if (a.href === b.href) return true;
-	return a.protocol === b.protocol && a.username === b.username && a.password === b.password && a.host === b.host && a.pathname === b.pathname && a.hash === b.hash && areSearchParamsEqual(a.searchParams, b.searchParams);
-}
-/**
-* Whether the search params passed are equal in value.
+* Whether the TypedArray instances are equal in value with strict property checking.
 *
 * @note
-* Order is not significant, matching how the other unordered collections in the library are
-* compared. Repeated keys are, so this is a comparison of multisets rather than of sets:
-* `a=1&a=2` is equal to `a=2&a=1`, but not to `a=1&a=1`.
+* Indexed elements are also own properties, listed first and in order, with descriptors fixed by the
+* spec. They are compared once by `areTypedArraysEqual`, so only the own properties after them
+* (including symbols) are compared with strict property checking.
 */
-function areSearchParamsEqual(a, b) {
-	const serializedA = a.toString();
-	const serializedB = b.toString();
-	return serializedA === serializedB || sortSearchParams(serializedA) === sortSearchParams(serializedB);
+function areTypedArraysEqualStrict(a, b, state) {
+	if (!areTypedArraysEqual(a, b)) return false;
+	const properties = getStrictProperties(a);
+	return getStrictProperties(b).length === properties.length && areStrictPropertiesEqual(a, b, state, properties, a.length);
 }
 /**
-* Reorder a serialized query string so that params holding the same pairs compare as equal
-* regardless of the order they appear in.
-*
-* @note
-* The serializer percent-encodes `&` and `=` wherever they appear inside a name or a value, so
-* splitting on `&` recovers exactly the pairs and nothing else.
+* Whether the URL instances are equal in value.
 */
-function sortSearchParams(serialized) {
-	return serialized.split("&").sort().join("&");
-}
-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);
+function areUrlsEqual(a, b) {
+	if (a.href === b.href) return true;
+	return a.protocol === b.protocol && a.username === b.username && a.password === b.password && a.host === b.host && a.pathname === b.pathname && a.hash === b.hash && areSearchParamsEqual(a.searchParams, b.searchParams);
 }
-const toString = Object.prototype.toString;
+const { toString } = Object.prototype;
 /**
 * 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;
+	const { areArraysEqual, areDatesEqual, areFunctionsEqual, areMapsEqual, areNumbersEqual, areObjectsEqual, areRegExpsEqual, areSetsEqual, getUnsupportedCustomComparator, strictNullPrototypeComparison } = config;
+	/**
+	* Whether the custom objects are equal in value, based on their string tag. If not matching any tags
+	* that require a specific type of comparison, then we hard-code false because the only thing remaining
+	* is strict equality, which has already been compared. This is for a few reasons:
+	*   - Certain types that cannot be introspected (e.g., `WeakMap`). For these types, this is the only
+	*     comparison that can be made.
+	*   - For types that can be introspected but do not have an objective definition of what
+	*     equality is (`Error`, etc.), the subjective decision is to be conservative and strictly compare.
+	* In all cases, these decisions should be reevaluated based on changes to the language and
+	* common development practices.
+	*
+	* Capturing the tag is reasonably performant in modern environments like v8 and SpiderMonkey. This is
+	* kept out of the main comparator so that it stays within the engine's bytecode budget for inlining.
+	* See [#207](https://github.com/planttheidea/fast-equals/pull/207) for more details.
+	*/
+	const areTaggedObjectsEqual = getUnsupportedCustomComparator ? function areTaggedObjectsEqual(a, b, state) {
+		const tag = toString.call(a);
+		const supportedComparator = supportedComparatorMap[tag];
+		if (supportedComparator) return supportedComparator(a, b, state);
+		const unsupportedCustomComparator = getUnsupportedCustomComparator(a, b, state, tag);
+		return unsupportedCustomComparator ? unsupportedCustomComparator(a, b, state) : false;
+	} : function areTaggedObjectsEqual(a, b, state) {
+		const supportedComparator = supportedComparatorMap[toString.call(a)];
+		return supportedComparator ? supportedComparator(a, b, state) : false;
+	};
 	/**
 	* compare the value of the two objects and return true if they are equivalent in values
 	*/
@@ -736,33 +852,29 @@ function createEqualityComparator(config) {
 			return false;
 		}
 		const constructor = a.constructor;
-		if (constructor !== b.constructor) return false;
+		if (constructor !== b.constructor) return strictNullPrototypeComparison ? false : isNullPrototypeComparable(a, b) && areObjectsEqual(a, b, state);
 		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 == null) return areObjectsEqual(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;
+		return areTaggedObjectsEqual(a, b, state);
 	};
 }
 /**
 * Create the configuration object used for building comparators.
 */
-function createEqualityComparatorConfig({ circular, createCustomConfig, strict }) {
+function createEqualityComparatorConfig({ circular, createCustomConfig, strict, strictNullPrototypeComparison = true }) {
 	let config = {
 		areArrayBuffersEqual,
 		areArraysEqual: strict ? areObjectsEqualStrict : areArraysEqual,
 		areDataViewsEqual,
-		areDatesEqual,
-		areErrorsEqual: strict ? combineComparators(areErrorsEqual, areObjectsEqualStrict) : combineComparators(areErrorsEqual, areObjectsEqual),
+		areDatesEqual: strict ? combineComparators(areDatesEqual, areObjectsEqualStrict) : areDatesEqual,
+		areErrorsEqual: strict ? areErrorsEqualStrict : areErrorsEqual,
 		areFunctionsEqual: strictEqual,
 		areMapsEqual: strict ? combineComparators(areMapsEqual, areObjectsEqualStrict) : areMapsEqual,
 		areNumbersEqual: sameValueEqual,
@@ -770,23 +882,28 @@ function createEqualityComparatorConfig({ circular, createCustomConfig, strict }
 		arePrimitiveWrappersEqual,
 		areRegExpsEqual,
 		areSetsEqual: strict ? combineComparators(areSetsEqual, areObjectsEqualStrict) : areSetsEqual,
-		areTypedArraysEqual: strict ? combineComparators(areTypedArraysEqual, areObjectsEqualStrict) : areTypedArraysEqual,
+		areTypedArraysEqual: strict ? areTypedArraysEqualStrict : areTypedArraysEqual,
 		areUrlsEqual,
-		getUnsupportedCustomComparator: void 0
+		getUnsupportedCustomComparator: void 0,
+		strictNullPrototypeComparison
 	};
 	if (createCustomConfig) config = Object.assign({}, config, createCustomConfig(config));
 	if (circular) {
 		const areArraysEqual = createIsCircular(config.areArraysEqual);
+		const areDatesEqual = strict ? createIsCircular(config.areDatesEqual) : config.areDatesEqual;
 		const areErrorsEqual = createIsCircular(config.areErrorsEqual);
 		const areMapsEqual = createIsCircular(config.areMapsEqual);
 		const areObjectsEqual = createIsCircular(config.areObjectsEqual);
 		const areSetsEqual = createIsCircular(config.areSetsEqual);
+		const areTypedArraysEqual = strict ? createIsCircular(config.areTypedArraysEqual) : config.areTypedArraysEqual;
 		config = Object.assign({}, config, {
 			areArraysEqual,
+			areDatesEqual,
 			areErrorsEqual,
 			areMapsEqual,
 			areObjectsEqual,
-			areSetsEqual
+			areSetsEqual,
+			areTypedArraysEqual
 		});
 	}
 	return config;
@@ -935,27 +1052,13 @@ function createCustomEqual(options = {}) {
 	});
 }
 
-//#endregion
-//#region ../../node_modules/.pnpm/remeda@2.45.0/node_modules/remeda/dist/lazyDataLastImpl--3B10z3s.js
-function e(e, t, n) {
-	let r = (n) => e(n, ...t);
-	return n === void 0 ? r : Object.assign(r, {
-		lazy: n,
-		lazyArgs: t
-	});
-}
+// ../../node_modules/.pnpm/remeda@2.52.0/node_modules/remeda/dist/dataLastImplementation-D-BXl-Tn.js
+const e = (e, t) => t.length === 1 ? (n) => e(n, t[0]) : (n) => e(n, ...t);
 
-//#endregion
-//#region ../../node_modules/.pnpm/remeda@2.45.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`);
-}
+// ../../node_modules/.pnpm/remeda@2.52.0/node_modules/remeda/dist/purry.js
+const t$1 = /* @__PURE__ */ __name((t, n) => n.length >= t.length ? t(...n) : e(t, n), "t");
 
-//#endregion
-//#region ../../node_modules/.pnpm/remeda@2.45.0/node_modules/remeda/dist/mapValues.js
+// ../../node_modules/.pnpm/remeda@2.52.0/node_modules/remeda/dist/mapValues.js
 function t(...t) {
 	return t$1(n, t);
 }
@@ -965,11 +1068,7 @@ function n(e, t) {
 	return n;
 }
 
-//#endregion
-//#region ../vite-plugin/src/internal.ts
-/**
-* This module is used by the Vite plugin to generate the virtual modules
-*/
+// ../vite-plugin/src/internal.ts
 /**
 * Create a PluginRPC instance for the LikeC4 Vite plugin
 * used by the Vite plugin in virtual modules
@@ -991,7 +1090,7 @@ function createRpc(options) {
 	});
 }
 function createHooksForModel($atom) {
-	const $likec4model = /* @__PURE__ */ computed($atom, (data) => LikeC4Model.create(data));
+	const $likec4model = /* @__PURE__ */ computed($atom, (data) => LikeC4Model$1.create(data));
 	function updateModel(data) {
 		const current = $atom.get();
 		const next = {
@@ -1020,9 +1119,9 @@ function createHooksForModel($atom) {
 		$likec4model,
 		useLikeC4Model,
 		useLikeC4Views,
-		useLikeC4View
+		useLikeC4View,
+		isLikeC4ViewId: (id) => typeof id === "string" && Object.hasOwn($atom.get().views, id)
 	};
 }
 
-//#endregion
 export { atom, batched, computed, createHooksForModel, createRpc, map, useStore };

package/generators/likec4/package.json

@@ -0,0 +1,4 @@
+{
+  "types": "../../dist/generators/likec4.d.mts",
+  "module": "../../dist/generators/likec4.mjs"
+}