@rpgjs/client 5.0.0-alpha.43 → 5.0.0-alpha.44

package/dist/node_modules/.pnpm/@signe_reactive@2.8.3/node_modules/@signe/reactive/dist/index.js

@@ -1,540 +1,463 @@
-import { BehaviorSubject, filter, combineLatest, map, finalize, Observable } from 'rxjs';
-
+import { BehaviorSubject, Observable, combineLatest, filter, finalize, map } from "rxjs";
+//#region ../../node_modules/.pnpm/@signe+reactive@2.8.3/node_modules/@signe/reactive/dist/index.js
 var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
 var ArraySubject = class extends BehaviorSubject {
-  static {
-    __name(this, "ArraySubject");
-  }
-  _items = [];
-  constructor(items = []) {
-    super({
-      type: "init",
-      items
-    });
-    this.createProxy(items);
-  }
-  createProxy(items) {
-    this._items = new Proxy(items, {
-      get: /* @__PURE__ */ __name((target, prop, receiver) => {
-        const origMethod = target[prop];
-        if (typeof origMethod === "function") {
-          return (...args) => {
-            let changeType = "update";
-            let index = void 0;
-            let isMutateFn = false;
-            let itemsToEmit = [];
-            let changeSplice = true;
-            switch (prop) {
-              case "push":
-                index = target.length;
-                changeType = "add";
-                isMutateFn = true;
-                break;
-              case "pop":
-                index = target.length - 1;
-                changeType = "remove";
-                isMutateFn = true;
-                break;
-              case "unshift":
-                index = 0;
-                changeType = "add";
-                isMutateFn = true;
-                break;
-              case "shift":
-                index = 0;
-                changeType = "remove";
-                isMutateFn = true;
-                break;
-              case "splice":
-                index = args[0];
-                const deleteCount = args[1];
-                const newItems = args.slice(2);
-                itemsToEmit = newItems;
-                if (deleteCount > 0 && newItems.length === 0) {
-                  changeType = "remove";
-                } else if (deleteCount === 0 && newItems.length > 0) {
-                  changeType = "add";
-                } else if (deleteCount === 0 && newItems.length === 0) {
-                  changeSplice = false;
-                } else {
-                  changeType = "update";
-                }
-                isMutateFn = true;
-                break;
-            }
-            const result = origMethod.apply(target, args);
-            if (isMutateFn && changeSplice) {
-              if (prop === "splice") {
-                this.next({
-                  type: changeType,
-                  index,
-                  items: itemsToEmit
-                });
-              } else {
-                this.next({
-                  type: changeType,
-                  index,
-                  items: args
-                });
-              }
-            }
-            return result;
-          };
-        }
-        return Reflect.get(target, prop, receiver);
-      }, "get"),
-      set: /* @__PURE__ */ __name((target, prop, value) => {
-        const index = !isNaN(Number(prop)) ? Number(prop) : void 0;
-        target[prop] = value;
-        this.next({
-          type: "update",
-          index,
-          items: [
-            value
-          ]
-        });
-        return true;
-      }, "set")
-    });
-  }
-  get items() {
-    return this._items;
-  }
-  set items(newItems) {
-    this.createProxy(newItems);
-    this.next({
-      type: "reset",
-      items: newItems
-    });
-  }
+	static {
+		__name(this, "ArraySubject");
+	}
+	_items = [];
+	constructor(items = []) {
+		super({
+			type: "init",
+			items
+		});
+		this.createProxy(items);
+	}
+	createProxy(items) {
+		this._items = new Proxy(items, {
+			get: /* @__PURE__ */ __name((target, prop, receiver) => {
+				const origMethod = target[prop];
+				if (typeof origMethod === "function") return (...args) => {
+					let changeType = "update";
+					let index = void 0;
+					let isMutateFn = false;
+					let itemsToEmit = [];
+					let changeSplice = true;
+					switch (prop) {
+						case "push":
+							index = target.length;
+							changeType = "add";
+							isMutateFn = true;
+							break;
+						case "pop":
+							index = target.length - 1;
+							changeType = "remove";
+							isMutateFn = true;
+							break;
+						case "unshift":
+							index = 0;
+							changeType = "add";
+							isMutateFn = true;
+							break;
+						case "shift":
+							index = 0;
+							changeType = "remove";
+							isMutateFn = true;
+							break;
+						case "splice":
+							index = args[0];
+							const deleteCount = args[1];
+							const newItems = args.slice(2);
+							itemsToEmit = newItems;
+							if (deleteCount > 0 && newItems.length === 0) changeType = "remove";
+							else if (deleteCount === 0 && newItems.length > 0) changeType = "add";
+							else if (deleteCount === 0 && newItems.length === 0) changeSplice = false;
+							else changeType = "update";
+							isMutateFn = true;
+							break;
+					}
+					const result = origMethod.apply(target, args);
+					if (isMutateFn && changeSplice) if (prop === "splice") this.next({
+						type: changeType,
+						index,
+						items: itemsToEmit
+					});
+					else this.next({
+						type: changeType,
+						index,
+						items: args
+					});
+					return result;
+				};
+				return Reflect.get(target, prop, receiver);
+			}, "get"),
+			set: /* @__PURE__ */ __name((target, prop, value) => {
+				const index = !isNaN(Number(prop)) ? Number(prop) : void 0;
+				target[prop] = value;
+				this.next({
+					type: "update",
+					index,
+					items: [value]
+				});
+				return true;
+			}, "set")
+		});
+	}
+	get items() {
+		return this._items;
+	}
+	set items(newItems) {
+		this.createProxy(newItems);
+		this.next({
+			type: "reset",
+			items: newItems
+		});
+	}
 };
 var isArraySubject = /* @__PURE__ */ __name((value) => {
-  return "_items" in value;
+	return "_items" in value;
 }, "isArraySubject");
 var ObjectSubject = class extends BehaviorSubject {
-  static {
-    __name(this, "ObjectSubject");
-  }
-  _obj;
-  constructor(obj = {}) {
-    super({
-      type: "init",
-      value: obj
-    });
-    this.createProxy(obj);
-  }
-  createProxy(obj) {
-    this._obj = new Proxy(obj, {
-      get: /* @__PURE__ */ __name((target, prop, receiver) => {
-        return Reflect.get(target, prop, receiver);
-      }, "get"),
-      set: /* @__PURE__ */ __name((target, prop, value, receiver) => {
-        const key = prop;
-        const changeType = key in target ? "update" : "add";
-        target[key] = value;
-        this.next({
-          type: changeType,
-          key,
-          value
-        });
-        return true;
-      }, "set"),
-      deleteProperty: /* @__PURE__ */ __name((target, prop) => {
-        const key = prop;
-        if (key in target) {
-          const value = target[key];
-          delete target[key];
-          this.next({
-            type: "remove",
-            key,
-            value
-          });
-          return true;
-        }
-        return false;
-      }, "deleteProperty")
-    });
-  }
-  get obj() {
-    return this._obj;
-  }
-  set obj(newObj) {
-    this.createProxy(newObj);
-    this.next({
-      type: "reset",
-      value: newObj
-    });
-  }
+	static {
+		__name(this, "ObjectSubject");
+	}
+	_obj;
+	constructor(obj = {}) {
+		super({
+			type: "init",
+			value: obj
+		});
+		this.createProxy(obj);
+	}
+	createProxy(obj) {
+		this._obj = new Proxy(obj, {
+			get: /* @__PURE__ */ __name((target, prop, receiver) => {
+				return Reflect.get(target, prop, receiver);
+			}, "get"),
+			set: /* @__PURE__ */ __name((target, prop, value, receiver) => {
+				const key = prop;
+				const changeType = key in target ? "update" : "add";
+				target[key] = value;
+				this.next({
+					type: changeType,
+					key,
+					value
+				});
+				return true;
+			}, "set"),
+			deleteProperty: /* @__PURE__ */ __name((target, prop) => {
+				const key = prop;
+				if (key in target) {
+					const value = target[key];
+					delete target[key];
+					this.next({
+						type: "remove",
+						key,
+						value
+					});
+					return true;
+				}
+				return false;
+			}, "deleteProperty")
+		});
+	}
+	get obj() {
+		return this._obj;
+	}
+	set obj(newObj) {
+		this.createProxy(newObj);
+		this.next({
+			type: "reset",
+			value: newObj
+		});
+	}
 };
 var isObjectSubject = /* @__PURE__ */ __name((value) => {
-  return "_obj" in value;
+	return "_obj" in value;
 }, "isObjectSubject");
