@kky42/pievo-server 1.0.0

package/.output/server/_libs/eventemitter3.mjs

@@ -0,0 +1,236 @@
+import { o as __toESM, t as __commonJSMin } from "../_runtime.mjs";
+var eventemitter3_default = (/* @__PURE__ */ __toESM((/* @__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;
+})))(), 1)).default;
+//#endregion
+export { eventemitter3_default as t };

package/.output/server/_libs/fast-copy.mjs

@@ -0,0 +1,285 @@
+import { t as __commonJSMin } from "../_runtime.mjs";
+//#region ../../node_modules/.pnpm/fast-copy@4.0.3/node_modules/fast-copy/dist/cjs/index.cjs
+var require_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var toStringFunction = Function.prototype.toString;
+	var toStringObject = Object.prototype.toString;
+	/**
+	* Get an empty version of the object with the same prototype it has.
+	*/
+	function getCleanClone(prototype) {
+		if (!prototype) return Object.create(null);
+		const Constructor = prototype.constructor;
+		if (Constructor === Object) return prototype === Object.prototype ? {} : Object.create(prototype);
+		if (Constructor && ~toStringFunction.call(Constructor).indexOf("[native code]")) try {
+			return new Constructor();
+		} catch (_a) {}
+		return Object.create(prototype);
+	}
+	/**
+	* Get the tag of the value passed, so that the correct copier can be used.
+	*/
+	function getTag(value) {
+		const stringTag = value[Symbol.toStringTag];
+		if (stringTag) return stringTag;
+		const type = toStringObject.call(value);
+		return type.substring(8, type.length - 1);
+	}
+	var { hasOwnProperty, propertyIsEnumerable } = Object.prototype;
+	function copyOwnDescriptor(original, clone, property, state) {
+		const ownDescriptor = Object.getOwnPropertyDescriptor(original, property) || {
+			configurable: true,
+			enumerable: true,
+			value: original[property],
+			writable: true
+		};
+		const descriptor = ownDescriptor.get || ownDescriptor.set ? ownDescriptor : {
+			configurable: ownDescriptor.configurable,
+			enumerable: ownDescriptor.enumerable,
+			value: state.copier(ownDescriptor.value, state),
+			writable: ownDescriptor.writable
+		};
+		try {
+			Object.defineProperty(clone, property, descriptor);
+		} catch (_a) {
+			clone[property] = descriptor.get ? descriptor.get() : descriptor.value;
+		}
+	}
+	/**
+	* Striclty copy all properties contained on the object.
+	*/
+	function copyOwnPropertiesStrict(value, clone, state) {
+		const names = Object.getOwnPropertyNames(value);
+		for (let index = 0; index < names.length; ++index) copyOwnDescriptor(value, clone, names[index], state);
+		const symbols = Object.getOwnPropertySymbols(value);
+		for (let index = 0; index < symbols.length; ++index) copyOwnDescriptor(value, clone, symbols[index], state);
+		return clone;
+	}
+	/**
+	* Deeply copy the indexed values in the array.
+	*/
+	function copyArrayLoose(array, state) {
+		const clone = new state.Constructor();
+		state.cache.set(array, clone);
+		for (let index = 0; index < array.length; ++index) clone[index] = state.copier(array[index], state);
+		return clone;
+	}
+	/**
+	* Deeply copy the indexed values in the array, as well as any custom properties.
+	*/
+	function copyArrayStrict(array, state) {
+		const clone = new state.Constructor();
+		state.cache.set(array, clone);
+		return copyOwnPropertiesStrict(array, clone, state);
+	}
+	/**
+	* Copy the contents of the ArrayBuffer.
+	*/
+	function copyArrayBuffer(arrayBuffer, _state) {
+		return arrayBuffer.slice(0);
+	}
+	/**
+	* Create a new Blob with the contents of the original.
+	*/
+	function copyBlob(blob, _state) {
+		return blob.slice(0, blob.size, blob.type);
+	}
+	/**
+	* Create a new DataView with the contents of the original.
+	*/
+	function copyDataView(dataView, state) {
+		return new state.Constructor(copyArrayBuffer(dataView.buffer));
+	}
+	/**
+	* Create a new Date based on the time of the original.
+	*/
+	function copyDate(date, state) {
+		return new state.Constructor(date.getTime());
+	}
+	/**
+	* Deeply copy the keys and values of the original.
+	*/
+	function copyMapLoose(map, state) {
+		const clone = new state.Constructor();
+		state.cache.set(map, clone);
+		map.forEach((value, key) => {
+			clone.set(key, state.copier(value, state));
+		});
+		return clone;
+	}
+	/**
+	* Deeply copy the keys and values of the original, as well as any custom properties.
+	*/
+	function copyMapStrict(map, state) {
+		return copyOwnPropertiesStrict(map, copyMapLoose(map, state), state);
+	}
+	/**
+	* Deeply copy the properties (keys and symbols) and values of the original.
+	*/
+	function copyObjectLoose(object, state) {
+		const clone = getCleanClone(state.prototype);
+		state.cache.set(object, clone);
+		for (const key in object) if (hasOwnProperty.call(object, key)) clone[key] = state.copier(object[key], state);
+		const symbols = Object.getOwnPropertySymbols(object);
+		for (let index = 0; index < symbols.length; ++index) {
+			const symbol = symbols[index];
+			if (propertyIsEnumerable.call(object, symbol)) clone[symbol] = state.copier(object[symbol], state);
+		}
+		return clone;
+	}
+	/**
+	* Deeply copy the properties (keys and symbols) and values of the original, as well
+	* as any hidden or non-enumerable properties.
+	*/
+	function copyObjectStrict(object, state) {
+		const clone = getCleanClone(state.prototype);
+		state.cache.set(object, clone);
+		return copyOwnPropertiesStrict(object, clone, state);
+	}
+	/**
+	* Create a new primitive wrapper from the value of the original.
+	*/
+	function copyPrimitiveWrapper(primitiveObject, state) {
+		return new state.Constructor(primitiveObject.valueOf());
+	}
+	/**
+	* Create a new RegExp based on the value and flags of the original.
+	*/
+	function copyRegExp(regExp, state) {
+		const clone = new state.Constructor(regExp.source, regExp.flags);
+		clone.lastIndex = regExp.lastIndex;
+		return clone;
+	}
+	/**
+	* Return the original value (an identity function).
+	*
+	* @note
+	* THis is used for objects that cannot be copied, such as WeakMap.
+	*/
+	function copySelf(value, _state) {
+		return value;
+	}
+	/**
+	* Deeply copy the values of the original.
+	*/
+	function copySetLoose(set, state) {
+		const clone = new state.Constructor();
+		state.cache.set(set, clone);
+		set.forEach((value) => {
+			clone.add(state.copier(value, state));
+		});
+		return clone;
+	}
+	/**
+	* Deeply copy the values of the original, as well as any custom properties.
+	*/
+	function copySetStrict(set, state) {
+		return copyOwnPropertiesStrict(set, copySetLoose(set, state), state);
+	}
+	function createDefaultCache() {
+		return /* @__PURE__ */ new WeakMap();
+	}
+	function getOptions({ createCache: createCacheOverride, methods: methodsOverride, strict }) {
+		const defaultMethods = {
+			array: strict ? copyArrayStrict : copyArrayLoose,
+			arrayBuffer: copyArrayBuffer,
+			asyncGenerator: copySelf,
+			blob: copyBlob,
+			dataView: copyDataView,
+			date: copyDate,
+			error: copySelf,
+			generator: copySelf,
+			map: strict ? copyMapStrict : copyMapLoose,
+			object: strict ? copyObjectStrict : copyObjectLoose,
+			regExp: copyRegExp,
+			set: strict ? copySetStrict : copySetLoose
+		};
+		const methods = methodsOverride ? Object.assign(defaultMethods, methodsOverride) : defaultMethods;
+		const copiers = getTagSpecificCopiers(methods);
+		const createCache = createCacheOverride || createDefaultCache;
+		if (!copiers.Object || !copiers.Array) throw new Error("An object and array copier must be provided.");
+		return {
+			createCache,
+			copiers,
+			methods,
+			strict: Boolean(strict)
+		};
+	}
+	/**
+	* Get the copiers used for each specific object tag.
+	*/
+	function getTagSpecificCopiers(methods) {
+		return {
+			Arguments: methods.object,
+			Array: methods.array,
+			ArrayBuffer: methods.arrayBuffer,
+			AsyncGenerator: methods.asyncGenerator,
+			BigInt64Array: methods.arrayBuffer,
+			BigUint64Array: methods.arrayBuffer,
+			Blob: methods.blob,
+			Boolean: copyPrimitiveWrapper,
+			DataView: methods.dataView,
+			Date: methods.date,
+			Error: methods.error,
+			Float32Array: methods.arrayBuffer,
+			Float64Array: methods.arrayBuffer,
+			Generator: methods.generator,
+			Int8Array: methods.arrayBuffer,
+			Int16Array: methods.arrayBuffer,
+			Int32Array: methods.arrayBuffer,
+			Map: methods.map,
+			Number: copyPrimitiveWrapper,
+			Object: methods.object,
+			Promise: copySelf,
+			RegExp: methods.regExp,
+			Set: methods.set,
+			String: copyPrimitiveWrapper,
+			WeakMap: copySelf,
+			WeakSet: copySelf,
+			Uint8Array: methods.arrayBuffer,
+			Uint8ClampedArray: methods.arrayBuffer,
+			Uint16Array: methods.arrayBuffer,
+			Uint32Array: methods.arrayBuffer
+		};
+	}
+	/**
+	* Create a custom copier based on custom options for any of the following:
+	*   - `createCache` method to create a cache for copied objects
+	*   - custom copier `methods` for specific object types
+	*   - `strict` mode to copy all properties with their descriptors
+	*/
+	function createCopier(options = {}) {
+		const { createCache, copiers } = getOptions(options);
+		const { Array: copyArray, Object: copyObject } = copiers;
+		function copier(value, state) {
+			state.prototype = state.Constructor = void 0;
+			if (!value || typeof value !== "object") return value;
+			if (state.cache.has(value)) return state.cache.get(value);
+			state.prototype = Object.getPrototypeOf(value);
+			state.Constructor = state.prototype && state.prototype.constructor;
+			if (!state.Constructor || state.Constructor === Object) return copyObject(value, state);
+			if (Array.isArray(value)) return copyArray(value, state);
+			const tagSpecificCopier = copiers[getTag(value)];
+			if (tagSpecificCopier) return tagSpecificCopier(value, state);
+			return typeof value.then === "function" ? value : copyObject(value, state);
+		}
+		return function copy(value) {
+			return copier(value, {
+				Constructor: void 0,
+				cache: createCache(),
+				copier,
+				prototype: void 0
+			});
+		};
+	}
+	/**
+	* Copy an value deeply as much as possible, where strict recreation of object properties
+	* are maintained. All properties (including non-enumerable ones) are copied with their
+	* original property descriptors on both objects and arrays.
+	*/
+	var copyStrict = createCopier({ strict: true });
+	exports.copy = createCopier();
+	exports.copyStrict = copyStrict;
+	exports.createCopier = createCopier;
+}));
+//#endregion
+export { require_cjs as t };

