keyv 6.0.0-alpha.3 → 6.0.0-beta.1

package/dist/index.js

@@ -1,1087 +0,0 @@
-// src/event-manager.ts
-var EventManager = class {
-  _eventListeners;
-  _maxListeners;
-  constructor() {
-    this._eventListeners = /* @__PURE__ */ new Map();
-    this._maxListeners = 100;
-  }
-  maxListeners() {
-    return this._maxListeners;
-  }
-  // Add an event listener
-  addListener(event, listener) {
-    this.on(event, listener);
-  }
-  on(event, listener) {
-    if (!this._eventListeners.has(event)) {
-      this._eventListeners.set(event, []);
-    }
-    const listeners = this._eventListeners.get(event);
-    if (listeners) {
-      if (listeners.length >= this._maxListeners) {
-        console.warn(
-          `MaxListenersExceededWarning: Possible event memory leak detected. ${listeners.length + 1} ${event} listeners added. Use setMaxListeners() to increase limit.`
-        );
-      }
-      listeners.push(listener);
-    }
-    return this;
-  }
-  // Remove an event listener
-  removeListener(event, listener) {
-    this.off(event, listener);
-  }
-  off(event, listener) {
-    const listeners = this._eventListeners.get(event) ?? [];
-    const index = listeners.indexOf(listener);
-    if (index !== -1) {
-      listeners.splice(index, 1);
-    }
-    if (listeners.length === 0) {
-      this._eventListeners.delete(event);
-    }
-  }
-  once(event, listener) {
-    const onceListener = (...arguments_) => {
-      listener(...arguments_);
-      this.off(event, onceListener);
-    };
-    this.on(event, onceListener);
-  }
-  // Emit an event
-  // biome-ignore lint/suspicious/noExplicitAny: type format
-  emit(event, ...arguments_) {
-    const listeners = this._eventListeners.get(event);
-    if (listeners && listeners.length > 0) {
-      for (const listener of listeners) {
-        listener(...arguments_);
-      }
-    }
-  }
-  // Get all listeners for a specific event
-  listeners(event) {
-    return this._eventListeners.get(event) ?? [];
-  }
-  // Remove all listeners for a specific event
-  removeAllListeners(event) {
-    if (event) {
-      this._eventListeners.delete(event);
-    } else {
-      this._eventListeners.clear();
-    }
-  }
-  // Set the maximum number of listeners for a single event
-  setMaxListeners(n) {
-    this._maxListeners = n;
-  }
-};
-var event_manager_default = EventManager;
-
-// src/hooks-manager.ts
-var HooksManager = class extends event_manager_default {
-  _hookHandlers;
-  constructor() {
-    super();
-    this._hookHandlers = /* @__PURE__ */ new Map();
-  }
-  // Adds a handler function for a specific event
-  addHandler(event, handler) {
-    const eventHandlers = this._hookHandlers.get(event);
-    if (eventHandlers) {
-      eventHandlers.push(handler);
-    } else {
-      this._hookHandlers.set(event, [handler]);
-    }
-  }
-  // Removes a specific handler function for a specific event
-  removeHandler(event, handler) {
-    const eventHandlers = this._hookHandlers.get(event);
-    if (eventHandlers) {
-      const index = eventHandlers.indexOf(handler);
-      if (index !== -1) {
-        eventHandlers.splice(index, 1);
-      }
-    }
-  }
-  // Triggers all handlers for a specific event with provided data
-  // biome-ignore lint/suspicious/noExplicitAny: type format
-  trigger(event, data) {
-    const eventHandlers = this._hookHandlers.get(event);
-    if (eventHandlers) {
-      for (const handler of eventHandlers) {
-        try {
-          handler(data);
-        } catch (error) {
-          this.emit(
-            "error",
-            new Error(
-              `Error in hook handler for event "${event}": ${error.message}`
-            )
-          );
-        }
-      }
-    }
-  }
-  // Provides read-only access to the current handlers
-  get handlers() {
-    return new Map(this._hookHandlers);
-  }
-};
-var hooks_manager_default = HooksManager;
-
-// src/json-serializer.ts
-function getGlobalBuffer() {
-  return globalThis.Buffer;
-}
-function bytesToBase64(bytes) {
-  const buffer = getGlobalBuffer();
-  if (buffer) {
-    return buffer.from(bytes).toString("base64");
-  }
-  let binary = "";
-  for (const byte of bytes) {
-    binary += String.fromCharCode(byte);
-  }
-  return btoa(binary);
-}
-function base64ToBytes(value) {
-  const buffer = getGlobalBuffer();
-  if (buffer) {
-    return buffer.from(value, "base64");
-  }
-  const binary = atob(value);
-  const bytes = new Uint8Array(binary.length);
-  for (let index = 0; index < binary.length; index++) {
-    bytes[index] = binary.charCodeAt(index);
-  }
-  return bytes;
-}
-function isBinaryValue(value) {
-  const buffer = getGlobalBuffer();
-  if (buffer?.isBuffer(value)) {
-    return true;
-  }
-  return value instanceof Uint8Array;
-}
-function prepare(value) {
-  if (value === null || value === void 0) {
-    return value;
-  }
-  if (isBinaryValue(value)) {
-    return `:base64:${bytesToBase64(value)}`;
-  }
-  if (typeof value === "bigint") {
-    return `:bigint:${value.toString()}`;
-  }
-  if (typeof value === "string") {
-    return value.startsWith(":") ? `:${value}` : value;
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => prepare(item));
-  }
-  if (typeof value === "object") {
-    if (typeof value.toJSON === "function") {
-      return prepare(value.toJSON());
-    }
-    const result = {};
-    for (const key of Object.keys(value)) {
-      if (value[key] !== void 0) {
-        result[key] = prepare(value[key]);
-      }
-    }
-    return result;
-  }
-  return value;
-}
-var KeyvJsonSerializer = class {
-  stringify(object) {
-    return JSON.stringify(prepare(object));
-  }
-  parse(data) {
-    return JSON.parse(data, (_, value) => {
-      if (typeof value === "string") {
-        if (value.startsWith(":bigint:")) {
-          return BigInt(value.slice(8));
-        }
-        if (value.startsWith(":base64:")) {
-          return base64ToBytes(value.slice(8));
-        }
-        return value.startsWith(":") ? value.slice(1) : value;
-      }
-      return value;
-    });
-  }
-};
-var jsonSerializer = new KeyvJsonSerializer();
-
-// src/stats-manager.ts
-var StatsManager = class extends event_manager_default {
-  enabled = true;
-  hits = 0;
-  misses = 0;
-  sets = 0;
-  deletes = 0;
-  errors = 0;
-  constructor(enabled) {
-    super();
-    if (enabled !== void 0) {
-      this.enabled = enabled;
-    }
-    this.reset();
-  }
-  hit() {
-    if (this.enabled) {
-      this.hits++;
-    }
-  }
-  miss() {
-    if (this.enabled) {
-      this.misses++;
-    }
-  }
-  set() {
-    if (this.enabled) {
-      this.sets++;
-    }
-  }
-  delete() {
-    if (this.enabled) {
-      this.deletes++;
-    }
-  }
-  hitsOrMisses(array) {
-    for (const item of array) {
-      if (item === void 0) {
-        this.miss();
-      } else {
-        this.hit();
-      }
-    }
-  }
-  reset() {
-    this.hits = 0;
-    this.misses = 0;
-    this.sets = 0;
-    this.deletes = 0;
-    this.errors = 0;
-  }
-};
-var stats_manager_default = StatsManager;
-
-// src/types.ts
-var KeyvHooks = /* @__PURE__ */ ((KeyvHooks2) => {
-  KeyvHooks2["PRE_SET"] = "preSet";
-  KeyvHooks2["POST_SET"] = "postSet";
-  KeyvHooks2["PRE_GET"] = "preGet";
-  KeyvHooks2["POST_GET"] = "postGet";
-  KeyvHooks2["PRE_GET_MANY"] = "preGetMany";
-  KeyvHooks2["POST_GET_MANY"] = "postGetMany";
-  KeyvHooks2["PRE_GET_RAW"] = "preGetRaw";
-  KeyvHooks2["POST_GET_RAW"] = "postGetRaw";
-  KeyvHooks2["PRE_GET_MANY_RAW"] = "preGetManyRaw";
-  KeyvHooks2["POST_GET_MANY_RAW"] = "postGetManyRaw";
-  KeyvHooks2["PRE_SET_RAW"] = "preSetRaw";
-  KeyvHooks2["POST_SET_RAW"] = "postSetRaw";
-  KeyvHooks2["PRE_SET_MANY_RAW"] = "preSetManyRaw";
-  KeyvHooks2["POST_SET_MANY_RAW"] = "postSetManyRaw";
-  KeyvHooks2["PRE_DELETE"] = "preDelete";
-  KeyvHooks2["POST_DELETE"] = "postDelete";
-  return KeyvHooks2;
-})(KeyvHooks || {});
-
-// src/index.ts
-var iterableAdapters = [
-  "sqlite",
-  "postgres",
-  "mysql",
-  "mongo",
-  "redis",
-  "valkey",
-  "etcd"
-];
-var Keyv = class extends event_manager_default {
-  iterator;
-  hooks = new hooks_manager_default();
-  stats = new stats_manager_default(false);
-  /**
-   * Time to live in milliseconds
-   */
-  _ttl;
-  /**
-   * Namespace
-   */
-  _namespace;
-  /**
-   * Store
-   */
-  // biome-ignore lint/suspicious/noExplicitAny: type format
-  _store = /* @__PURE__ */ new Map();
-  _serialization;
-  _compression;
-  _throwOnErrors = false;
-  _emitErrors = true;
-  /**
-   * Keyv Constructor
-   * @param {KeyvStorageAdapter | KeyvOptions} store
-   * @param {Omit<KeyvOptions, 'store'>} [options] if you provide the store you can then provide the Keyv Options
-   */
-  constructor(store, options) {
-    super();
-    options ??= {};
-    store ??= {};
-    const mergedOptions = {
-      namespace: "keyv",
-      emitErrors: true,
-      ...options
-    };
-    if (store && store.get) {
-      mergedOptions.store = store;
-    } else {
-      Object.assign(mergedOptions, store);
-    }
-    this._store = mergedOptions.store ?? /* @__PURE__ */ new Map();
-    this._compression = mergedOptions.compression;
-    if (mergedOptions.serialization === false) {
-      this._serialization = void 0;
-    } else {
-      this._serialization = mergedOptions.serialization ?? new KeyvJsonSerializer();
-    }
-    if (mergedOptions.namespace) {
-      this._namespace = mergedOptions.namespace;
-    }
-    if (this._store) {
-      if (!this._isValidStorageAdapter(this._store)) {
-        throw new Error("Invalid storage adapter");
-      }
-      if (typeof this._store.on === "function") {
-        this._store.on("error", (error) => this.emit("error", error));
-      }
-      this._store.namespace = this._namespace;
-      if (
-        // biome-ignore lint/suspicious/noExplicitAny: need to check Map iterator
-        typeof this._store[Symbol.iterator] === "function" && this._store instanceof Map
-      ) {
-        this.iterator = this.generateIterator(
-          this._store
-        );
-      } else if ("iterator" in this._store && this._store.opts && this._checkIterableAdapter()) {
-        this.iterator = this.generateIterator(
-          // biome-ignore lint/style/noNonNullAssertion: need to fix
-          this._store.iterator.bind(this._store)
-        );
-      }
-    }
-    if (mergedOptions.stats) {
-      this.stats.enabled = mergedOptions.stats;
-    }
-    if (mergedOptions.ttl) {
-      this._ttl = mergedOptions.ttl;
-    }
-    if (mergedOptions.emitErrors !== void 0) {
-      this._emitErrors = mergedOptions.emitErrors;
-    }
-    if (mergedOptions.throwOnErrors !== void 0) {
-      this._throwOnErrors = mergedOptions.throwOnErrors;
-    }
-  }
-  /**
-   * Get the current store
-   */
-  // biome-ignore lint/suspicious/noExplicitAny: type format
-  get store() {
-    return this._store;
-  }
-  /**
-   * Set the current store. This will also set the namespace, event error handler, and generate the iterator. If the store is not valid it will throw an error.
-   * @param {KeyvStorageAdapter | Map<any, any> | any} store the store to set
-   */
-  // biome-ignore lint/suspicious/noExplicitAny: type format
-  set store(store) {
-    if (this._isValidStorageAdapter(store)) {
-      this._store = store;
-      if (typeof store.on === "function") {
-        store.on("error", (error) => this.emit("error", error));
-      }
-      if (this._namespace) {
-        this._store.namespace = this._namespace;
-      }
-      if (typeof store[Symbol.iterator] === "function" && store instanceof Map) {
-        this.iterator = this.generateIterator(
-          store
-        );
-      } else if ("iterator" in store && store.opts && this._checkIterableAdapter()) {
-        this.iterator = this.generateIterator(store.iterator?.bind(store));
-      }
-    } else {
-      throw new Error("Invalid storage adapter");
-    }
-  }
-  /**
-   * Get the current compression function
-   * @returns {KeyvCompressionAdapter} The current compression function
-   */
-  get compression() {
-    return this._compression;
-  }
-  /**
-   * Set the current compression function
-   * @param {KeyvCompressionAdapter} compress The compression function to set
-   */
-  set compression(compress) {
-    this._compression = compress;
-  }
-  /**
-   * Get the current namespace.
-   * @returns {string | undefined} The current namespace.
-   */
-  get namespace() {
-    return this._namespace;
-  }
-  /**
-   * Set the current namespace.
-   * @param {string | undefined} namespace The namespace to set.
-   */
-  set namespace(namespace) {
-    this._namespace = namespace;
-    this._store.namespace = namespace;
-  }
-  /**
-   * Get the current TTL.
-   * @returns {number} The current TTL in milliseconds.
-   */
-  get ttl() {
-    return this._ttl;
-  }
-  /**
-   * Set the current TTL.
-   * @param {number} ttl The TTL to set in milliseconds.
-   */
-  set ttl(ttl) {
-    this._ttl = ttl;
-  }
-  /**
-   * Get the current serialization adapter.
-   * @returns {KeyvSerializationAdapter | undefined} The current serialization adapter.
-   */
-  get serialization() {
-    return this._serialization;
-  }
-  /**
-   * Set the current serialization adapter.
-   * @param {KeyvSerializationAdapter | undefined} serialization The serialization adapter to set.
-   */
-  set serialization(serialization) {
-    this._serialization = serialization === false ? void 0 : serialization;
-  }
-  /**
-   * Get the current throwErrors value. This will enable or disable throwing errors on methods in addition to emitting them.
-   * @return {boolean} The current throwOnErrors value.
-   */
-  get throwOnErrors() {
-    return this._throwOnErrors;
-  }
-  /**
-   * Set the current throwOnErrors value. This will enable or disable throwing errors on methods in addition to emitting them.
-   * @param {boolean} value The throwOnErrors value to set.
-   */
-  set throwOnErrors(value) {
-    this._throwOnErrors = value;
-  }
-  /**
-   * Get the current emitErrors value. This will enable or disable emitting errors on methods.
-   * @return {boolean} The current emitErrors value.
-   * @default true
-   */
-  get emitErrors() {
-    return this._emitErrors;
-  }
-  /**
-   * Set the current emitErrors value. This will enable or disable emitting errors on methods.
-   * @param {boolean} value The emitErrors value to set.
-   */
-  set emitErrors(value) {
-    this._emitErrors = value;
-  }
-  generateIterator(iterator) {
-    const function_ = async function* () {
-      for await (const [key, raw] of typeof iterator === "function" ? iterator(this._store.namespace) : iterator) {
-        const data = await this.deserializeData(raw);
-        if (typeof data.expires === "number" && Date.now() > data.expires) {
-          await this.delete(key);
-          continue;
-        }
-        yield [key, data.value];
-      }
-    };
-    return function_.bind(this);
-  }
-  _checkIterableAdapter() {
-    return iterableAdapters.includes(this._store.opts.dialect) || iterableAdapters.some(
-      (element) => this._store.opts.url.includes(element)
-    );
-  }
-  // biome-ignore lint/suspicious/noExplicitAny: type format
-  _isValidStorageAdapter(store) {
-    return store instanceof Map || typeof store.get === "function" && typeof store.set === "function" && typeof store.delete === "function" && typeof store.clear === "function";
-  }
-  // eslint-disable-next-line @stylistic/max-len
-  async get(key, options) {
-    const store = this._store;
-    const isArray = Array.isArray(key);
-    const isDataExpired = (data) => typeof data.expires === "number" && Date.now() > data.expires;
-    if (isArray) {
-      if (options?.raw === true) {
-        return this.getMany(key, { raw: true });
-      }
-      return this.getMany(key, { raw: false });
-    }
-    this.hooks.trigger("preGet" /* PRE_GET */, { key });
-    let rawData;
-    try {
-      rawData = await store.get(key);
-    } catch (error) {
-      if (this.throwOnErrors) {
-        throw error;
-      }
-    }
-    const deserializedData = typeof rawData === "string" || this._compression ? await this.deserializeData(rawData) : rawData;
-    if (deserializedData === void 0 || deserializedData === null) {
-      this.hooks.trigger("postGet" /* POST_GET */, {
-        key,
-        value: void 0
-      });
-      this.stats.miss();
-      return void 0;
-    }
-    if (isDataExpired(deserializedData)) {
-      await this.delete(key);
-      this.hooks.trigger("postGet" /* POST_GET */, {
-        key,
-        value: void 0
-      });
-      this.stats.miss();
-      return void 0;
-    }
-    this.hooks.trigger("postGet" /* POST_GET */, {
-      key,
-      value: deserializedData
-    });
-    this.stats.hit();
-    return options?.raw ? deserializedData : deserializedData.value;
-  }
-  async getMany(keys, options) {
-    const store = this._store;
-    const isDataExpired = (data) => typeof data.expires === "number" && Date.now() > data.expires;
-    this.hooks.trigger("preGetMany" /* PRE_GET_MANY */, { keys });
-    if (store.getMany === void 0) {
-      const promises = keys.map(async (key) => {
-        const rawData2 = await store.get(key);
-        const deserializedRow = typeof rawData2 === "string" || this._compression ? await this.deserializeData(rawData2) : rawData2;
-        if (deserializedRow === void 0 || deserializedRow === null) {
-          return void 0;
-        }
-        if (isDataExpired(deserializedRow)) {
-          await this.delete(key);
-          return void 0;
-        }
-        return options?.raw ? deserializedRow : deserializedRow.value;
-      });
-      const deserializedRows = await Promise.allSettled(promises);
-      const result2 = deserializedRows.map(
-        // biome-ignore lint/suspicious/noExplicitAny: type format
-        (row) => row.value
-      );
-      this.hooks.trigger("postGetMany" /* POST_GET_MANY */, result2);
-      if (result2.length > 0) {
-        this.stats.hit();
-      }
-      return result2;
-    }
-    const rawData = await store.getMany(keys);
-    const result = [];
-    const expiredKeys = [];
-    for (const index in rawData) {
-      let row = rawData[index];
-      if (typeof row === "string") {
-        row = await this.deserializeData(row);
-      }
-      if (row === void 0 || row === null) {
-        result.push(void 0);
-        continue;
-      }
-      if (isDataExpired(row)) {
-        expiredKeys.push(keys[index]);
-        result.push(void 0);
-        continue;
-      }
-      const value = options?.raw ? row : row.value;
-      result.push(value);
-    }
-    if (expiredKeys.length > 0) {
-      await this.deleteMany(expiredKeys);
-    }
-    this.hooks.trigger("postGetMany" /* POST_GET_MANY */, result);
-    if (result.length > 0) {
-      this.stats.hit();
-    }
-    return result;
-  }
-  /**
-   * Get the raw value of a key. This is the replacement for setting raw to true in the get() method.
-   * @param {string} key the key to get
-   * @returns {Promise<StoredDataRaw<Value> | undefined>} will return a StoredDataRaw<Value> or undefined if the key does not exist or is expired.
-   */
-  async getRaw(key) {
-    const store = this._store;
-    this.hooks.trigger("preGetRaw" /* PRE_GET_RAW */, { key });
-    const rawData = await store.get(key);
-    if (rawData === void 0 || rawData === null) {
-      this.hooks.trigger("postGetRaw" /* POST_GET_RAW */, {
-        key,
-        value: void 0
-      });
-      this.stats.miss();
-      return void 0;
-    }
-    const deserializedData = typeof rawData === "string" || this._compression ? await this.deserializeData(rawData) : rawData;
-    if (deserializedData !== void 0 && deserializedData.expires !== void 0 && deserializedData.expires !== null && // biome-ignore lint/style/noNonNullAssertion: need to fix
-    deserializedData.expires < Date.now()) {
-      this.hooks.trigger("postGetRaw" /* POST_GET_RAW */, {
-        key,
-        value: void 0
-      });
-      this.stats.miss();
-      await this.delete(key);
-      return void 0;
-    }
-    this.stats.hit();
-    this.hooks.trigger("postGetRaw" /* POST_GET_RAW */, {
-      key,
-      value: deserializedData
-    });
-    return deserializedData;
-  }
-  /**
-   * Get the raw values of many keys. This is the replacement for setting raw to true in the getMany() method.
-   * @param {string[]} keys the keys to get
-   * @returns {Promise<Array<StoredDataRaw<Value>>>} will return an array of StoredDataRaw<Value> or undefined if the key does not exist or is expired.
-   */
-  async getManyRaw(keys) {
-    const store = this._store;
-    if (keys.length === 0) {
-      const result2 = Array.from({ length: keys.length }).fill(
-        void 0
-      );
-      this.stats.misses += keys.length;
-      this.hooks.trigger("postGetManyRaw" /* POST_GET_MANY_RAW */, {
-        keys,
-        values: result2
-      });
-      return result2;
-    }
-    let result = [];
-    if (store.getMany === void 0) {
-      const promises = keys.map(async (key) => {
-        const rawData = await store.get(key);
-        if (rawData !== void 0 && rawData !== null) {
-          return this.deserializeData(rawData);
-        }
-        return void 0;
-      });
-      const deserializedRows = await Promise.allSettled(promises);
-      result = deserializedRows.map(
-        (row) => (
-          // biome-ignore lint/suspicious/noExplicitAny: type format
-          row.value
-        )
-      );
-    } else {
-      const rawData = await store.getMany(keys);
-      for (const row of rawData) {
-        if (row !== void 0 && row !== null) {
-          result.push(await this.deserializeData(row));
-        } else {
-          result.push(void 0);
-        }
-      }
-    }
-    const expiredKeys = [];
-    const isDataExpired = (data) => typeof data.expires === "number" && Date.now() > data.expires;
-    for (const [index, row] of result.entries()) {
-      if (row !== void 0 && isDataExpired(row)) {
-        expiredKeys.push(keys[index]);
-        result[index] = void 0;
-      }
-    }
-    if (expiredKeys.length > 0) {
-      await this.deleteMany(expiredKeys);
-    }
-    this.stats.hitsOrMisses(result);
-    this.hooks.trigger("postGetManyRaw" /* POST_GET_MANY_RAW */, {
-      keys,
-      values: result
-    });
-    return result;
-  }
-  /**
-   * Set an item to the store
-   * @param {string | Array<KeyvEntry>} key the key to use. If you pass in an array of KeyvEntry it will set many items
-   * @param {Value} value the value of the key
-   * @param {number} [ttl] time to live in milliseconds
-   * @returns {boolean} if it sets then it will return a true. On failure will return false.
-   */
-  async set(key, value, ttl) {
-    const data = { key, value, ttl };
-    this.hooks.trigger("preSet" /* PRE_SET */, data);
-    data.ttl ??= this._ttl;
-    if (data.ttl === 0) {
-      data.ttl = void 0;
-    }
-    const store = this._store;
-    const expires = typeof data.ttl === "number" ? Date.now() + data.ttl : void 0;
-    if (typeof data.value === "symbol") {
-      this.emit("error", "symbol cannot be serialized");
-      throw new Error("symbol cannot be serialized");
-    }
-    const formattedValue = { value: data.value, expires };
-    const serializedValue = await this.serializeData(formattedValue);
-    let result = true;
-    try {
-      const value2 = await store.set(data.key, serializedValue, data.ttl);
-      if (typeof value2 === "boolean") {
-        result = value2;
-      }
-    } catch (error) {
-      result = false;
-      this.emit("error", error);
-      if (this._throwOnErrors) {
-        throw error;
-      }
-    }
-    this.hooks.trigger("postSet" /* POST_SET */, {
-      key,
-      value: serializedValue,
-      ttl
-    });
-    this.stats.set();
-    return result;
-  }
-  /**
-   * Set a raw value to the store without wrapping or serialization. This is the write-side counterpart to getRaw().
-   * The value should be a DeserializedData object with { value, expires? }.
-   * @param {string} key the key to set
-   * @param {DeserializedData<Value>} value the raw value envelope to store
-   * @param {number} [ttl] time to live in milliseconds. If the raw value does not already have an expires field, it will be computed from ttl.
-   * @returns {boolean} if it sets then it will return a true. On failure will return false.
-   */
-  async setRaw(key, value, ttl) {
-    const data = { key, value, ttl };
-    this.hooks.trigger("preSetRaw" /* PRE_SET_RAW */, data);
-    data.ttl ??= this._ttl;
-    if (data.ttl === 0) {
-      data.ttl = void 0;
-    }
-    if (data.value.expires === void 0 && typeof data.ttl === "number") {
-      data.value.expires = Date.now() + data.ttl;
-    }
-    const store = this._store;
-    let result = true;
-    try {
-      const serializedValue = await this.serializeData(data.value);
-      const storeResult = await store.set(data.key, serializedValue, data.ttl);
-      if (typeof storeResult === "boolean") {
-        result = storeResult;
-      }
-    } catch (error) {
-      result = false;
-      this.emit("error", error);
-      if (this._throwOnErrors) {
-        throw error;
-      }
-    }
-    this.hooks.trigger("postSetRaw" /* POST_SET_RAW */, {
-      key,
-      value: data.value,
-      ttl: data.ttl
-    });
-    this.stats.set();
-    return result;
-  }
-  /**
-   * Set many items to the store
-   * @param {Array<KeyvEntry>} entries the entries to set
-   * @returns {boolean[]} will return an array of booleans if it sets then it will return a true. On failure will return false.
-   */
-  // biome-ignore lint/correctness/noUnusedVariables: type format
-  async setMany(entries) {
-    let results = [];
-    try {
-      if (this._store.setMany === void 0) {
-        const promises = [];
-        for (const entry of entries) {
-          promises.push(this.set(entry.key, entry.value, entry.ttl));
-        }
-        const promiseResults = await Promise.all(promises);
-        results = promiseResults;
-      } else {
-        const serializedEntries = await Promise.all(
-          entries.map(async ({ key, value, ttl }) => {
-            ttl ??= this._ttl;
-            if (ttl === 0) {
-              ttl = void 0;
-            }
-            const expires = typeof ttl === "number" ? Date.now() + ttl : void 0;
-            if (typeof value === "symbol") {
-              this.emit("error", "symbol cannot be serialized");
-              throw new Error("symbol cannot be serialized");
-            }
-            const formattedValue = { value, expires };
-            const serializedValue = await this.serializeData(formattedValue);
-            return { key, value: serializedValue, ttl };
-          })
-        );
-        const storeResult = await this._store.setMany(serializedEntries);
-        results = Array.isArray(storeResult) ? storeResult : entries.map(() => true);
-      }
-    } catch (error) {
-      this.emit("error", error);
-      if (this._throwOnErrors) {
-        throw error;
-      }
-      results = entries.map(() => false);
-    }
-    return results;
-  }
-  /**
-   * Set many raw values to the store without wrapping or serialization. This is the write-side counterpart to getManyRaw().
-   * Each entry's value should be a DeserializedData object with { value, expires? }.
-   * @param {Array<{key: string, value: DeserializedData<Value>, ttl?: number}>} entries the raw entries to set
-   * @returns {boolean[]} will return an array of booleans if it sets then it will return a true. On failure will return false.
-   */
-  async setManyRaw(entries) {
-    let results = [];
-    this.hooks.trigger("preSetManyRaw" /* PRE_SET_MANY_RAW */, { entries });
-    try {
-      if (this._store.setMany === void 0) {
-        const promises = [];
-        for (const entry of entries) {
-          promises.push(this.setRaw(entry.key, entry.value, entry.ttl));
-        }
-        results = await Promise.all(promises);
-      } else {
-        const rawEntries = await Promise.all(
-          entries.map(async ({ key, value, ttl }) => {
-            ttl ??= this._ttl;
-            if (ttl === 0) {
-              ttl = void 0;
-            }
-            if (value.expires === void 0 && typeof ttl === "number") {
-              value.expires = Date.now() + ttl;
-            }
-            const serializedValue = await this.serializeData(value);
-            return { key, value: serializedValue, ttl };
-          })
-        );
-        const storeResult = await this._store.setMany(rawEntries);
-        results = Array.isArray(storeResult) ? storeResult : entries.map(() => true);
-      }
-    } catch (error) {
-      this.emit("error", error);
-      if (this._throwOnErrors) {
-        throw error;
-      }
-      results = entries.map(() => false);
-    }
-    this.hooks.trigger("postSetManyRaw" /* POST_SET_MANY_RAW */, { entries, results });
-    return results;
-  }
-  /**
-   * Delete an Entry
-   * @param {string | string[]} key the key to be deleted. if an array it will delete many items
-   * @returns {boolean} will return true if item or items are deleted. false if there is an error
-   */
-  async delete(key) {
-    const store = this._store;
-    if (Array.isArray(key)) {
-      return this.deleteMany(key);
-    }
-    this.hooks.trigger("preDelete" /* PRE_DELETE */, { key });
-    let result = true;
-    try {
-      const value = await store.delete(key);
-      if (typeof value === "boolean") {
-        result = value;
-      }
-    } catch (error) {
-      result = false;
-      this.emit("error", error);
-      if (this._throwOnErrors) {
-        throw error;
-      }
-    }
-    this.hooks.trigger("postDelete" /* POST_DELETE */, {
-      key,
-      value: result
-    });
-    this.stats.delete();
-    return result;
-  }
-  /**
-   * Delete many items from the store
-   * @param {string[]} keys the keys to be deleted
-   * @returns {boolean} will return true if item or items are deleted. false if there is an error
-   */
-  async deleteMany(keys) {
-    try {
-      const store = this._store;
-      this.hooks.trigger("preDelete" /* PRE_DELETE */, { key: keys });
-      if (store.deleteMany !== void 0) {
-        return await store.deleteMany(keys);
-      }
-      const promises = keys.map(async (key) => store.delete(key));
-      const results = await Promise.all(promises);
-      const returnResult = results.every(Boolean);
-      this.hooks.trigger("postDelete" /* POST_DELETE */, {
-        key: keys,
-        value: returnResult
-      });
-      return returnResult;
-    } catch (error) {
-      this.emit("error", error);
-      if (this._throwOnErrors) {
-        throw error;
-      }
-      return false;
-    }
-  }
-  /**
-   * Clear the store
-   * @returns {void}
-   */
-  async clear() {
-    this.emit("clear");
-    const store = this._store;
-    try {
-      await store.clear();
-    } catch (error) {
-      this.emit("error", error);
-      if (this._throwOnErrors) {
-        throw error;
-      }
-    }
-  }
-  async has(key) {
-    if (Array.isArray(key)) {
-      return this.hasMany(key);
-    }
-    const store = this._store;
-    if (store.has !== void 0 && !(store instanceof Map)) {
-      return store.has(key);
-    }
-    let rawData;
-    try {
-      rawData = await store.get(key);
-    } catch (error) {
-      this.emit("error", error);
-      if (this._throwOnErrors) {
-        throw error;
-      }
-      return false;
-    }
-    if (rawData) {
-      const data = await this.deserializeData(rawData);
-      if (data) {
-        if (data.expires === void 0 || data.expires === null) {
-          return true;
-        }
-        return data.expires > Date.now();
-      }
-    }
-    return false;
-  }
-  /**
-   * Check if many keys exist
-   * @param {string[]} keys the keys to check
-   * @returns {boolean[]} will return an array of booleans if the keys exist
-   */
-  async hasMany(keys) {
-    const store = this._store;
-    if (store.hasMany !== void 0) {
-      return store.hasMany(keys);
-    }
-    const results = [];
-    for (const key of keys) {
-      results.push(await this.has(key));
-    }
-    return results;
-  }
-  /**
-   * Will disconnect the store. This is only available if the store has a disconnect method
-   * @returns {Promise<void>}
-   */
-  async disconnect() {
-    const store = this._store;
-    this.emit("disconnect");
-    if (typeof store.disconnect === "function") {
-      return store.disconnect();
-    }
-  }
-  // biome-ignore lint/suspicious/noExplicitAny: type format
-  emit(event, ...arguments_) {
-    if (event === "error" && !this._emitErrors) {
-      return;
-    }
-    super.emit(event, ...arguments_);
-  }
-  async serializeData(data) {
-    if (!this._serialization && !this._compression) {
-      return data;
-    }
-    let result = data;
-    if (this._serialization) {
-      result = await this._serialization.stringify(data);
-    } else if (this._compression) {
-      result = JSON.stringify(data);
-    }
-    if (this._compression?.compress) {
-      result = await this._compression.compress(result);
-    }
-    return result;
-  }
-  async deserializeData(data) {
-    if (data === void 0 || data === null) {
-      return void 0;
-    }
-    if (!this._serialization && !this._compression) {
-      if (typeof data === "string") {
-        return void 0;
-      }
-      return data;
-    }
-    let result = data;
-    if (this._compression?.decompress) {
-      result = await this._compression.decompress(result);
-    }
-    if (this._serialization && typeof result === "string") {
-      return await this._serialization.parse(result);
-    }
-    if (typeof result === "string") {
-      try {
-        return JSON.parse(result);
-      } catch {
-        return void 0;
-      }
-    }
-    return result;
-  }
-};
-var index_default = Keyv;
-export {
-  Keyv,
-  KeyvHooks,
-  KeyvJsonSerializer,
-  index_default as default,
-  jsonSerializer
-};
-/* v8 ignore next -- @preserve */