likec4 1.60.0 → 1.61.0

package/dist/vite-plugin/internal/index.d.mts

@@ -1,10 +1,75 @@
 import { t as __name } from "./chunks/rolldown-runtime.mjs";
-import { LikeC4Model } from "@likec4/core/model";
 import { DependencyList } from "react";
+import { LikeC4Model } from "@likec4/core/model";
 import { LayoutedElementView, LayoutedLikeC4ModelData, LayoutedView, ProjectId, ViewChange, ViewId } from "@likec4/core/types";
 import { AdhocViewPredicate } from "@likec4/core/compute-view";
-//#region ../vite-plugin/dist/internal/index.d.mts
-//#region ../../node_modules/.pnpm/nanostores@1.5.5/node_modules/nanostores/atom/index.d.ts
+import "@likec4/core/builder";
+import * as c4 from "@likec4/core";
+import "zod/v4";
+import "type-fest";
+import "@likec4/core/utils";
+import "@likec4/core/styles";
+import "chokidar";
+import "@tanstack/ai";
+declare module 'langium' {
+  interface LangiumDocument {
+    likec4ProjectId?: c4.ProjectId;
+  }
+  interface AstNodeDescription {
+    likec4ProjectId?: c4.ProjectId;
+  }
+}
+declare const idattr: unique symbol;
+declare module './generated/ast' {
+  interface Element {
+    [idattr]?: c4.Fqn | undefined;
+  }
+  interface ElementView {
+    [idattr]?: c4.ViewId | undefined;
+  }
+  interface DynamicView {
+    [idattr]?: c4.ViewId | undefined;
+  }
+  interface DeploymentView {
+    [idattr]?: c4.ViewId | undefined;
+  }
+  interface DeploymentNode {
+    [idattr]?: c4.Fqn | undefined;
+  }
+  interface DeployedInstance {
+    [idattr]?: c4.Fqn | undefined;
+  }
+}
+/**
+ * @hidden
+ */
+declare type $keywords<T extends string> = { [key in T]: key; };
+declare module 'ts-graphviz' {
+  namespace GraphAttributeKey {
+    interface $values extends $keywords<'likec4_viewId'> {}
+  }
+  namespace ClusterSubgraphAttributeKey {
+    interface $values extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_level' | 'likec4_depth'> {}
+  }
+  namespace NodeAttributeKey {
+    interface $values extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_project' | 'likec4_level'> {}
+  }
+  namespace EdgeAttributeKey {
+    interface $values extends $keywords<'likec4_id' | 'likec4_project'> {}
+  }
+  namespace Attribute {
+    interface $keys extends $keywords<'likec4_viewId' | 'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_project' | 'likec4_level' | 'likec4_depth'> {}
+    interface $types {
+      likec4_viewId: string;
+      likec4_type: 'folder' | 'file' | 'view';
+      likec4_path: string;
+      likec4_id: string;
+      likec4_project: string;
+      likec4_level: number;
+      likec4_depth: number;
+    }
+  }
+}
 type AllKeys<T> = T extends any ? keyof T : never;
 type Primitive = boolean | number | string;
 type ReadonlyIfObject<Value> = Value extends undefined ? Value : Value extends ((...args: any) => any) ? Value : Value extends Primitive ? Value : Value extends object ? Readonly<Value> : Value;
@@ -143,8 +208,6 @@ type Atom<Value = any> = ReadableAtom<Value> | WritableAtom<Value>;
  * @returns The store object with methods to subscribe.
  */
 export declare function atom<Value, StoreExt = object>(...args: undefined extends Value ? [] | [Value] : [Value]): PreinitializedWritableAtom<Value> & StoreExt;
-//#endregion
-//#region ../../node_modules/.pnpm/nanostores@1.5.5/node_modules/nanostores/map/index.d.ts
 type KeyofBase = keyof any;
 type Get<T, K extends KeyofBase> = T extends any ? K extends keyof T ? T[K] : never : never;
 type HasIndexSignature<T> = string extends keyof T ? true : false;
@@ -257,13 +320,9 @@ export declare function map<Value extends object, StoreExt extends object = obje
  * @returns The store object with methods to subscribe.
  */
 export declare function map<Value extends object, StoreExt extends object = object>(value?: Value): PreinitializedMapStore<Partial<Value>> & StoreExt;