-var getGlobalReactiveStore = /* @__PURE__ */ __name(() => {
-  const globalKey = "__REACTIVE_STORE__";
-  if (typeof globalThis !== "undefined") {
-    if (!globalThis[globalKey]) {
-      globalThis[globalKey] = {
-        currentDependencyTracker: null,
-        currentSubscriptionsTracker: null
-      };
-    }
-    return globalThis[globalKey];
-  }
-  let globalObj;
-  if (typeof window !== "undefined") {
-    globalObj = window;
-  } else if (typeof process !== "undefined" && process.versions && process.versions.node) {
-    globalObj = Function("return this")();
-  } else if (typeof self !== "undefined") {
-    globalObj = self;
-  } else {
-    console.warn("Unable to find global object, using local instance");
-    return {
-      currentDependencyTracker: null,
-      currentSubscriptionsTracker: null
-    };
-  }
-  if (!globalObj[globalKey]) {
-    globalObj[globalKey] = {
-      currentDependencyTracker: null,
-      currentSubscriptionsTracker: null
-    };
-  }
-  return globalObj[globalKey];
-}, "getGlobalReactiveStore");
-var reactiveStore = getGlobalReactiveStore();
+var reactiveStore = (/* @__PURE__ */ __name(() => {
+	const globalKey = "__REACTIVE_STORE__";
+	if (typeof globalThis !== "undefined") {
+		if (!globalThis[globalKey]) globalThis[globalKey] = {
+			currentDependencyTracker: null,
+			currentSubscriptionsTracker: null
+		};
+		return globalThis[globalKey];
+	}
+	let globalObj;
+	if (typeof window !== "undefined") globalObj = window;
+	else if (typeof process !== "undefined" && process.versions && process.versions.node) globalObj = Function("return this")();
+	else if (typeof self !== "undefined") globalObj = self;
+	else {
+		console.warn("Unable to find global object, using local instance");
+		return {
+			currentDependencyTracker: null,
+			currentSubscriptionsTracker: null
+		};
+	}
+	if (!globalObj[globalKey]) globalObj[globalKey] = {
+		currentDependencyTracker: null,
+		currentSubscriptionsTracker: null
+	};
+	return globalObj[globalKey];
+}, "getGlobalReactiveStore"))();
 var trackDependency = /* @__PURE__ */ __name((signal2) => {
-  if (reactiveStore.currentDependencyTracker) {
-    reactiveStore.currentDependencyTracker(signal2);
-  }
+	if (reactiveStore.currentDependencyTracker) reactiveStore.currentDependencyTracker(signal2);
 }, "trackDependency");
 function signal(defaultValue, options) {
-  let subject;
-  if (Array.isArray(defaultValue)) {
-    subject = new ArraySubject(defaultValue);
-  } else if (typeof defaultValue === "object" && defaultValue !== null) {
-    subject = new ObjectSubject(defaultValue);
-  } else {
-    subject = new BehaviorSubject(defaultValue);
-  }
-  const getValue = /* @__PURE__ */ __name(() => {
-    if (subject instanceof ArraySubject) {
-      return subject.items;
-    } else if (subject instanceof ObjectSubject) {
-      return subject.obj;
-    }
-    return subject.value;
-  }, "getValue");
-  const fn = /* @__PURE__ */ __name(function() {
-    trackDependency(fn);
-    return getValue();
-  }, "fn");
-  fn.set = (value) => {
-    const currentValue = getValue();
-    let shouldEmit = true;
-    if (options?.equal) {
-      shouldEmit = !options.equal(currentValue, value);
-    } else {
-      shouldEmit = currentValue !== value;
-    }
-    if (shouldEmit) {
-      if (subject instanceof ArraySubject) {
-        subject.items = value;
-      } else if (subject instanceof ObjectSubject) {
-        subject.obj = value;
-      } else {
-        subject.next(value);
-      }
-    }
-  };
-  fn._isFrozen = false;
-  fn.freeze = () => {
-    fn._isFrozen = true;
-  };
-  fn.unfreeze = () => {
-    fn._isFrozen = false;
-    if (subject instanceof ArraySubject) {
-      subject.next({
-        type: "init",
-        items: subject.items
-      });
-    } else if (subject instanceof ObjectSubject) {
-      subject.next({
-        type: "init",
-        value: subject.obj
-      });
-    } else {
-      subject.next(subject.value);
-    }
-  };
-  fn.mutate = (mutateFn) => {
-    const value = getValue();
-    mutateFn(value);
-  };
-  fn.update = (updateFn) => {
-    const updatedValue = updateFn(getValue());
-    fn.set(updatedValue);
-  };
-  fn.observable = subject.asObservable().pipe(filter(() => !fn._isFrozen));
-  fn._subject = subject;
-  return fn;
+	let subject;
+	if (Array.isArray(defaultValue)) subject = new ArraySubject(defaultValue);
+	else if (typeof defaultValue === "object" && defaultValue !== null) subject = new ObjectSubject(defaultValue);
+	else subject = new BehaviorSubject(defaultValue);
+	const getValue = /* @__PURE__ */ __name(() => {
+		if (subject instanceof ArraySubject) return subject.items;
+		else if (subject instanceof ObjectSubject) return subject.obj;
+		return subject.value;
+	}, "getValue");
+	const fn = /* @__PURE__ */ __name(function() {
+		trackDependency(fn);
+		return getValue();
+	}, "fn");
+	fn.set = (value) => {
+		const currentValue = getValue();
+		let shouldEmit = true;
+		if (options?.equal) shouldEmit = !options.equal(currentValue, value);
+		else shouldEmit = currentValue !== value;
+		if (shouldEmit) if (subject instanceof ArraySubject) subject.items = value;
+		else if (subject instanceof ObjectSubject) subject.obj = value;
+		else subject.next(value);
+	};
+	fn._isFrozen = false;
+	fn.freeze = () => {
+		fn._isFrozen = true;
+	};
+	fn.unfreeze = () => {
+		fn._isFrozen = false;
+		if (subject instanceof ArraySubject) subject.next({
+			type: "init",
+			items: subject.items
+		});
+		else if (subject instanceof ObjectSubject) subject.next({
+			type: "init",
+			value: subject.obj
+		});
+		else subject.next(subject.value);
+	};
+	fn.mutate = (mutateFn) => {
+		mutateFn(getValue());
+	};
+	fn.update = (updateFn) => {
+		const updatedValue = updateFn(getValue());
+		fn.set(updatedValue);
+	};
+	fn.observable = subject.asObservable().pipe(filter(() => !fn._isFrozen));
+	fn._subject = subject;
+	return fn;
 }
 __name(signal, "signal");
 function isSignal(value) {
-  return !!(value && value.observable);
+	return !!(value && value.observable);
 }
 __name(isSignal, "isSignal");
 function isComputed(value) {
-  return isSignal(value) && !!value.dependencies;
+	return isSignal(value) && !!value.dependencies;
 }
 __name(isComputed, "isComputed");
 function computed(computeFunction, disposableFn) {
-  const dependencies = /* @__PURE__ */ new Set();
-  let init = true;
-  let lastComputedValue;
-  const previousTracker = reactiveStore.currentDependencyTracker;
-  reactiveStore.currentDependencyTracker = (signal2) => {
-    dependencies.add(signal2);
-  };
-  lastComputedValue = computeFunction();
-  if (computeFunction["isEffect"]) {
-    disposableFn = lastComputedValue;
-  }
-  reactiveStore.currentDependencyTracker = previousTracker;
-  const observables = [
-    ...dependencies
-  ].map((dep) => {
-    if (isComputed(dep) && "dependencies" in dep) {
-      const computedDep = dep;
-      if (computedDep.dependencies.size === 0) {
-        return new BehaviorSubject(computedDep()).asObservable();
-      }
-    }
-    return dep.observable;
-  });
-  const computedObservable = combineLatest(observables).pipe(filter(() => !init), map(() => computeFunction()), finalize(() => disposableFn?.()));
-  const fn = /* @__PURE__ */ __name(function() {
-    trackDependency(fn);
-    return lastComputedValue;
-  }, "fn");
-  fn.observable = computedObservable;
-  fn.subscription = computedObservable.subscribe((value) => {
-    lastComputedValue = value;
-  });
-  fn.dependencies = dependencies;
-  reactiveStore.currentSubscriptionsTracker?.(fn.subscription);
-  init = false;
-  return fn;
+	const dependencies = /* @__PURE__ */ new Set();
+	let init = true;
+	let lastComputedValue;
+	const previousTracker = reactiveStore.currentDependencyTracker;
+	reactiveStore.currentDependencyTracker = (signal2) => {
+		dependencies.add(signal2);
+	};
+	lastComputedValue = computeFunction();
+	if (computeFunction["isEffect"]) disposableFn = lastComputedValue;
+	reactiveStore.currentDependencyTracker = previousTracker;
+	const computedObservable = combineLatest([...dependencies].map((dep) => {
+		if (isComputed(dep) && "dependencies" in dep) {
+			const computedDep = dep;
+			if (computedDep.dependencies.size === 0) return new BehaviorSubject(computedDep()).asObservable();
+		}
+		return dep.observable;
+	})).pipe(filter(() => !init), map(() => computeFunction()), finalize(() => disposableFn?.()));
+	const fn = /* @__PURE__ */ __name(function() {
+		trackDependency(fn);
+		return lastComputedValue;
+	}, "fn");
+	fn.observable = computedObservable;
+	fn.subscription = computedObservable.subscribe((value) => {
+		lastComputedValue = value;
+	});
+	fn.dependencies = dependencies;
+	reactiveStore.currentSubscriptionsTracker?.(fn.subscription);
+	init = false;
+	return fn;
 }
 __name(computed, "computed");
 function linkedSignal(computationOrOptions, simpleOptions) {
-  const dependencies = /* @__PURE__ */ new Set();
-  let init = true;
-  let lastComputedValue;
-  let computeFunction;
-  let sourceSignal;
-  let computationFn;
-  let equalFn;
-  let previousValue;
-  let isOverridden = false;
-  let overriddenValue;
-  let depVersion = 0;
-  let overrideDepVersion = null;
-  if (typeof computationOrOptions === "function") {
-    computeFunction = computationOrOptions;
-    equalFn = simpleOptions?.equal;
-  } else {
-    const options = computationOrOptions;
-    sourceSignal = options.source;
-    computationFn = options.computation;
-    equalFn = options.equal;
-    if (typeof sourceSignal === "function" && !isSignal(sourceSignal)) {
-      const sourceFn = sourceSignal;
-      computeFunction = /* @__PURE__ */ __name(() => {
-        const sourceValue = sourceFn();
-        if (computationFn.length > 1) {
-          const result = computationFn(sourceValue, previousValue);
-          previousValue = {
-            source: sourceValue,
-            value: result
-          };
-          return result;
-        } else {
-          const result = computationFn(sourceValue);
-          previousValue = {
-            source: sourceValue,
-            value: result
-          };
-          return result;
-        }
-      }, "computeFunction");
-    } else {
-      const source = typeof sourceSignal === "function" ? sourceSignal : sourceSignal;
-      computeFunction = /* @__PURE__ */ __name(() => {
-        const sourceValue = source();
-        if (computationFn.length > 1) {
-          const result = computationFn(sourceValue, previousValue);
-          previousValue = {
-            source: sourceValue,
-            value: result
-          };
-          return result;
-        } else {
-          const result = computationFn(sourceValue);
-          previousValue = {
-            source: sourceValue,
-            value: result
-          };
-          return result;
-        }
-      }, "computeFunction");
-    }
-  }
-  const previousTracker = reactiveStore.currentDependencyTracker;
-  reactiveStore.currentDependencyTracker = (signal2) => {
-    dependencies.add(signal2);
-  };
-  if (sourceSignal && typeof sourceSignal === "function" && !isSignal(sourceSignal)) {
-    lastComputedValue = computeFunction();
-  } else if (sourceSignal && isSignal(sourceSignal)) {
-    dependencies.add(sourceSignal);
-    lastComputedValue = computeFunction();
-  } else {
-    lastComputedValue = computeFunction();
-  }
-  reactiveStore.currentDependencyTracker = previousTracker;
-  const subject = new BehaviorSubject(lastComputedValue);
-  const observables = [
-    ...dependencies
-  ].map((dep) => {
-    if (isComputed(dep) && "dependencies" in dep) {
-      const computedDep = dep;
-      if (computedDep.dependencies.size === 0) {
-        return new BehaviorSubject(computedDep()).asObservable();
-      }
-    }
-    return dep.observable;
-  });
-  let linkedObservable;
-  if (observables.length > 0) {
-    linkedObservable = combineLatest(observables).pipe(filter(() => !init), map(() => {
-      const computed2 = computeFunction();
-      if (equalFn) {
-        if (!equalFn(lastComputedValue, computed2)) {
-          lastComputedValue = computed2;
-          isOverridden = false;
-        }
-      } else {
-        if (lastComputedValue !== computed2) {
-          lastComputedValue = computed2;
-          isOverridden = false;
-        }
-      }
-      return lastComputedValue;
-    }));
-  } else {
-    linkedObservable = subject.asObservable().pipe(filter(() => !init));
-  }
-  const fn = /* @__PURE__ */ __name(function() {
-    trackDependency(fn);
-    if (isOverridden && dependencies.size > 0) {
-      if (overrideDepVersion !== depVersion) {
-        const computed2 = computeFunction();
-        isOverridden = false;
-        overriddenValue = void 0;
-        lastComputedValue = computed2;
-        overrideDepVersion = null;
-        return computed2;
-      }
-      return overriddenValue;
-    }
-    if (isOverridden) {
-      return overriddenValue;
-    }
-    if (dependencies.size === 0) {
-      const computed2 = computeFunction();
-      lastComputedValue = computed2;
-    }
-    return lastComputedValue;
-  }, "fn");
-  fn.observable = new Observable((observer) => {
-    const depSubscription = linkedObservable.subscribe((value) => {
-      if (dependencies.size > 0) {
-        depVersion++;
-        isOverridden = false;
-        overrideDepVersion = null;
-        lastComputedValue = value;
-      } else {
-        lastComputedValue = value;
-      }
-      observer.next(value);
-    });
-    let subjectSubscription;
-    if (dependencies.size === 0) {
-      subjectSubscription = subject.pipe(filter(() => !init)).subscribe((value) => {
-        observer.next(value);
-      });
-    }
-    observer.next(lastComputedValue);
-    return () => {
-      depSubscription.unsubscribe();
-      if (subjectSubscription) {
-        subjectSubscription.unsubscribe();
-      }
-    };
-  });
-  fn.subscription = fn.observable.subscribe(() => {
-  });
-  fn.dependencies = dependencies;
-  fn._subject = subject;
-  fn.set = (value) => {
-    if (!isOverridden) {
-      overrideDepVersion = depVersion;
-      if (computationFn && sourceSignal) {
-        const sourceValue = untracked(() => {
-          if (typeof sourceSignal === "function") {
-            const source = sourceSignal;
-            return isSignal(source) ? source() : sourceSignal();
-          }
-          return sourceSignal();
-        });
-        previousValue = {
-          source: sourceValue,
-          value
-        };
-      }
-    }
-    isOverridden = true;
-    overriddenValue = value;
-    lastComputedValue = value;
-    subject.next(value);
-  };
-  reactiveStore.currentSubscriptionsTracker?.(fn.subscription);
-  init = false;
-  return fn;
+	const dependencies = /* @__PURE__ */ new Set();
+	let init = true;
+	let lastComputedValue;
+	let computeFunction;
+	let sourceSignal;
+	let computationFn;
+	let equalFn;
+	let previousValue;
+	let isOverridden = false;
+	let overriddenValue;
+	let depVersion = 0;
+	let overrideDepVersion = null;
+	if (typeof computationOrOptions === "function") {
+		computeFunction = computationOrOptions;
+		equalFn = simpleOptions?.equal;
+	} else {
+		const options = computationOrOptions;
+		sourceSignal = options.source;
+		computationFn = options.computation;
+		equalFn = options.equal;
+		if (typeof sourceSignal === "function" && !isSignal(sourceSignal)) {
+			const sourceFn = sourceSignal;
+			computeFunction = /* @__PURE__ */ __name(() => {
+				const sourceValue = sourceFn();
+				if (computationFn.length > 1) {
+					const result = computationFn(sourceValue, previousValue);
+					previousValue = {
+						source: sourceValue,
+						value: result
+					};
+					return result;
+				} else {
+					const result = computationFn(sourceValue);
+					previousValue = {
+						source: sourceValue,
+						value: result
+					};
+					return result;
+				}
+			}, "computeFunction");
+		} else {
+			const source = typeof sourceSignal === "function" ? sourceSignal : sourceSignal;
+			computeFunction = /* @__PURE__ */ __name(() => {
+				const sourceValue = source();
+				if (computationFn.length > 1) {
+					const result = computationFn(sourceValue, previousValue);
+					previousValue = {
+						source: sourceValue,
+						value: result
+					};
+					return result;
+				} else {
+					const result = computationFn(sourceValue);
+					previousValue = {
+						source: sourceValue,
+						value: result
+					};
+					return result;
+				}
+			}, "computeFunction");
+		}
+	}
+	const previousTracker = reactiveStore.currentDependencyTracker;
+	reactiveStore.currentDependencyTracker = (signal2) => {
+		dependencies.add(signal2);
+	};
+	if (sourceSignal && typeof sourceSignal === "function" && !isSignal(sourceSignal)) lastComputedValue = computeFunction();
+	else if (sourceSignal && isSignal(sourceSignal)) {
+		dependencies.add(sourceSignal);
+		lastComputedValue = computeFunction();
+	} else lastComputedValue = computeFunction();
+	reactiveStore.currentDependencyTracker = previousTracker;
+	const subject = new BehaviorSubject(lastComputedValue);
+	const observables = [...dependencies].map((dep) => {
+		if (isComputed(dep) && "dependencies" in dep) {
+			const computedDep = dep;
+			if (computedDep.dependencies.size === 0) return new BehaviorSubject(computedDep()).asObservable();
+		}
+		return dep.observable;
+	});
+	let linkedObservable;
+	if (observables.length > 0) linkedObservable = combineLatest(observables).pipe(filter(() => !init), map(() => {
+		const computed2 = computeFunction();
+		if (equalFn) {
+			if (!equalFn(lastComputedValue, computed2)) {
+				lastComputedValue = computed2;
+				isOverridden = false;
+			}
+		} else if (lastComputedValue !== computed2) {
+			lastComputedValue = computed2;
+			isOverridden = false;
+		}
+		return lastComputedValue;
+	}));
+	else linkedObservable = subject.asObservable().pipe(filter(() => !init));
+	const fn = /* @__PURE__ */ __name(function() {
+		trackDependency(fn);
+		if (isOverridden && dependencies.size > 0) {
+			if (overrideDepVersion !== depVersion) {
+				const computed2 = computeFunction();
+				isOverridden = false;
+				overriddenValue = void 0;
+				lastComputedValue = computed2;
+				overrideDepVersion = null;
+				return computed2;
+			}
+			return overriddenValue;
+		}
+		if (isOverridden) return overriddenValue;
+		if (dependencies.size === 0) lastComputedValue = computeFunction();
+		return lastComputedValue;
+	}, "fn");
+	fn.observable = new Observable((observer) => {
+		const depSubscription = linkedObservable.subscribe((value) => {
+			if (dependencies.size > 0) {
+				depVersion++;
+				isOverridden = false;
+				overrideDepVersion = null;
+				lastComputedValue = value;
+			} else lastComputedValue = value;
+			observer.next(value);
+		});
+		let subjectSubscription;
+		if (dependencies.size === 0) subjectSubscription = subject.pipe(filter(() => !init)).subscribe((value) => {
+			observer.next(value);
+		});
+		observer.next(lastComputedValue);
+		return () => {
+			depSubscription.unsubscribe();
+			if (subjectSubscription) subjectSubscription.unsubscribe();
+		};
+	});
+	fn.subscription = fn.observable.subscribe(() => {});
+	fn.dependencies = dependencies;
+	fn._subject = subject;
+	fn.set = (value) => {
+		if (!isOverridden) {
+			overrideDepVersion = depVersion;
+			if (computationFn && sourceSignal) previousValue = {
+				source: untracked(() => {
+					if (typeof sourceSignal === "function") {
+						const source = sourceSignal;
+						return isSignal(source) ? source() : sourceSignal();
+					}
+					return sourceSignal();
+				}),
+				value
+			};
+		}
+		isOverridden = true;
+		overriddenValue = value;
+		lastComputedValue = value;
+		subject.next(value);
+	};
+	reactiveStore.currentSubscriptionsTracker?.(fn.subscription);
+	init = false;
+	return fn;
 }
 __name(linkedSignal, "linkedSignal");
 function untracked(fn) {
-  const prevDepTracker = reactiveStore.currentDependencyTracker;
-  const prevSubTracker = reactiveStore.currentSubscriptionsTracker;
-  reactiveStore.currentDependencyTracker = null;
-  reactiveStore.currentSubscriptionsTracker = null;
-  try {
-    return fn();
-  } finally {
-    reactiveStore.currentDependencyTracker = prevDepTracker;
-    reactiveStore.currentSubscriptionsTracker = prevSubTracker;
-  }
+	const prevDepTracker = reactiveStore.currentDependencyTracker;
+	const prevSubTracker = reactiveStore.currentSubscriptionsTracker;
+	reactiveStore.currentDependencyTracker = null;
+	reactiveStore.currentSubscriptionsTracker = null;
+	try {
+		return fn();
+	} finally {
+		reactiveStore.currentDependencyTracker = prevDepTracker;
+		reactiveStore.currentSubscriptionsTracker = prevSubTracker;
+	}
 }
 __name(untracked, "untracked");
-
-// src/effect.ts
 function effect(fn) {
-  fn["isEffect"] = true;
-  return computed(fn);
+	fn["isEffect"] = true;
+	return computed(fn);
 }
 __name(effect, "effect");
+//#endregion
+export { isArraySubject, isComputed, isObjectSubject, isSignal, signal };
 
-export { ArraySubject, ObjectSubject, computed, effect, isArraySubject, isComputed, isObjectSubject, isSignal, linkedSignal, signal, untracked };
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map