package/.output/server/_libs/fast-safe-stringify.mjs

@@ -0,0 +1,172 @@
+import { t as __commonJSMin } from "../_runtime.mjs";
+//#region ../../node_modules/.pnpm/fast-safe-stringify@2.1.1/node_modules/fast-safe-stringify/index.js
+var require_fast_safe_stringify = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = stringify;
+	stringify.default = stringify;
+	stringify.stable = deterministicStringify;
+	stringify.stableStringify = deterministicStringify;
+	var LIMIT_REPLACE_NODE = "[...]";
+	var CIRCULAR_REPLACE_NODE = "[Circular]";
+	var arr = [];
+	var replacerStack = [];
+	function defaultOptions() {
+		return {
+			depthLimit: Number.MAX_SAFE_INTEGER,
+			edgesLimit: Number.MAX_SAFE_INTEGER
+		};
+	}
+	function stringify(obj, replacer, spacer, options) {
+		if (typeof options === "undefined") options = defaultOptions();
+		decirc(obj, "", 0, [], void 0, 0, options);
+		var res;
+		try {
+			if (replacerStack.length === 0) res = JSON.stringify(obj, replacer, spacer);
+			else res = JSON.stringify(obj, replaceGetterValues(replacer), spacer);
+		} catch (_) {
+			return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
+		} finally {
+			while (arr.length !== 0) {
+				var part = arr.pop();
+				if (part.length === 4) Object.defineProperty(part[0], part[1], part[3]);
+				else part[0][part[1]] = part[2];
+			}
+		}
+		return res;
+	}
+	function setReplace(replace, val, k, parent) {
+		var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k);
+		if (propertyDescriptor.get !== void 0) if (propertyDescriptor.configurable) {
+			Object.defineProperty(parent, k, { value: replace });
+			arr.push([
+				parent,
+				k,
+				val,
+				propertyDescriptor
+			]);
+		} else replacerStack.push([
+			val,
+			k,
+			replace
+		]);
+		else {
+			parent[k] = replace;
+			arr.push([
+				parent,
+				k,
+				val
+			]);
+		}
+	}
+	function decirc(val, k, edgeIndex, stack, parent, depth, options) {
+		depth += 1;
+		var i;
+		if (typeof val === "object" && val !== null) {
+			for (i = 0; i < stack.length; i++) if (stack[i] === val) {
+				setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
+				return;
+			}
+			if (typeof options.depthLimit !== "undefined" && depth > options.depthLimit) {
+				setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+				return;
+			}
+			if (typeof options.edgesLimit !== "undefined" && edgeIndex + 1 > options.edgesLimit) {
+				setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+				return;
+			}
+			stack.push(val);
+			if (Array.isArray(val)) for (i = 0; i < val.length; i++) decirc(val[i], i, i, stack, val, depth, options);
+			else {
+				var keys = Object.keys(val);
+				for (i = 0; i < keys.length; i++) {
+					var key = keys[i];
+					decirc(val[key], key, i, stack, val, depth, options);
+				}
+			}
+			stack.pop();
+		}
+	}
+	function compareFunction(a, b) {
+		if (a < b) return -1;
+		if (a > b) return 1;
+		return 0;
+	}
+	function deterministicStringify(obj, replacer, spacer, options) {
+		if (typeof options === "undefined") options = defaultOptions();
+		var tmp = deterministicDecirc(obj, "", 0, [], void 0, 0, options) || obj;
+		var res;
+		try {
+			if (replacerStack.length === 0) res = JSON.stringify(tmp, replacer, spacer);
+			else res = JSON.stringify(tmp, replaceGetterValues(replacer), spacer);
+		} catch (_) {
+			return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
+		} finally {
+			while (arr.length !== 0) {
+				var part = arr.pop();
+				if (part.length === 4) Object.defineProperty(part[0], part[1], part[3]);
+				else part[0][part[1]] = part[2];
+			}
+		}
+		return res;
+	}
+	function deterministicDecirc(val, k, edgeIndex, stack, parent, depth, options) {
+		depth += 1;
+		var i;
+		if (typeof val === "object" && val !== null) {
+			for (i = 0; i < stack.length; i++) if (stack[i] === val) {
+				setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
+				return;
+			}
+			try {
+				if (typeof val.toJSON === "function") return;
+			} catch (_) {
+				return;
+			}
+			if (typeof options.depthLimit !== "undefined" && depth > options.depthLimit) {
+				setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+				return;
+			}
+			if (typeof options.edgesLimit !== "undefined" && edgeIndex + 1 > options.edgesLimit) {
+				setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+				return;
+			}
+			stack.push(val);
+			if (Array.isArray(val)) for (i = 0; i < val.length; i++) deterministicDecirc(val[i], i, i, stack, val, depth, options);
+			else {
+				var tmp = {};
+				var keys = Object.keys(val).sort(compareFunction);
+				for (i = 0; i < keys.length; i++) {
+					var key = keys[i];
+					deterministicDecirc(val[key], key, i, stack, val, depth, options);
+					tmp[key] = val[key];
+				}
+				if (typeof parent !== "undefined") {
+					arr.push([
+						parent,
+						k,
+						val
+					]);
+					parent[k] = tmp;
+				} else return tmp;
+			}
+			stack.pop();
+		}
+	}
+	function replaceGetterValues(replacer) {
+		replacer = typeof replacer !== "undefined" ? replacer : function(k, v) {
+			return v;
+		};
+		return function(key, val) {
+			if (replacerStack.length > 0) for (var i = 0; i < replacerStack.length; i++) {
+				var part = replacerStack[i];
+				if (part[1] === key && part[0] === val) {
+					val = part[2];
+					replacerStack.splice(i, 1);
+					break;
+				}
+			}
+			return replacer.call(this, key, val);
+		};
+	}
+}));
+//#endregion
+export { require_fast_safe_stringify as t };