ai 2.1.23 → 2.1.24

package/svelte/dist/index.mjs

@@ -1,4 +1,6 @@
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
@@ -14,6 +16,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -30,7 +33,7 @@ var __async = (__this, __arguments, generator) => {
         reject(e);
       }
     };
-    var step = (x2) => x2.done ? resolve(x2.value) : Promise.resolve(x2.value).then(fulfilled, rejected);
+    var step = (x3) => x3.done ? resolve(x3.value) : Promise.resolve(x3.value).then(fulfilled, rejected);
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
@@ -38,376 +41,418 @@ var __async = (__this, __arguments, generator) => {
 // svelte/use-chat.ts
 import { get, writable } from "svelte/store";
 
-// ../../node_modules/.pnpm/swrev@3.0.0/node_modules/swrev/dist/swrev.es.js
-var __defProp2 = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols2 = Object.getOwnPropertySymbols;
-var __hasOwnProp2 = Object.prototype.hasOwnProperty;
-var __propIsEnum2 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues2 = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp2.call(b, prop))
-      __defNormalProp2(a, prop, b[prop]);
-  if (__getOwnPropSymbols2)
-    for (var prop of __getOwnPropSymbols2(b)) {
-      if (__propIsEnum2.call(b, prop))
-        __defNormalProp2(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __publicField = (obj, key, value) => {
-  __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-var DefaultSWREventManager = class {
+// ../../node_modules/.pnpm/swrev@4.0.0/node_modules/swrev/dist/swrev.mjs
+var P = Object.defineProperty;
+var F = (r, e, t) => e in r ? P(r, e, { enumerable: true, configurable: true, writable: true, value: t }) : r[e] = t;
+var h = (r, e, t) => (F(r, typeof e != "symbol" ? e + "" : e, t), t);
+var I = class {
   constructor() {
-    __publicField(this, "listeners", /* @__PURE__ */ new Map());
+    h(this, "listeners", /* @__PURE__ */ new Map());
   }
-  subscribe(key, listener) {
-    if (!this.listeners.has(key))
-      this.listeners.set(key, []);
-    if (this.listeners.get(key).includes(listener))
-      return;
-    this.listeners.get(key).push(listener);
+  /**
+   * Subscribes a given listener.
+   */
+  subscribe(e, t) {
+    this.listeners.has(e) || this.listeners.set(e, []), !this.listeners.get(e).includes(t) && this.listeners.get(e).push(t);
   }
-  unsubscribe(key, listener) {
-    if (!this.listeners.has(key))
-      return;
-    if (!this.listeners.get(key).includes(listener))
-      return;
-    this.listeners.get(key).splice(this.listeners.get(key).indexOf(listener), 1);
-    if (this.listeners.get(key).length === 0)
-      this.listeners.delete(key);
+  /**
+   * Unsubscribes the given listener.
+   */
+  unsubscribe(e, t) {
+    this.listeners.has(e) && this.listeners.get(e).includes(t) && (this.listeners.get(e).splice(this.listeners.get(e).indexOf(t), 1), this.listeners.get(e).length === 0 && this.listeners.delete(e));
   }
-  emit(key, payload) {
-    if (!this.listeners.has(key))
-      return;
-    this.listeners.get(key).forEach((listener) => listener(payload));
+  /**
+   * Emits an event to all active listeners.
+   */
+  emit(e, t) {
+    this.listeners.has(e) && this.listeners.get(e).forEach((s) => s(t));
   }
 };
-var defaultCacheRemoveOptions = {
+var L = {
   broadcast: false
 };
-var defaultCacheClearOptions = {
+var S = {
   broadcast: false
 };
-var CacheItem = class {
-  constructor({ data, expiresAt = null }) {
-    __publicField(this, "data");
-    __publicField(this, "expiresAt");
-    this.data = data;
-    this.expiresAt = expiresAt;
+var O = class {
+  /**
+   * Creates the cache item given the data and expiration at.
+   */
+  constructor({ data: e, expiresAt: t = null }) {
+    h(this, "data");
+    h(this, "expiresAt");
+    this.data = e, this.expiresAt = t;
   }
+  /**
+   * Determines if the current cache item is still being resolved.
+   * This returns true if data is a promise, or false if type `D`.
+   */
   isResolving() {
     return this.data instanceof Promise;
   }
+  /**
+   * Determines if the given cache item has expired.
+   */
   hasExpired() {
     return this.expiresAt === null || this.expiresAt < /* @__PURE__ */ new Date();
   }
-  expiresIn(milliseconds) {
-    this.expiresAt = /* @__PURE__ */ new Date();
-    this.expiresAt.setMilliseconds(this.expiresAt.getMilliseconds() + milliseconds);
-    return this;
+  /**
+   * Set the expiration time of the given cache item relative to now.
+   */
+  expiresIn(e) {
+    return this.expiresAt = /* @__PURE__ */ new Date(), this.expiresAt.setMilliseconds(this.expiresAt.getMilliseconds() + e), this;
   }
 };
-var DefaultCache = class {
+var q = class {
   constructor() {
-    __publicField(this, "elements", /* @__PURE__ */ new Map());
-    __publicField(this, "event", new DefaultSWREventManager());
+    h(this, "elements", /* @__PURE__ */ new Map());
+    h(this, "event", new I());
   }
-  resolve(key, value) {
-    Promise.resolve(value.data).then((detail) => {
-      if (detail === void 0 || detail === null) {
-        return this.remove(key);
-      }
-      value.data = detail;
-      this.broadcast(key, detail);
+  /**
+   * Resolves the promise and replaces the Promise to the resolved data.
+   * It also broadcasts the value change if needed or deletes the key if
+   * the value resolves to undefined or null.
+   */
+  resolve(e, t) {
+    Promise.resolve(t.data).then((s) => {
+      if (s == null)
+        return this.remove(e);
+      t.data = s, this.broadcast(e, s);
     });
   }
-  get(key) {
-    return this.elements.get(key);
+  /**
+   * Gets an element from the cache.
+   *
+   * It is assumed the item always exist when
+   * you get it. Use the has method to check
+   * for the existence of it.
+   */
+  get(e) {
+    return this.elements.get(e);
   }
-  set(key, value) {
-    this.elements.set(key, value);
-    this.resolve(key, value);
+  /**
+   * Sets an element to the cache.
+   */
+  set(e, t) {
+    this.elements.set(e, t), this.resolve(e, t);
   }
-  remove(key, options) {
-    const { broadcast } = __spreadValues2(__spreadValues2({}, defaultCacheRemoveOptions), options);
-    if (broadcast)
-      this.broadcast(key, void 0);
-    this.elements.delete(key);
+  /**
+   * Removes an key-value pair from the cache.
+   */
+  remove(e, t) {
+    const { broadcast: s } = __spreadValues(__spreadValues({}, L), t);
+    s && this.broadcast(e, void 0), this.elements.delete(e);
   }
-  clear(options) {
-    const { broadcast } = __spreadValues2(__spreadValues2({}, defaultCacheClearOptions), options);
-    if (broadcast)
-      for (const key of this.elements.keys())
-        this.broadcast(key, void 0);
+  /**
+   * Removes all the key-value pairs from the cache.
+   */
+  clear(e) {
+    const { broadcast: t } = __spreadValues(__spreadValues({}, S), e);
+    if (t)
+      for (const s of this.elements.keys())
+        this.broadcast(s, void 0);
     this.elements.clear();
   }
-  has(key) {
-    return this.elements.has(key);
+  /**
+   * Determines if the given key exists
+   * in the cache.
+   */
+  has(e) {
+    return this.elements.has(e);
   }
-  subscribe(key, listener) {
-    this.event.subscribe(key, listener);
+  /**
+   * Subscribes the callback to the given key.
+   */
+  subscribe(e, t) {
+    this.event.subscribe(e, t);
   }
-  unsubscribe(key, listener) {
-    this.event.unsubscribe(key, listener);
+  /**
+   * Unsubscribes to the given key events.
+   */
+  unsubscribe(e, t) {
+    this.event.unsubscribe(e, t);
   }
-  broadcast(key, data) {
-    this.event.emit(key, data);
+  /**
+   * Broadcasts a value change  on all subscribed instances.
+   */
+  broadcast(e, t) {
+    this.event.emit(e, t);
   }
 };
-var defaultOptions = {
-  cache: new DefaultCache(),
-  errors: new DefaultSWREventManager(),
-  fetcher: (url) => __async(void 0, null, function* () {
-    const response = yield fetch(url);
-    if (!response.ok)
+var x = {
+  cache: new q(),
+  errors: new I(),
+  fetcher: (r) => __async(void 0, null, function* () {
+    const e = yield fetch(r);
+    if (!e.ok)
       throw Error("Not a 2XX response.");
-    return response.json();
+    return e.json();
   }),
-  initialData: void 0,
+  fallbackData: void 0,
   loadInitialCache: true,
   revalidateOnStart: true,
   dedupingInterval: 2e3,
   revalidateOnFocus: true,
   focusThrottleInterval: 5e3,
   revalidateOnReconnect: true,
-  reconnectWhen: (notify, { enabled }) => {
-    if (enabled && typeof window !== "undefined") {
-      window.addEventListener("online", notify);
-      return () => window.removeEventListener("online", notify);
-    }
-    return () => {
-    };
+  reconnectWhen: (r, { enabled: e }) => e && typeof window < "u" ? (window.addEventListener("online", r), () => window.removeEventListener("online", r)) : () => {
   },
-  focusWhen: (notify, { enabled, throttleInterval }) => {
-    if (enabled && typeof window !== "undefined") {
-      let lastFocus = null;
-      const rawHandler = () => {
-        const now = Date.now();
-        if (lastFocus === null || now - lastFocus > throttleInterval) {
-          lastFocus = now;
-          notify();
-        }
+  focusWhen: (r, { enabled: e, throttleInterval: t }) => {
+    if (e && typeof window < "u") {
+      let s = null;
+      const i = () => {
+        const a = Date.now();
+        (s === null || a - s > t) && (s = a, r());
       };
-      window.addEventListener("focus", rawHandler);
-      return () => window.removeEventListener("focus", rawHandler);
+      return window.addEventListener("focus", i), () => window.removeEventListener("focus", i);
     }
     return () => {
     };
-  }
+  },
+  revalidateFunction: void 0
 };
-var defaultRevalidateOptions = __spreadProps(__spreadValues2({}, defaultOptions), {
+var E = __spreadProps(__spreadValues({}, x), {
   force: false
 });
-var defaultMutateOptions = {
+var T = {
   revalidate: true,
-  revalidateOptions: __spreadValues2({}, defaultRevalidateOptions)
+  revalidateOptions: __spreadValues({}, E),
+  revalidateFunction: void 0
 };
-var defaultClearOptions = {
+var X = {
   broadcast: false
 };
-var SWR = class {
-  constructor(options) {
-    __publicField(this, "options");
-    this.options = __spreadValues2(__spreadValues2({}, defaultOptions), options);
+var H = class {
+  /**
+   * Creates a new instance of SWR.
+   */
+  constructor(e) {
+    h(this, "options");
+    this.options = __spreadValues(__spreadValues({}, x), e);
   }
+  /**
+   * Gets the cache of the SWR.
+   */
   get cache() {
     return this.options.cache;
   }
+  /**
+   * Gets the cache of the SWR.
+   */
   get errors() {
     return this.options.errors;
   }
-  requestData(key, fetcher) {
-    return Promise.resolve(fetcher(key)).catch((data) => {
-      this.errors.emit(key, data);
-      return void 0;
+  /**
+   * Requests the data using the provided fetcher.
+   */
+  requestData(e, t) {
+    return __async(this, null, function* () {
+      return yield Promise.resolve(t(e)).catch((s) => {
+        throw this.errors.emit(e, s), s;
+      });
     });
   }
-  resolveKey(key) {
-    if (typeof key === "function") {
+  /**
+   * Resolves the given to a SWRKey or undefined.
+   */
+  resolveKey(e) {
+    if (typeof e == "function")
       try {
-        return key();
-      } catch (e) {
-        return void 0;
+        return e();
+      } catch (e2) {
+        return;
       }
-    }
-    return key;
-  }
-  clear(keys, options) {
-    const ops = __spreadValues2(__spreadValues2({}, defaultClearOptions), options);
-    if (keys === void 0 || keys === null)
-      return this.cache.clear(ops);
-    if (!Array.isArray(keys))
-      return this.cache.remove(keys, ops);
-    for (const key of keys)
-      this.cache.remove(key, ops);
-  }
-  revalidate(key, options) {
-    if (!key)
-      return;
-    const { fetcher: defaultFetcher, dedupingInterval: defaultDedupingInterval } = this.options;
-    const { force, fetcher, dedupingInterval } = __spreadValues2(__spreadValues2(__spreadValues2({}, defaultRevalidateOptions), { fetcher: defaultFetcher, dedupingInterval: defaultDedupingInterval }), options);
-    let data = void 0;
-    if (force || !this.cache.has(key) || this.cache.has(key) && this.cache.get(key).hasExpired()) {
-      data = this.requestData(key, fetcher);
-    }
-    if (data !== void 0) {
-      this.mutate(key, new CacheItem({ data }).expiresIn(dedupingInterval), {
-        revalidate: false
-      });
-    }
+    return e;
   }
-  mutate(key, value, options) {
-    if (!key)
-      return;
-    const { revalidate: revalidateAfterMutation, revalidateOptions } = __spreadValues2(__spreadValues2({}, defaultMutateOptions), options);
-    let data;
-    if (typeof value === "function") {
-      let state = null;
-      if (this.cache.has(key)) {
-        const item = this.cache.get(key);
-        if (!item.isResolving())
-          state = item.data;
+  /**
+   * Clear the specified keys from the cache. If no keys
+   * are specified, it clears all the cache keys.
+   */
+  clear(e, t) {
+    const s = __spreadValues(__spreadValues({}, X), t);
+    if (e == null)
+      return this.cache.clear(s);
+    if (!Array.isArray(e))
+      return this.cache.remove(e, s);
+    for (const i of e)
+      this.cache.remove(i, s);
+  }
+  /**
+   * Revalidates the key and mutates the cache if needed.
+   */
+  revalidate(e, t) {
+    return __async(this, null, function* () {
+      if (!e)
+        throw new Error("[Revalidate] Key issue: ${key}");
+      const { fetcher: s, dedupingInterval: i } = this.options, { force: a, fetcher: o, dedupingInterval: n } = __spreadValues(__spreadProps(__spreadValues({}, E), {
+        fetcher: s,
+        dedupingInterval: i
+      }), t);
+      if (a || !this.cache.has(e) || this.cache.has(e) && this.cache.get(e).hasExpired()) {
+        const c2 = this.requestData(e, o), l = c2.catch(() => {
+        });
+        return this.cache.set(e, new O({ data: l }).expiresIn(n)), yield c2;
       }
-      data = value(state);
-    } else {
-      data = value;
-    }
-    this.cache.set(key, data instanceof CacheItem ? data : new CacheItem({ data }));
-    if (revalidateAfterMutation)
-      this.revalidate(key, revalidateOptions);
-  }
-  subscribeData(key, onData) {
-    if (key) {
-      const handler = (payload) => onData(payload);
-      this.cache.subscribe(key, handler);
-      return () => this.cache.unsubscribe(key, handler);
+      return this.getWait(e);
+    });
+  }
+  /**
+   * Mutates the data of a given key with a new value.
+   * This is used to replace the cache contents of the
+   * given key manually.
+   */
+  mutate(e, t, s) {
+    return __async(this, null, function* () {
+      var _a;
+      if (!e)
+        throw new Error("[Mutate] Key issue: ${key}");
+      const {
+        revalidate: i,
+        revalidateOptions: a,
+        revalidateFunction: o
+      } = __spreadValues(__spreadValues({}, T), s);
+      let n;
+      if (typeof t == "function") {
+        let c2;
+        if (this.cache.has(e)) {
+          const l = this.cache.get(e);
+          l.isResolving() || (c2 = l.data);
+        }
+        n = t(c2);
+      } else
+        n = t;
+      return this.cache.set(e, new O({ data: n })), i ? yield (_a = o == null ? void 0 : o(e, a)) != null ? _a : this.revalidate(e, a) : n;
+    });
+  }
+  /**
+   * Gets the data of the given key. Keep in mind
+   * this data will be stale and revalidate in the background
+   * unless specified otherwise.
+   */
+  subscribeData(e, t) {
+    if (e) {
+      const s = (i) => t(i);
+      return this.cache.subscribe(e, s), () => this.cache.unsubscribe(e, s);
     }
     return () => {
     };
   }
-  subscribeErrors(key, onError) {
-    if (key) {
-      const handler = (payload) => onError(payload);
-      this.errors.subscribe(key, handler);
-      return () => this.errors.unsubscribe(key, handler);
+  /**
+   * Subscribes to errors on the given key.
+   */
+  subscribeErrors(e, t) {
+    if (e) {
+      const s = (i) => t(i);
+      return this.errors.subscribe(e, s), () => this.errors.unsubscribe(e, s);
     }
     return () => {
     };
   }
-  get(key) {
-    if (key && this.cache.has(key)) {
-      const item = this.cache.get(key);
-      if (!item.isResolving())
-        return item.data;
+  /**
+   * Gets the current cached data of the given key.
+   * This does not trigger any revalidation nor mutation
+   * of the data.
+   * - If the data has never been validated
+   * (there is no cache) it will return undefined.
+   * - If the item is pending to resolve (there is a request
+   * pending to resolve) it will return undefined.
+   */
+  get(e) {
+    if (e && this.cache.has(e)) {
+      const t = this.cache.get(e);
+      if (!t.isResolving())
+        return t.data;
     }
-    return void 0;
   }
-  getWait(key) {
-    return new Promise((resolve, reject) => {
-      const unsubscribe = this.subscribeData(key, (data) => {
-        unsubscribe();
-        return resolve(data);
-      });
-      const unsubscribeErrors = this.subscribeErrors(key, (error) => {
-        unsubscribeErrors();
-        return reject(error);
-      });
-      const current = this.get(key);
-      if (current)
-        return resolve(current);
+  /**
+   * Gets an element from the cache. The difference
+   * with the get is that this method returns a promise
+   * that will resolve the the value. If there's no item
+   * in the cache, it will wait for it before resolving.
+   */
+  getWait(e) {
+    return new Promise((t, s) => {
+      const i = this.subscribeData(e, (n) => {
+        if (i(), n !== void 0)
+          return t(n);
+      }), a = this.subscribeErrors(e, (n) => {
+        if (a(), n !== void 0)
+          return s(n);
+      }), o = this.get(e);
+      if (o !== void 0)
+        return t(o);
     });
   }
-  subscribe(key, onData, onError, options) {
+  /**
+   * Use a SWR value given the key and
+   * subscribe to future changes.
+   */
+  subscribe(e, t, s, i) {
     const {
-      fetcher,
-      initialData,
-      loadInitialCache,
-      revalidateOnStart,
-      dedupingInterval,
-      revalidateOnFocus,
-      focusThrottleInterval,
-      revalidateOnReconnect,
-      reconnectWhen,
-      focusWhen
-    } = __spreadValues2(__spreadValues2({}, this.options), options);
-    const mutateCurrent = (value, options2) => {
-      return this.mutate(this.resolveKey(key), value, options2);
-    };
-    const revalidateCurrent = (options2) => {
-      return this.revalidate(this.resolveKey(key), options2);
-    };
-    const revalidateCurrentWithOptions = () => {
-      return revalidateCurrent({ fetcher, dedupingInterval });
-    };
-    if (revalidateOnStart)
-      revalidateCurrentWithOptions();
-    const unsubscribeData = this.subscribeData(this.resolveKey(key), onData);
-    const unsubscribeErrors = this.subscribeErrors(this.resolveKey(key), onError);
-    const unsubscribeVisibility = focusWhen(revalidateCurrentWithOptions, {
-      throttleInterval: focusThrottleInterval,
-      enabled: revalidateOnFocus
-    });
-    const unsubscribeNetwork = reconnectWhen(revalidateCurrentWithOptions, {
-      enabled: revalidateOnReconnect
+      fetcher: a,
+      fallbackData: o,
+      loadInitialCache: n,
+      revalidateOnStart: c2,
+      dedupingInterval: l,
+      revalidateOnFocus: A2,
+      focusThrottleInterval: C,
+      revalidateOnReconnect: R,
+      reconnectWhen: W2,
+      focusWhen: D2,
+      revalidateFunction: d
+    } = __spreadValues(__spreadValues({}, this.options), i), K2 = (m) => {
+      var _a;
+      return (_a = d == null ? void 0 : d(this.resolveKey(e), m)) != null ? _a : this.revalidate(this.resolveKey(e), m);
+    }, f = () => K2({ fetcher: a, dedupingInterval: l }), u = n ? this.get(this.resolveKey(e)) : o != null ? o : void 0, g = c2 ? f() : Promise.resolve(void 0), M = u ? Promise.resolve(u) : g;
+    u && (t == null || t(u));
+    const v2 = t ? this.subscribeData(this.resolveKey(e), t) : void 0, b = s ? this.subscribeErrors(this.resolveKey(e), s) : void 0, p2 = D2(f, {
+      throttleInterval: C,
+      enabled: A2
+    }), w2 = W2(f, {
+      enabled: R
     });
-    const unsubscribe = () => {
-      unsubscribeData();
-      unsubscribeErrors();
-      unsubscribeVisibility == null ? void 0 : unsubscribeVisibility();
-      unsubscribeNetwork == null ? void 0 : unsubscribeNetwork();
-    };
-    if (initialData) {
-      mutateCurrent(initialData, { revalidate: false });
-    }
-    if (loadInitialCache) {
-      const cachedData = this.get(this.resolveKey(key));
-      if (cachedData)
-        onData(cachedData);
-    }
-    return { unsubscribe };
+    return { unsubscribe: () => {
+      v2 == null || v2(), b == null || b(), p2 == null || p2(), w2 == null || w2();
+    }, dataPromise: M, revalidatePromise: g };
   }
 };
 
-// ../../node_modules/.pnpm/sswr@1.10.0_svelte@4.0.0/node_modules/sswr/dist/sswr.mjs
-import { beforeUpdate as _, onDestroy as D } from "svelte";
-function h() {
+// ../../node_modules/.pnpm/sswr@2.0.0_svelte@4.0.0/node_modules/sswr/dist/sswr.mjs
+import { beforeUpdate as w, onDestroy as E2 } from "svelte";
+function p() {
 }
-function E(t) {
+function D(t) {
   return t();
 }
-function q(t) {
-  t.forEach(E);
+function q2(t) {
+  t.forEach(D);
 }
-function w(t) {
+function x2(t) {
   return typeof t == "function";
 }
 function K(t, e) {
   return t != t ? e == e : t !== e || t && typeof t == "object" || typeof t == "function";
 }
-function x(t, ...e) {
-  if (t == null)
-    return h;
+function z(t, ...e) {
+  if (t == null) {
+    for (const r of e)
+      r(void 0);
+    return p;
+  }
   const n = t.subscribe(...e);
   return n.unsubscribe ? () => n.unsubscribe() : n;
 }
-Promise.resolve();
 var v = [];
-function z(t, e) {
+function A(t, e) {
   return {
-    subscribe: m(t, e).subscribe
+    subscribe: y(t, e).subscribe
   };
 }
-function m(t, e = h) {
+function y(t, e = p) {
   let n;
   const r = /* @__PURE__ */ new Set();
-  function c(i) {
-    if (K(t, i) && (t = i, n)) {
+  function i(u) {
+    if (K(t, u) && (t = u, n)) {
       const f = !v.length;
       for (const s of r)
         s[1](), v.push(s, t);
@@ -418,63 +463,72 @@ function m(t, e = h) {
       }
     }
   }
-  function l(i) {
-    c(i(t));
+  function a(u) {
+    i(u(t));
   }
-  function d(i, f = h) {
-    const s = [i, f];
-    return r.add(s), r.size === 1 && (n = e(c) || h), i(t), () => {
-      r.delete(s), r.size === 0 && (n(), n = null);
+  function d(u, f = p) {
+    const s = [u, f];
+    return r.add(s), r.size === 1 && (n = e(i, a) || p), u(t), () => {
+      r.delete(s), r.size === 0 && n && (n(), n = null);
     };
   }
-  return { set: c, update: l, subscribe: d };
+  return { set: i, update: a, subscribe: d };
 }
-function S(t, e, n) {
-  const r = !Array.isArray(t), c = r ? [t] : t, l = e.length < 2;
-  return z(n, (d) => {
-    let i = false;
-    const f = [];
-    let s = 0, p = h;
-    const o = () => {
-      if (s)
+function S2(t, e, n) {
+  const r = !Array.isArray(t), i = r ? [t] : t;
+  if (!i.every(Boolean))
+    throw new Error("derived() expects stores as input, got a falsy value");
+  const a = e.length < 2;
+  return A(n, (d, u) => {
+    let f = false;
+    const s = [];
+    let h2 = 0, o = p;
+    const l = () => {
+      if (h2)
         return;
-      p();
-      const a = e(r ? f[0] : f, d);
-      l ? d(a) : p = w(a) ? a : h;
-    }, b = c.map((a, g) => x(a, (y) => {
-      f[g] = y, s &= ~(1 << g), i && o();
-    }, () => {
-      s |= 1 << g;
-    }));
-    return i = true, o(), function() {
-      q(b), p();
+      o();
+      const b = e(r ? s[0] : s, d, u);
+      a ? d(b) : o = x2(b) ? b : p;
+    }, g = i.map(
+      (b, m) => z(
+        b,
+        (R) => {
+          s[m] = R, h2 &= ~(1 << m), f && l();
+        },
+        () => {
+          h2 |= 1 << m;
+        }
+      )
+    );
+    return f = true, l(), function() {
+      q2(g), o(), f = false;
     };
   });
 }
-var A = class extends SWR {
+var O2 = class extends H {
   /**
    * Svelte specific use of SWR.
    */
   useSWR(e, n) {
     let r;
-    const c = m(void 0, () => () => r == null ? void 0 : r()), l = m(void 0, () => () => r == null ? void 0 : r());
-    _(() => {
-      const o = (a) => {
-        l.set(void 0), c.set(a);
-      }, b = (a) => l.set(a);
-      r || (r = this.subscribe(e, o, b, __spreadValues({
+    const i = y(void 0, () => () => r == null ? void 0 : r()), a = y(void 0, () => () => r == null ? void 0 : r());
+    w(() => {
+      const o = (g) => {
+        a.set(void 0), i.set(g);
+      }, l = (g) => a.set(g);
+      r || (r = this.subscribe(e, o, l, __spreadValues({
         loadInitialCache: true
       }, n)).unsubscribe);
-    }), D(() => r == null ? void 0 : r());
-    const d = (o, b) => this.mutate(this.resolveKey(e), o, __spreadValues({
+    }), E2(() => r == null ? void 0 : r());
+    const d = (o, l) => this.mutate(this.resolveKey(e), o, __spreadValues({
       revalidateOptions: n
-    }, b)), i = (o) => this.revalidate(this.resolveKey(e), __spreadValues(__spreadValues({}, n), o)), f = (o) => this.clear(this.resolveKey(e), o), s = S([c, l], ([o, b]) => o === void 0 && b === void 0), p = S([c, l], ([o, b]) => o !== void 0 && b === void 0);
-    return { data: c, error: l, mutate: d, revalidate: i, clear: f, isLoading: s, isValid: p };
+    }, l)), u = (o) => this.revalidate(this.resolveKey(e), __spreadValues(__spreadValues({}, n), o)), f = (o) => this.clear(this.resolveKey(e), o), s = S2([i, a], ([o, l]) => o === void 0 && l === void 0), h2 = S2([i, a], ([o, l]) => o !== void 0 && l === void 0);
+    return { data: i, error: a, mutate: d, revalidate: u, clear: f, isLoading: s, isValid: h2 };
   }
 };
-var W = (t) => new A(t);
-var u = W();
-var $ = (t, e) => u.useSWR(t, e);
+var W = (t) => new O2(t);
+var c = W();
+var F2 = (t, e) => c.useSWR(t, e);
 
 // shared/utils.ts
 import { customAlphabet } from "nanoid/non-secure";
@@ -594,9 +648,9 @@ function useChat({
 } = {}) {
   const chatId = id || `chat-${uniqueId++}`;
   const key = `${api}|${chatId}`;
-  const { data, mutate: originalMutate } = $(key, {
+  const { data, mutate: originalMutate } = F2(key, {
     fetcher: () => store[key] || initialMessages,
-    initialData: initialMessages
+    fallbackData: initialMessages
   });
   data.set(initialMessages);
   const mutate = (data2) => {
@@ -744,9 +798,9 @@ function useCompletion({
 } = {}) {
   const completionId = id || `completion-${uniqueId2++}`;
   const key = `${api}|${completionId}`;
-  const { data, mutate: originalMutate } = $(key, {
+  const { data, mutate: originalMutate } = F2(key, {
     fetcher: () => store2[key] || initialCompletion,
-    initialData: initialCompletion
+    fallbackData: initialCompletion
   });
   data.set(initialCompletion);
   const mutate = (data2) => {