-//#endregion
-//#region ../../node_modules/.pnpm/nanostores@1.5.5/node_modules/nanostores/task/index.d.ts
 interface Task<Value> extends Promise<Value> {
   t: true;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/nanostores@1.5.5/node_modules/nanostores/computed/index.d.ts
 type StoreValues<Stores extends readonly Gettable[]> = { -readonly [Index in keyof Stores]: StoreValue<Stores[Index]>; };
 interface Computed {
   /**
@@ -312,8 +371,6 @@ interface Batched {
   <Value, OriginStores extends readonly Store[]>(stores: readonly [...OriginStores], cb: (...values: StoreValues<OriginStores>) => Task<Value> | Value): ReadableAtom<Value>;
 }
 export declare const batched: Batched;
-//#endregion
-//#region src/rpc/protocol.d.ts
 interface LikeC4VitePluginRpc {
   /**
    * Apply semantic layout (if AI is available)
@@ -343,8 +400,6 @@ interface LikeC4VitePluginRpc {
     predicates: AdhocViewPredicate[];
   }): Promise<LayoutedElementView>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/@nanostores+react@2.0.1_nanostores@1.5.5_react@19.3.0/node_modules/@nanostores/react/index.d.ts
 type StoreKeys<T> = T extends {
   setKey: (k: infer K, v: any) => unknown;
 } ? K : never;
@@ -391,8 +446,27 @@ interface UseStoreOptions<SomeStore> {
  * @returns Store value.
  */
 export declare function useStore<SomeStore extends Store>(store: SomeStore, options?: UseStoreOptions<SomeStore>): StoreValue<SomeStore>;
-//#endregion
-//#region src/internal.d.ts
+/**
+ * @deprecated Use {@link LikeC4AppOptions} at the top level of the plugin options
+ */
+interface LikeC4AppConfig {
+  /**
+   * @deprecated Use `webcomponentPrefix` at the top level of the plugin options
+   */
+  webcomponentPrefix?: string;
+  /**
+   * @deprecated Use `title` at the top level of the plugin options
+   */
+  pageTitle?: string;
+  /**
+   * @deprecated Use `useHashHistory` at the top level of the plugin options
+   */
+  useHashHistory?: boolean | undefined;
+  /**
+   * @deprecated Use `theme` at the top level of the plugin options
+   */
+  theme?: 'light' | 'dark' | undefined;
+}
 export interface LikeC4VitePluginRpcOptions {
   /**
    * Function to post raw message
@@ -414,6 +488,6 @@ export declare function createHooksForModel($atom: WritableAtom<LayoutedLikeC4Mo
   useLikeC4Model: () => LikeC4Model.Layouted;
   useLikeC4Views: () => ReadonlyArray<LayoutedView>;
   useLikeC4View: (viewId: string) => LayoutedView | null;
+  isLikeC4ViewId: (id: unknown) => id is string;
 };
-//#endregion
-export type { Atom, LikeC4VitePluginRpc, ReadableAtom, WritableAtom };
+export type { Atom, LikeC4AppConfig, LikeC4VitePluginRpc, ReadableAtom, WritableAtom };

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

@@ -1,8 +1,8 @@
 import { t as __name } from "./chunks/rolldown-runtime.mjs";
-import { LikeC4Model } from "@likec4/core/model";
 import { useCallback, useMemo, useRef, useSyncExternalStore } from "react";
+import { LikeC4Model as LikeC4Model$1 } from "@likec4/core/model";
 
-//#region ../../node_modules/.pnpm/nanostores@1.5.5/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;
@@ -83,8 +83,7 @@ const atom = /* @__NO_SIDE_EFFECTS__ */ (initialValue) => {
 	return $atom;
 };
 
-//#endregion
-//#region ../../node_modules/.pnpm/nanostores@1.5.5/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;
@@ -144,8 +143,7 @@ let onMount = ($store, initialize) => {
 	});
 };
 
-//#endregion
-//#region ../../node_modules/.pnpm/nanostores@1.5.5/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;
@@ -189,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.5/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;
@@ -212,8 +209,7 @@ function getKeyAndIndicesFromKey(key) {
 	return [key];
 }
 
-//#endregion
-//#region ../../node_modules/.pnpm/nanostores@1.5.5/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) => {
@@ -222,8 +218,7 @@ function listenKeys($store, keys, listener) {
 	});
 }
 
-//#endregion
-//#region ../../node_modules/.pnpm/nanostores@1.5.5/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;
@@ -244,8 +239,7 @@ const map = /* @__NO_SIDE_EFFECTS__ */ (initial = {}) => {
 	return $map;
 };
 
-//#endregion
-//#region ../../node_modules/.pnpm/@nanostores+react@2.0.1_nanostores@1.5.5_react@19.3.0/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;
@@ -264,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;
@@ -463,12 +456,29 @@ function createBirpc($functions, options) {
 	return rpc;
 }
 
-//#endregion
-//#region ../../node_modules/.pnpm/fast-equals@6.1.1/node_modules/fast-equals/dist/es/index.mjs
-const { getOwnPropertyNames, getOwnPropertySymbols } = Object;
+// ../../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.
 */
 function combineComparators(comparatorA, comparatorB) {
@@ -505,6 +515,10 @@ 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));
@@ -520,14 +534,32 @@ function isNullPrototypeComparable(a, b) {
 	if (bConstructor == null) return aConstructor === Object || toString$1.call(a) === OBJECT_TAG;
 	return false;
 }
-const PREACT_VNODE = "__v";
-const PREACT_OWNER = "__o";
-const REACT_OWNER = "_owner";
-const { getOwnPropertyDescriptor, keys } = Object;
 /**
-* Identify the element type of TypedArrays across realms and subclasses.
+* 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.).
 */
-const getTypedArrayTag = getOwnPropertyDescriptor(Object.getPrototypeOf(Int8Array.prototype), Symbol.toStringTag).get;
+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`.
@@ -583,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.
@@ -598,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;
@@ -606,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;
@@ -617,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++;
@@ -632,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;
 }
 /**
@@ -642,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.
@@ -669,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++;
@@ -711,39 +787,24 @@ 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;
 /**
@@ -812,8 +873,8 @@ function createEqualityComparatorConfig({ circular, createCustomConfig, strict,
 		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,
@@ -821,7 +882,7 @@ 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,
 		strictNullPrototypeComparison
@@ -829,16 +890,20 @@ function createEqualityComparatorConfig({ circular, createCustomConfig, strict,
 	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;
@@ -987,28 +1052,13 @@ function createCustomEqual(options = {}) {
 	});
 }
 
-//#endregion
-//#region ../../node_modules/.pnpm/remeda@2.51.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.51.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`);
-}
-__name(t$1, "t");
+// ../../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.51.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);
 }
@@ -1018,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
@@ -1044,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 = {
@@ -1073,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 };