@likec4/language-server 1.47.0 → 1.48.0

package/dist/_chunks/libs/eventemitter3.mjs

@@ -0,0 +1,243 @@
+import { r as __toESM, t as __commonJSMin } from "../rolldown-runtime.mjs";
+
+//#region ../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.js
+var require_eventemitter3 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var has = Object.prototype.hasOwnProperty, prefix = "~";
+	/**
+	* Constructor to create a storage for our `EE` objects.
+	* An `Events` instance is a plain object whose properties are event names.
+	*
+	* @constructor
+	* @private
+	*/
+	function Events() {}
+	if (Object.create) {
+		Events.prototype = Object.create(null);
+		if (!new Events().__proto__) prefix = false;
+	}
+	/**
+	* Representation of a single event listener.
+	*
+	* @param {Function} fn The listener function.
+	* @param {*} context The context to invoke the listener with.
+	* @param {Boolean} [once=false] Specify if the listener is a one-time listener.
+	* @constructor
+	* @private
+	*/
+	function EE(fn, context, once) {
+		this.fn = fn;
+		this.context = context;
+		this.once = once || false;
+	}
+	/**
+	* Add a listener for a given event.
+	*
+	* @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+	* @param {(String|Symbol)} event The event name.
+	* @param {Function} fn The listener function.
+	* @param {*} context The context to invoke the listener with.
+	* @param {Boolean} once Specify if the listener is a one-time listener.
+	* @returns {EventEmitter}
+	* @private
+	*/
+	function addListener(emitter, event, fn, context, once) {
+		if (typeof fn !== "function") throw new TypeError("The listener must be a function");
+		var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+		if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+		else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+		else emitter._events[evt] = [emitter._events[evt], listener];
+		return emitter;
+	}
+	/**
+	* Clear event by name.
+	*
+	* @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+	* @param {(String|Symbol)} evt The Event name.
+	* @private
+	*/
+	function clearEvent(emitter, evt) {
+		if (--emitter._eventsCount === 0) emitter._events = new Events();
+		else delete emitter._events[evt];
+	}
+	/**
+	* Minimal `EventEmitter` interface that is molded against the Node.js
+	* `EventEmitter` interface.
+	*
+	* @constructor
+	* @public
+	*/
+	function EventEmitter() {
+		this._events = new Events();
+		this._eventsCount = 0;
+	}
+	/**
+	* Return an array listing the events for which the emitter has registered
+	* listeners.
+	*
+	* @returns {Array}
+	* @public
+	*/
+	EventEmitter.prototype.eventNames = function eventNames() {
+		var names = [], events, name;
+		if (this._eventsCount === 0) return names;
+		for (name in events = this._events) if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+		if (Object.getOwnPropertySymbols) return names.concat(Object.getOwnPropertySymbols(events));
+		return names;
+	};
+	/**
+	* Return the listeners registered for a given event.
+	*
+	* @param {(String|Symbol)} event The event name.
+	* @returns {Array} The registered listeners.
+	* @public
+	*/
+	EventEmitter.prototype.listeners = function listeners(event) {
+		var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+		if (!handlers) return [];
+		if (handlers.fn) return [handlers.fn];
+		for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) ee[i] = handlers[i].fn;
+		return ee;
+	};
+	/**
+	* Return the number of listeners listening to a given event.
+	*
+	* @param {(String|Symbol)} event The event name.
+	* @returns {Number} The number of listeners.
+	* @public
+	*/
+	EventEmitter.prototype.listenerCount = function listenerCount(event) {
+		var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+		if (!listeners) return 0;
+		if (listeners.fn) return 1;
+		return listeners.length;
+	};
+	/**
+	* Calls each of the listeners registered for a given event.
+	*
+	* @param {(String|Symbol)} event The event name.
+	* @returns {Boolean} `true` if the event had listeners, else `false`.
+	* @public
+	*/
+	EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+		var evt = prefix ? prefix + event : event;
+		if (!this._events[evt]) return false;
+		var listeners = this._events[evt], len = arguments.length, args, i;
+		if (listeners.fn) {
+			if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
+			switch (len) {
+				case 1: return listeners.fn.call(listeners.context), true;
+				case 2: return listeners.fn.call(listeners.context, a1), true;
+				case 3: return listeners.fn.call(listeners.context, a1, a2), true;
+				case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
+				case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+				case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+			}
+			for (i = 1, args = new Array(len - 1); i < len; i++) args[i - 1] = arguments[i];
+			listeners.fn.apply(listeners.context, args);
+		} else {
+			var length = listeners.length, j;
+			for (i = 0; i < length; i++) {
+				if (listeners[i].once) this.removeListener(event, listeners[i].fn, void 0, true);
+				switch (len) {
+					case 1:
+						listeners[i].fn.call(listeners[i].context);
+						break;
+					case 2:
+						listeners[i].fn.call(listeners[i].context, a1);
+						break;
+					case 3:
+						listeners[i].fn.call(listeners[i].context, a1, a2);
+						break;
+					case 4:
+						listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+						break;
+					default:
+						if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) args[j - 1] = arguments[j];
+						listeners[i].fn.apply(listeners[i].context, args);
+				}
+			}
+		}
+		return true;
+	};
+	/**
+	* Add a listener for a given event.
+	*
+	* @param {(String|Symbol)} event The event name.
+	* @param {Function} fn The listener function.
+	* @param {*} [context=this] The context to invoke the listener with.
+	* @returns {EventEmitter} `this`.
+	* @public
+	*/
+	EventEmitter.prototype.on = function on(event, fn, context) {
+		return addListener(this, event, fn, context, false);
+	};
+	/**
+	* Add a one-time listener for a given event.
+	*
+	* @param {(String|Symbol)} event The event name.
+	* @param {Function} fn The listener function.
+	* @param {*} [context=this] The context to invoke the listener with.
+	* @returns {EventEmitter} `this`.
+	* @public
+	*/
+	EventEmitter.prototype.once = function once(event, fn, context) {
+		return addListener(this, event, fn, context, true);
+	};
+	/**
+	* Remove the listeners of a given event.
+	*
+	* @param {(String|Symbol)} event The event name.
+	* @param {Function} fn Only remove the listeners that match this function.
+	* @param {*} context Only remove the listeners that have this context.
+	* @param {Boolean} once Only remove one-time listeners.
+	* @returns {EventEmitter} `this`.
+	* @public
+	*/
+	EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+		var evt = prefix ? prefix + event : event;
+		if (!this._events[evt]) return this;
+		if (!fn) {
+			clearEvent(this, evt);
+			return this;
+		}
+		var listeners = this._events[evt];
+		if (listeners.fn) {
+			if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) clearEvent(this, evt);
+		} else {
+			for (var i = 0, events = [], length = listeners.length; i < length; i++) if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) events.push(listeners[i]);
+			if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+			else clearEvent(this, evt);
+		}
+		return this;
+	};
+	/**
+	* Remove all listeners, or those of the specified event.
+	*
+	* @param {(String|Symbol)} [event] The event name.
+	* @returns {EventEmitter} `this`.
+	* @public
+	*/
+	EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+		var evt;
+		if (event) {
+			evt = prefix ? prefix + event : event;
+			if (this._events[evt]) clearEvent(this, evt);
+		} else {
+			this._events = new Events();
+			this._eventsCount = 0;
+		}
+		return this;
+	};
+	EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+	EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+	EventEmitter.prefixed = prefix;
+	EventEmitter.EventEmitter = EventEmitter;
+	if ("undefined" !== typeof module) module.exports = EventEmitter;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.mjs
+var import_eventemitter3 = /* @__PURE__ */ __toESM(require_eventemitter3(), 1);
+
+//#endregion
+export { import_eventemitter3 as t };

package/dist/_chunks/libs/fast-equals.mjs

@@ -0,0 +1,446 @@
+//#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
+export { deepEqual as t };