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

package/dist/index.cjs

@@ -1,1117 +1,2286 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  Keyv: () => Keyv,
-  KeyvHooks: () => KeyvHooks,
-  KeyvJsonSerializer: () => KeyvJsonSerializer,
-  default: () => index_default,
-  jsonSerializer: () => jsonSerializer
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
 });
-module.exports = __toCommonJS(index_exports);
-
-// 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;
-  }
+let hookified = require("hookified");
+//#region src/capabilities.ts
+const keyvMethodNames = [
+	"get",
+	"set",
+	"delete",
+	"clear",
+	"has",
+	"getMany",
+	"setMany",
+	"deleteMany",
+	"hasMany",
+	"disconnect",
+	"getRaw",
+	"getManyRaw",
+	"setRaw",
+	"setManyRaw",
+	"iterator"
+];
+const keyvPropertyNames = ["hooks", "stats"];
+const keyvStorageMethodNames = [
+	"get",
+	"getMany",
+	"has",
+	"hasMany",
+	"set",
+	"setMany",
+	"delete",
+	"deleteMany",
+	"clear",
+	"disconnect",
+	"iterator"
+];
+const keyvCompressionMethodNames = ["compress", "decompress"];
+const keyvSerializationMethodNames = ["stringify", "parse"];
+const keyvEncryptionMethodNames = ["encrypt", "decrypt"];
+function isMethod(obj, name) {
+	return name in obj && typeof obj[name] === "function";
+}
+function isProperty(obj, name) {
+	return name in obj;
+}
+function resolveMethodType(obj, name) {
+	if (!(name in obj)) return "none";
+	const value = obj[name];
+	if (typeof value !== "function") return "none";
+	return value.constructor.name === "AsyncFunction" ? "async" : "sync";
+}
+function resolveMethod(obj, name) {
+	return {
+		exists: isMethod(obj, name),
+		methodType: resolveMethodType(obj, name)
+	};
+}
+const noneMethod = {
+	exists: false,
+	methodType: "none"
 };
-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);
-  }
+function buildMethods(obj, names) {
+	const methods = {};
+	for (const name of names) methods[name] = obj ? resolveMethod(obj, name) : { ...noneMethod };
+	return methods;
+}
+/**
+* Detect whether an object implements the full Keyv interface
+* @param obj - The object to check
+* @returns A {@link KeyvCapability} where `compatible` is `true` only when all required capabilities are present
+* @example
+* ```typescript
+* import Keyv, { detectKeyv } from 'keyv';
+*
+* const result = detectKeyv(new Keyv());
+* result.compatible;              // true — all capabilities present
+* result.methods.get.exists;      // true
+* result.methods.get.methodType;  // "async"
+*
+* const partial = detectKeyv(new Map());
+* partial.compatible;             // false — missing getMany, setMany, hooks, stats, etc.
+* partial.methods.get.exists;     // true
+* ```
+*/
+function detectKeyv(obj) {
+	if (obj === null || obj === void 0 || typeof obj !== "object") return {
+		compatible: false,
+		methods: buildMethods(null, keyvMethodNames),
+		properties: {
+			hooks: false,
+			stats: false
+		}
+	};
+	const methods = buildMethods(obj, keyvMethodNames);
+	const properties = {
+		hooks: isProperty(obj, "hooks"),
+		stats: isProperty(obj, "stats")
+	};
+	return {
+		compatible: [...keyvMethodNames, ...keyvPropertyNames].every((k) => {
+			if (k === "hooks" || k === "stats") return properties[k];
+			return methods[k].exists;
+		}),
+		methods,
+		properties
+	};
+}
+/**
+* Detect whether an object implements the Keyv storage adapter interface
+* @param obj - The object to check
+* @returns A {@link KeyvStorageCapability} where:
+* - `compatible` is `true` when the object is a valid storage adapter (`"keyvStorage"`, `"mapLike"`, or `"asyncMap"`)
+* - `store` indicates the detected store type: `"keyvStorage"`, `"mapLike"`, `"asyncMap"`, or `"none"`
+* - `methods` maps each method name to `{ exists, methodType }`
+* @example
+* ```typescript
+* import { detectKeyvStorage } from 'keyv';
+*
+* const map = detectKeyvStorage(new Map());
+* map.compatible;               // true
+* map.store;                    // "mapLike"
+* map.methods.get.exists;       // true
+* map.methods.get.methodType;   // "sync"
+*
+* const adapter = detectKeyvStorage(asyncAdapter);
+* adapter.compatible;               // true
+* adapter.store;                    // "keyvStorage"
+* adapter.methods.get.methodType;   // "async"
+* ```
+*/
+function detectKeyvStorage(obj) {
+	if (obj === null || obj === void 0 || typeof obj !== "object") return {
+		compatible: false,
+		store: "none",
+		methods: buildMethods(null, keyvStorageMethodNames)
+	};
+	const methods = buildMethods(obj, keyvStorageMethodNames);
+	if ([
+		"get",
+		"has",
+		"hasMany",
+		"set",
+		"setMany",
+		"delete",
+		"deleteMany",
+		"clear"
+	].every((k) => methods[k].exists && methods[k].methodType === "async")) return {
+		compatible: true,
+		store: "keyvStorage",
+		methods
+	};
+	if ([
+		"get",
+		"set",
+		"delete",
+		"has"
+	].every((m) => methods[m].exists && methods[m].methodType === "sync")) return {
+		compatible: true,
+		store: "mapLike",
+		methods
+	};
+	if ([
+		"get",
+		"set",
+		"delete",
+		"clear"
+	].every((m) => methods[m].exists)) return {
+		compatible: true,
+		store: "asyncMap",
+		methods
+	};
+	return {
+		compatible: false,
+		store: "none",
+		methods
+	};
+}
+/**
+* Detect whether an object implements the Keyv compression adapter interface
+* @param obj - The object to check
+* @returns A {@link KeyvCompressionCapability} where `compatible` is `true` when both `compress` and `decompress` methods are present
+* @example
+* ```typescript
+* import { detectKeyvCompression } from 'keyv';
+*
+* detectKeyvCompression({ compress: (d) => d, decompress: (d) => d });
+* // { compatible: true, methods: { compress: { exists: true, methodType: "sync" }, decompress: { exists: true, methodType: "sync" } } }
+* ```
+*/
+function detectKeyvCompression(obj) {
+	if (obj === null || obj === void 0 || typeof obj !== "object") return {
+		compatible: false,
+		methods: buildMethods(null, keyvCompressionMethodNames)
+	};
+	const methods = buildMethods(obj, keyvCompressionMethodNames);
+	return {
+		compatible: keyvCompressionMethodNames.every((k) => methods[k].exists),
+		methods
+	};
+}
+/**
+* Detect whether an object implements the Keyv serialization adapter interface
+* @param obj - The object to check
+* @returns A {@link KeyvSerializationCapability} where `compatible` is `true` when both `stringify` and `parse` methods are present
+* @example
+* ```typescript
+* import { detectKeyvSerialization } from 'keyv';
+*
+* detectKeyvSerialization(JSON);
+* // { compatible: true, methods: { stringify: { exists: true, methodType: "sync" }, parse: { exists: true, methodType: "sync" } } }
+* ```
+*/
+function detectKeyvSerialization(obj) {
+	if (obj === null || obj === void 0 || typeof obj !== "object") return {
+		compatible: false,
+		methods: buildMethods(null, keyvSerializationMethodNames)
+	};
+	const methods = buildMethods(obj, keyvSerializationMethodNames);
+	return {
+		compatible: keyvSerializationMethodNames.every((k) => methods[k].exists),
+		methods
+	};
+}
+/**
+* Detect whether an object implements the Keyv encryption adapter interface
+* @param obj - The object to check
+* @returns A {@link KeyvEncryptionCapability} where `compatible` is `true` when both `encrypt` and `decrypt` methods are present
+* @example
+* ```typescript
+* import { detectKeyvEncryption } from 'keyv';
+*
+* detectKeyvEncryption({ encrypt: (d) => d, decrypt: (d) => d });
+* // { compatible: true, methods: { encrypt: { exists: true, methodType: "sync" }, decrypt: { exists: true, methodType: "sync" } } }
+* ```
+*/
+function detectKeyvEncryption(obj) {
+	if (obj === null || obj === void 0 || typeof obj !== "object") return {
+		compatible: false,
+		methods: buildMethods(null, keyvEncryptionMethodNames)
+	};
+	const methods = buildMethods(obj, keyvEncryptionMethodNames);
+	return {
+		compatible: keyvEncryptionMethodNames.every((k) => methods[k].exists),
+		methods
+	};
+}
+//#endregion
+//#region src/types/keyv.ts
+/**
+* Events emitted by Keyv for error handling and telemetry.
+*/
+let KeyvEvents = /* @__PURE__ */ function(KeyvEvents) {
+	/** Emitted when an error occurs in a store operation. */
+	KeyvEvents["ERROR"] = "error";
+	/** Emitted for informational messages. */
+	KeyvEvents["INFO"] = "info";
+	/** Emitted for warning messages. */
+	KeyvEvents["WARN"] = "warn";
+	/** Telemetry: cache hit. */
+	KeyvEvents["STAT_HIT"] = "stat:hit";
+	/** Telemetry: cache miss. */
+	KeyvEvents["STAT_MISS"] = "stat:miss";
+	/** Telemetry: value set. */
+	KeyvEvents["STAT_SET"] = "stat:set";
+	/** Telemetry: value deleted. */
+	KeyvEvents["STAT_DELETE"] = "stat:delete";
+	/** Telemetry: operation error. */
+	KeyvEvents["STAT_ERROR"] = "stat:error";
+	return KeyvEvents;
+}({});
+/**
+* Hook names for intercepting Keyv operations.
+* Register hooks via `keyv.on(KeyvHooks.BEFORE_SET, callback)` to run logic before/after operations.
+*/
+let KeyvHooks = /* @__PURE__ */ function(KeyvHooks) {
+	/** @deprecated Use BEFORE_SET instead */
+	KeyvHooks["PRE_SET"] = "preSet";
+	/** @deprecated Use AFTER_SET instead */
+	KeyvHooks["POST_SET"] = "postSet";
+	/** @deprecated Use BEFORE_GET instead */
+	KeyvHooks["PRE_GET"] = "preGet";
+	/** @deprecated Use AFTER_GET instead */
+	KeyvHooks["POST_GET"] = "postGet";
+	/** @deprecated Use BEFORE_GET_MANY instead */
+	KeyvHooks["PRE_GET_MANY"] = "preGetMany";
+	/** @deprecated Use AFTER_GET_MANY instead */
+	KeyvHooks["POST_GET_MANY"] = "postGetMany";
+	/** @deprecated Use BEFORE_GET_RAW instead */
+	KeyvHooks["PRE_GET_RAW"] = "preGetRaw";
+	/** @deprecated Use AFTER_GET_RAW instead */
+	KeyvHooks["POST_GET_RAW"] = "postGetRaw";
+	/** @deprecated Use BEFORE_GET_MANY_RAW instead */
+	KeyvHooks["PRE_GET_MANY_RAW"] = "preGetManyRaw";
+	/** @deprecated Use AFTER_GET_MANY_RAW instead */
+	KeyvHooks["POST_GET_MANY_RAW"] = "postGetManyRaw";
+	/** @deprecated Use BEFORE_SET_RAW instead */
+	KeyvHooks["PRE_SET_RAW"] = "preSetRaw";
+	/** @deprecated Use AFTER_SET_RAW instead */
+	KeyvHooks["POST_SET_RAW"] = "postSetRaw";
+	/** @deprecated Use BEFORE_SET_MANY_RAW instead */
+	KeyvHooks["PRE_SET_MANY_RAW"] = "preSetManyRaw";
+	/** @deprecated Use AFTER_SET_MANY_RAW instead */
+	KeyvHooks["POST_SET_MANY_RAW"] = "postSetManyRaw";
+	/** @deprecated Use BEFORE_SET_MANY instead */
+	KeyvHooks["PRE_SET_MANY"] = "preSetMany";
+	/** @deprecated Use AFTER_SET_MANY instead */
+	KeyvHooks["POST_SET_MANY"] = "postSetMany";
+	/** @deprecated Use BEFORE_DELETE instead */
+	KeyvHooks["PRE_DELETE"] = "preDelete";
+	/** @deprecated Use AFTER_DELETE instead */
+	KeyvHooks["POST_DELETE"] = "postDelete";
+	/** @deprecated Use BEFORE_DELETE_MANY instead */
+	KeyvHooks["PRE_DELETE_MANY"] = "preDeleteMany";
+	/** @deprecated Use AFTER_DELETE_MANY instead */
+	KeyvHooks["POST_DELETE_MANY"] = "postDeleteMany";
+	KeyvHooks["BEFORE_SET"] = "before:set";
+	KeyvHooks["AFTER_SET"] = "after:set";
+	KeyvHooks["BEFORE_GET"] = "before:get";
+	KeyvHooks["AFTER_GET"] = "after:get";
+	KeyvHooks["BEFORE_GET_MANY"] = "before:getMany";
+	KeyvHooks["AFTER_GET_MANY"] = "after:getMany";
+	KeyvHooks["BEFORE_GET_RAW"] = "before:getRaw";
+	KeyvHooks["AFTER_GET_RAW"] = "after:getRaw";
+	KeyvHooks["BEFORE_GET_MANY_RAW"] = "before:getManyRaw";
+	KeyvHooks["AFTER_GET_MANY_RAW"] = "after:getManyRaw";
+	KeyvHooks["BEFORE_SET_RAW"] = "before:setRaw";
+	KeyvHooks["AFTER_SET_RAW"] = "after:setRaw";
+	KeyvHooks["BEFORE_SET_MANY"] = "before:setMany";
+	KeyvHooks["AFTER_SET_MANY"] = "after:setMany";
+	KeyvHooks["BEFORE_SET_MANY_RAW"] = "before:setManyRaw";
+	KeyvHooks["AFTER_SET_MANY_RAW"] = "after:setManyRaw";
+	KeyvHooks["BEFORE_DELETE"] = "before:delete";
+	KeyvHooks["AFTER_DELETE"] = "after:delete";
+	KeyvHooks["BEFORE_DELETE_MANY"] = "before:deleteMany";
+	KeyvHooks["AFTER_DELETE_MANY"] = "after:deleteMany";
+	KeyvHooks["BEFORE_HAS"] = "before:has";
+	KeyvHooks["AFTER_HAS"] = "after:has";
+	KeyvHooks["BEFORE_HAS_MANY"] = "before:hasMany";
+	KeyvHooks["AFTER_HAS_MANY"] = "after:hasMany";
+	KeyvHooks["BEFORE_CLEAR"] = "before:clear";
+	KeyvHooks["AFTER_CLEAR"] = "after:clear";
+	KeyvHooks["BEFORE_DISCONNECT"] = "before:disconnect";
+	KeyvHooks["AFTER_DISCONNECT"] = "after:disconnect";
+	return KeyvHooks;
+}({});
+//#endregion
+//#region src/utils.ts
+/**
+* Check whether a deserialized entry has expired based on its `expires` timestamp.
+*/
+function isDataExpired(data) {
+	return typeof data.expires === "number" && Date.now() > data.expires;
+}
+/**
+* Calculate an absolute expiry timestamp from a TTL value.
+* Returns `undefined` when `ttl` is absent, zero, negative, or non-finite
+* (meaning "no expiry").
+*
+* @param ttl - Time-to-live in milliseconds, or `undefined`
+* @returns Absolute expiry timestamp (ms since epoch), or `undefined`
+*/
+function calculateExpires(ttl) {
+	if (typeof ttl !== "number" || ttl <= 0 || !Number.isFinite(ttl)) return;
+	return Date.now() + ttl;
+}
+/**
+* Resolve a TTL value by falling back to a default when none is given,
+* then normalising zero, negative, or non-finite values to `undefined` (meaning "no expiry").
+*
+* @param ttl - Explicit TTL in milliseconds, or `undefined`
+* @param defaultTtl - Fallback TTL (typically `Keyv._ttl`), or `undefined`
+* @returns The resolved TTL in milliseconds, or `undefined` for no expiry
+*/
+function resolveTtl(ttl, defaultTtl) {
+	const resolved = ttl ?? defaultTtl;
+	if (resolved === void 0 || resolved <= 0 || !Number.isFinite(resolved)) return;
+	return resolved;
+}
+/**
+* Derive a store-level TTL from an absolute `expires` timestamp.
+* Returns `undefined` when `expires` is absent, non-finite, or when the derived
+* TTL is zero or negative (i.e. the entry has already expired).
+*
+* @param expires - Absolute expiry timestamp in milliseconds since epoch, or `undefined`
+* @returns The remaining TTL in milliseconds, or `undefined`
+*/
+function ttlFromExpires(expires) {
+	if (typeof expires !== "number" || !Number.isFinite(expires)) return;
+	const remaining = expires - Date.now();
+	return remaining > 0 ? remaining : void 0;
+}
+/**
+* Scan parallel `keys` and `data` arrays, nullify any expired entries in
+* `data`, and batch-delete the corresponding keys via `keyv.deleteMany()`.
+*/
+async function deleteExpiredKeys(keys, data, keyv) {
+	const expiredKeys = [];
+	for (const [index, row] of data.entries()) if (row !== void 0 && row !== null && isDataExpired(row)) {
+		expiredKeys.push(keys[index]);
+		data[index] = void 0;
+	}
+	if (expiredKeys.length > 0) await keyv.deleteMany(expiredKeys);
+}
+/**
+* Maps new hook names to their deprecated equivalents so both fire during migration.
+*/
+const deprecatedHookAliases = new Map([
+	[KeyvHooks.BEFORE_SET, KeyvHooks.PRE_SET],
+	[KeyvHooks.AFTER_SET, KeyvHooks.POST_SET],
+	[KeyvHooks.BEFORE_GET, KeyvHooks.PRE_GET],
+	[KeyvHooks.AFTER_GET, KeyvHooks.POST_GET],
+	[KeyvHooks.BEFORE_GET_MANY, KeyvHooks.PRE_GET_MANY],
+	[KeyvHooks.AFTER_GET_MANY, KeyvHooks.POST_GET_MANY],
+	[KeyvHooks.BEFORE_GET_RAW, KeyvHooks.PRE_GET_RAW],
+	[KeyvHooks.AFTER_GET_RAW, KeyvHooks.POST_GET_RAW],
+	[KeyvHooks.BEFORE_GET_MANY_RAW, KeyvHooks.PRE_GET_MANY_RAW],
+	[KeyvHooks.AFTER_GET_MANY_RAW, KeyvHooks.POST_GET_MANY_RAW],
+	[KeyvHooks.BEFORE_SET_RAW, KeyvHooks.PRE_SET_RAW],
+	[KeyvHooks.AFTER_SET_RAW, KeyvHooks.POST_SET_RAW],
+	[KeyvHooks.BEFORE_SET_MANY, KeyvHooks.PRE_SET_MANY],
+	[KeyvHooks.AFTER_SET_MANY, KeyvHooks.POST_SET_MANY],
+	[KeyvHooks.BEFORE_SET_MANY_RAW, KeyvHooks.PRE_SET_MANY_RAW],
+	[KeyvHooks.AFTER_SET_MANY_RAW, KeyvHooks.POST_SET_MANY_RAW],
+	[KeyvHooks.BEFORE_DELETE, KeyvHooks.PRE_DELETE],
+	[KeyvHooks.AFTER_DELETE, KeyvHooks.POST_DELETE],
+	[KeyvHooks.BEFORE_DELETE_MANY, KeyvHooks.PRE_DELETE_MANY],
+	[KeyvHooks.AFTER_DELETE_MANY, KeyvHooks.POST_DELETE_MANY]
+]);
+/**
+* Build the deprecated-hooks map used by Hookified to warn when old PRE_/POST_ hook names are registered.
+*/
+function buildDeprecatedHooks() {
+	return new Map([
+		["preSet", "Use KeyvHooks.BEFORE_SET ('before:set') instead"],
+		["postSet", "Use KeyvHooks.AFTER_SET ('after:set') instead"],
+		["preGet", "Use KeyvHooks.BEFORE_GET ('before:get') instead"],
+		["postGet", "Use KeyvHooks.AFTER_GET ('after:get') instead"],
+		["preGetMany", "Use KeyvHooks.BEFORE_GET_MANY ('before:getMany') instead"],
+		["postGetMany", "Use KeyvHooks.AFTER_GET_MANY ('after:getMany') instead"],
+		["preGetRaw", "Use KeyvHooks.BEFORE_GET_RAW ('before:getRaw') instead"],
+		["postGetRaw", "Use KeyvHooks.AFTER_GET_RAW ('after:getRaw') instead"],
+		["preGetManyRaw", "Use KeyvHooks.BEFORE_GET_MANY_RAW ('before:getManyRaw') instead"],
+		["postGetManyRaw", "Use KeyvHooks.AFTER_GET_MANY_RAW ('after:getManyRaw') instead"],
+		["preSetRaw", "Use KeyvHooks.BEFORE_SET_RAW ('before:setRaw') instead"],
+		["postSetRaw", "Use KeyvHooks.AFTER_SET_RAW ('after:setRaw') instead"],
+		["preSetMany", "Use KeyvHooks.BEFORE_SET_MANY ('before:setMany') instead"],
+		["postSetMany", "Use KeyvHooks.AFTER_SET_MANY ('after:setMany') instead"],
+		["preSetManyRaw", "Use KeyvHooks.BEFORE_SET_MANY_RAW ('before:setManyRaw') instead"],
+		["postSetManyRaw", "Use KeyvHooks.AFTER_SET_MANY_RAW ('after:setManyRaw') instead"],
+		["preDelete", "Use KeyvHooks.BEFORE_DELETE ('before:delete') instead"],
+		["postDelete", "Use KeyvHooks.AFTER_DELETE ('after:delete') instead"],
+		["preDeleteMany", "Use KeyvHooks.BEFORE_DELETE_MANY ('before:deleteMany') instead"],
+		["postDeleteMany", "Use KeyvHooks.AFTER_DELETE_MANY ('after:deleteMany') instead"]
+	]);
+}
+//#endregion
+//#region src/adapters/bridge.ts
+/**
+* A bridge storage adapter for Keyv that wraps any promise-based store.
+*
+* This class provides a unified interface for using various async stores
+* with Keyv, handling namespace prefixing, TTL-based expiration, and batch operations.
+* If the underlying store implements optional methods (has, hasMany, getMany, etc.),
+* the bridge will delegate to them. Otherwise, it falls back to using primitives.
+*
+* @example
+* ```typescript
+* // Using with a promise-based store
+* const bridge = new KeyvBridgeAdapter(myAsyncStore, { namespace: 'cache' });
+*
+* // Using with Keyv
+* const keyv = new Keyv({ store: new KeyvBridgeAdapter(myAsyncStore) });
+* ```
+*/
+var KeyvBridgeAdapter = class extends hookified.Hookified {
+	_store;
+	_namespace;
+	_keySeparator = ":";
+	_capabilities;
+	/**
+	* Creates a new KeyvBridgeAdapter instance.
+	* @param store - The underlying promise-based store to bridge
+	* @param options - Configuration options for the adapter
+	*/
+	constructor(store, options) {
+		super({ throwOnHookError: false });
+		this._store = store;
+		if (options?.keySeparator) this._keySeparator = options.keySeparator;
+		if (options?.namespace) this._namespace = options.namespace;
+		this._capabilities = detectKeyvStorage(store);
+		if (typeof store.on === "function") store.on(KeyvEvents.ERROR, (error) => this.emit(KeyvEvents.ERROR, error));
+	}
+	/**
+	* Gets the underlying store instance.
+	*/
+	get store() {
+		return this._store;
+	}
+	/**
+	* Sets the underlying store instance.
+	*/
+	set store(store) {
+		this._store = store;
+	}
+	/**
+	* Gets the detected capabilities of the underlying store.
+	*/
+	get capabilities() {
+		return this._capabilities;
+	}
+	/**
+	* Gets the current key separator used between namespace and key.
+	*/
+	get keySeparator() {
+		return this._keySeparator;
+	}
+	/**
+	* Sets the key separator used between namespace and key.
+	*/
+	set keySeparator(separator) {
+		this._keySeparator = separator;
+	}
+	/**
+	* Gets the current namespace.
+	*/
+	get namespace() {
+		return this._namespace;
+	}
+	/**
+	* Sets the namespace.
+	*/
+	set namespace(namespace) {
+		this._namespace = namespace;
+	}
+	/**
+	* Creates a prefixed key by combining the namespace and key with the separator.
+	* @param key - The base key
+	* @param namespace - Optional namespace to prefix the key with
+	* @returns The prefixed key if namespace is provided, otherwise the original key
+	*/
+	getKeyPrefix(key, namespace) {
+		if (namespace) return `${namespace}${this._keySeparator}${key}`;
+		return key;
+	}
+	/**
+	* Parses a prefixed key to extract the namespace and original key.
+	* @param key - The prefixed key to parse
+	* @returns An object containing the namespace (if present) and the original key
+	*/
+	getKeyPrefixData(key) {
+		if (this._namespace && key.startsWith(`${this._namespace}${this._keySeparator}`)) return {
+			namespace: this._namespace,
+			key: key.slice(this._namespace.length + this._keySeparator.length)
+		};
+		return { key };
+	}
+	/**
+	* Retrieves a value from the store by key.
+	* Automatically handles namespace prefixing and TTL expiration.
+	* @param key - The key to retrieve
+	* @returns The stored data, or undefined if not found or expired
+	*/
+	async get(key) {
+		const keyPrefix = this.getKeyPrefix(key, this._namespace);
+		const data = await this._store.get(keyPrefix);
+		if (data === void 0 || data === null) return;
+		if (isDataExpired(data)) {
+			await this._store.delete(keyPrefix);
+			return;
+		}
+		return data;
+	}
+	/**
+	* Retrieves multiple values from the store by their keys.
+	* Delegates to the store's native getMany if available.
+	* @param keys - Array of keys to retrieve
+	* @returns Array of stored data in the same order as the input keys
+	*/
+	async getMany(keys) {
+		if (this._capabilities.methods.getMany.exists) {
+			const prefixedKeys = keys.map((key) => this.getKeyPrefix(key, this._namespace));
+			/* v8 ignore next -- @preserve */
+			const results = await this._store.getMany?.(prefixedKeys) ?? [];
+			const values = [];
+			for (const [index, data] of results.entries()) {
+				if (data === void 0 || data === null) {
+					values.push(void 0);
+					continue;
+				}
+				if (isDataExpired(data)) {
+					await this._store.delete(prefixedKeys[index]);
+					values.push(void 0);
+					continue;
+				}
+				values.push(data);
+			}
+			return values;
+		}
+		const values = [];
+		for (const key of keys) {
+			const data = await this.get(key);
+			values.push(data);
+		}
+		return values;
+	}
+	/**
+	* Stores a value in the store with an optional TTL.
+	* @param key - The key to store the value under
+	* @param value - The value to store
+	* @param ttl - Optional time-to-live in milliseconds
+	* @returns Always returns true indicating success
+	*/
+	async set(key, value, ttl) {
+		const keyPrefix = this.getKeyPrefix(key, this._namespace);
+		const result = await this._store.set(keyPrefix, value, ttl);
+		if (typeof result === "boolean") return result;
+		return true;
+	}
+	/**
+	* Stores multiple entries in the store at once.
+	* Delegates to the store's native setMany if available, otherwise loops over set.
+	* @param entries - Array of entries containing key, value, and optional TTL
+	*/
+	async setMany(entries) {
+		if (this._capabilities.methods.setMany.exists) {
+			const prefixedEntries = entries.map((entry) => ({
+				...entry,
+				key: this.getKeyPrefix(entry.key, this._namespace)
+			}));
+			await this._store.setMany?.(prefixedEntries);
+			return entries.map(() => true);
+		}
+		const results = [];
+		for (const entry of entries) {
+			await this.set(entry.key, entry.value, entry.ttl);
+			results.push(true);
+		}
+		return results;
+	}
+	/**
+	* Checks if a key exists in the store and is not expired.
+	* Delegates to the store's native has if available.
+	* @param key - The key to check
+	* @returns True if the key exists and is not expired, false otherwise
+	*/
+	async has(key) {
+		if (this._capabilities.methods.has.exists) {
+			const keyPrefix = this.getKeyPrefix(key, this._namespace);
+			/* v8 ignore next -- @preserve */
+			return this._store.has?.(keyPrefix) ?? false;
+		}
+		return await this.get(key) !== void 0;
+	}
+	/**
+	* Checks if multiple keys exist in the store and are not expired.
+	* Delegates to the store's native hasMany if available.
+	* @param keys - Array of keys to check
+	* @returns Array of booleans indicating existence for each key
+	*/
+	async hasMany(keys) {
+		if (this._capabilities.methods.hasMany.exists) {
+			const prefixedKeys = keys.map((key) => this.getKeyPrefix(key, this._namespace));
+			/* v8 ignore next -- @preserve */
+			return this._store.hasMany?.(prefixedKeys) ?? [];
+		}
+		const results = [];
+		for (const key of keys) results.push(await this.has(key));
+		return results;
+	}
+	/**
+	* Deletes a value from the store by key.
+	* @param key - The key to delete
+	* @returns True if the key was deleted, false otherwise
+	*/
+	async delete(key) {
+		const keyPrefix = this.getKeyPrefix(key, this._namespace);
+		return this._store.delete(keyPrefix);
+	}
+	/**
+	* Deletes multiple keys from the store at once.
+	* Delegates to the store's native deleteMany if available.
+	* @param keys - Array of keys to delete
+	* @returns Array of booleans indicating success for each key
+	*/
+	async deleteMany(keys) {
+		if (this._capabilities.methods.deleteMany.exists) {
+			const prefixedKeys = keys.map((key) => this.getKeyPrefix(key, this._namespace));
+			/* v8 ignore next -- @preserve */
+			const result = await this._store.deleteMany?.(prefixedKeys) ?? [];
+			return Array.isArray(result) ? result : keys.map(() => result);
+		}
+		const results = [];
+		for (const key of keys) try {
+			const keyPrefix = this.getKeyPrefix(key, this._namespace);
+			const result = await this._store.delete(keyPrefix);
+			results.push(result);
+		} catch (error) {
+			this.emit(KeyvEvents.ERROR, error);
+			results.push(false);
+		}
+		return results;
+	}
+	/**
+	* Clears entries from the store. If a namespace is set and the store supports
+	* iteration, only entries within that namespace are removed. Otherwise, the
+	* entire store is cleared.
+	*/
+	async clear() {
+		if (!this._namespace || !this._capabilities.methods.iterator.exists) {
+			await this._store.clear();
+			return;
+		}
+		const prefix = `${this._namespace}${this._keySeparator}`;
+		const keysToDelete = [];
+		/* v8 ignore next -- @preserve */
+		for await (const entry of this._store.iterator?.(this._namespace) ?? []) {
+			const key = Array.isArray(entry) ? entry[0] : entry;
+			if (typeof key === "string" && key.startsWith(prefix)) keysToDelete.push(key);
+		}
+		for (const key of keysToDelete) await this._store.delete(key);
+	}
+	/**
+	* Creates an async iterator for iterating over store entries.
+	* If the underlying store does not support iteration, returns an empty generator.
+	* @returns An async generator yielding [key, value] pairs
+	*/
+	async *iterator() {
+		if (!this._capabilities.methods.iterator.exists) return;
+		const namespace = this._namespace;
+		const prefix = namespace ? `${namespace}${this._keySeparator}` : void 0;
+		/* v8 ignore next -- @preserve */
+		for await (const entry of this._store.iterator?.(this._namespace) ?? []) {
+			const [key, data] = Array.isArray(entry) ? entry : [entry];
+			if (prefix && typeof key === "string" && !key.startsWith(prefix)) continue;
+			if (data && isDataExpired(data)) {
+				await this._store.delete(key);
+				continue;
+			}
+			yield [prefix && typeof key === "string" ? key.slice(prefix.length) : key, data];
+		}
+	}
+	/**
+	* Disconnects from the underlying store.
+	* No-op if the store does not support disconnect.
+	*/
+	async disconnect() {
+		if (this._capabilities.methods.disconnect.exists) await this._store.disconnect?.();
+	}
 };
-var hooks_manager_default = HooksManager;
-
-// src/json-serializer.ts
+//#endregion
+//#region src/json-serializer.ts
 function getGlobalBuffer() {
-  return globalThis.Buffer;
+	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);
+	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;
+	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;
+	if (getGlobalBuffer()?.isBuffer(value)) return true;
+	return value instanceof Uint8Array;
 }
+/**
+* Pre-process a value tree, converting Buffer and BigInt to tagged strings
+* before JSON.stringify can call toJSON() on them.
+*/
 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;
+	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;
-    });
-  }
+	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;
-  }
+const jsonSerializer = new KeyvJsonSerializer();
+//#endregion
+//#region src/sanitize.ts
+const categoryPatterns = {
+	sql: [
+		/;/g,
+		/--/g,
+		/\/\*/g
+	],
+	mongo: [/^\$/g, /\{\s*\$/g],
+	escape: [
+		/\0/g,
+		/\r/g,
+		/\n/g
+	],
+	path: [/\.\.\//g, /\.\.\\/g]
 };
-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;
-  }
+/**
+* Compile an array of RegExp patterns from the enabled categories.
+* Returns `undefined` when nothing is enabled.
+*/
+function buildPatterns(options) {
+	const patterns = [];
+	for (const [category, regexes] of Object.entries(categoryPatterns)) if (options[category] !== false) patterns.push(...regexes);
+	return patterns.length > 0 ? patterns : void 0;
+}
+/**
+* Run all patterns against a string, stripping matched sequences.
+*/
+function applyPatterns(value, patterns) {
+	for (const pattern of patterns) {
+		pattern.lastIndex = 0;
+		value = value.replace(pattern, "");
+	}
+	return value;
+}
+const allOn = {
+	escape: true,
+	mongo: true,
+	path: true,
+	sql: true
 };
-var index_default = Keyv;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Keyv,
-  KeyvHooks,
-  KeyvJsonSerializer,
-  jsonSerializer
-});
-/* v8 ignore next -- @preserve */
+const allOff = {
+	escape: false,
+	mongo: false,
+	path: false,
+	sql: false
+};
+/**
+* Encapsulates key and namespace sanitization with an LRU result cache.
+*/
+var KeyvSanitize = class {
+	_keys = { ...allOff };
+	_namespace = { ...allOff };
+	_keyPatterns;
+	_namespacePatterns;
+	_enabled = false;
+	_cacheKeys = /* @__PURE__ */ new Map();
+	_cacheNamespaces = /* @__PURE__ */ new Map();
+	_cacheMax = 1e4;
+	constructor(options) {
+		if (options !== void 0) this.updateOptions(options);
+	}
+	/**
+	* The key sanitization pattern configuration.
+	*/
+	get keys() {
+		return this._keys;
+	}
+	/**
+	* Whether any sanitization pattern (keys or namespace) is enabled.
+	*/
+	get enabled() {
+		return this._enabled;
+	}
+	/**
+	* The namespace sanitization pattern configuration.
+	*/
+	get namespace() {
+		return this._namespace;
+	}
+	/**
+	* Update the sanitization configuration. Recompiles patterns and clears the cache.
+	*/
+	updateOptions(options) {
+		this._keys = this.resolvePatterns(options.keys);
+		this._namespace = this.resolvePatterns(options.namespace);
+		this._enabled = Object.values(this._keys).some(Boolean) || Object.values(this._namespace).some(Boolean);
+		this._keyPatterns = buildPatterns(this._keys);
+		this._namespacePatterns = buildPatterns(this._namespace);
+		this._cacheKeys.clear();
+		this._cacheNamespaces.clear();
+	}
+	/**
+	* Sanitize a single key. Uses an LRU cache for repeated lookups.
+	*/
+	cleanKey(key) {
+		if (!this._keyPatterns) return key;
+		const cached = this._cacheKeys.get(key);
+		if (cached !== void 0) {
+			this._cacheKeys.delete(key);
+			this._cacheKeys.set(key, cached);
+			return cached;
+		}
+		const result = applyPatterns(key, this._keyPatterns);
+		this._cacheKeys.set(key, result);
+		if (this._cacheKeys.size > this._cacheMax) {
+			const first = this._cacheKeys.keys().next().value;
+			if (first !== void 0) this._cacheKeys.delete(first);
+		}
+		return result;
+	}
+	/**
+	* Sanitize an array of keys.
+	*/
+	cleanKeys(keys) {
+		if (!this._keyPatterns) return keys;
+		return keys.map((k) => this.cleanKey(k));
+	}
+	/**
+	* Sanitize a namespace string. Uses an LRU cache for repeated lookups.
+	*/
+	cleanNamespace(ns) {
+		if (!this._namespacePatterns) return ns;
+		const cached = this._cacheNamespaces.get(ns);
+		if (cached !== void 0) {
+			this._cacheNamespaces.delete(ns);
+			this._cacheNamespaces.set(ns, cached);
+			return cached;
+		}
+		const result = applyPatterns(ns, this._namespacePatterns);
+		this._cacheNamespaces.set(ns, result);
+		if (this._cacheNamespaces.size > this._cacheMax) {
+			const first = this._cacheNamespaces.keys().next().value;
+			if (first !== void 0) this._cacheNamespaces.delete(first);
+		}
+		return result;
+	}
+	/**
+	* Clear the LRU caches.
+	*/
+	clearCache() {
+		this._cacheKeys.clear();
+		this._cacheNamespaces.clear();
+	}
+	resolvePatterns(options) {
+		if (options === false || options === void 0) return { ...allOff };
+		if (options === true) return { ...allOn };
+		return {
+			sql: options.sql !== false,
+			mongo: options.mongo !== false,
+			escape: options.escape !== false,
+			path: options.path !== false
+		};
+	}
+};
+//#endregion
+//#region src/stats.ts
+var KeyvStats = class {
+	_hits = 0;
+	_misses = 0;
+	_sets = 0;
+	_deletes = 0;
+	_errors = 0;
+	_maxEntries = 1e3;
+	_enabled = false;
+	hitKeysMap = /* @__PURE__ */ new Map();
+	missKeysMap = /* @__PURE__ */ new Map();
+	setKeysMap = /* @__PURE__ */ new Map();
+	deleteKeysMap = /* @__PURE__ */ new Map();
+	errorKeysMap = /* @__PURE__ */ new Map();
+	_emitter;
+	_listeners = /* @__PURE__ */ new Map();
+	constructor(options) {
+		if (options?.maxEntries !== void 0) this._maxEntries = options.maxEntries;
+		if (options?.enabled !== void 0) this._enabled = options.enabled;
+		this.reset();
+		if (options?.emitter) if (this._enabled === true) this.subscribe(options.emitter);
+		else this._emitter = options.emitter;
+	}
+	/**
+	* Total number of cache hits.
+	*/
+	get hits() {
+		return this._hits;
+	}
+	/**
+	* Total number of cache misses.
+	*/
+	get misses() {
+		return this._misses;
+	}
+	/**
+	* Total number of cache sets.
+	*/
+	get sets() {
+		return this._sets;
+	}
+	/**
+	* Total number of cache deletes.
+	*/
+	get deletes() {
+		return this._deletes;
+	}
+	/**
+	* Total number of cache errors.
+	*/
+	get errors() {
+		return this._errors;
+	}
+	/**
+	* LRU-bounded map of key to hit count.
+	*/
+	get hitKeys() {
+		return this.hitKeysMap;
+	}
+	/**
+	* LRU-bounded map of key to miss count.
+	*/
+	get missKeys() {
+		return this.missKeysMap;
+	}
+	/**
+	* LRU-bounded map of key to set count.
+	*/
+	get setKeys() {
+		return this.setKeysMap;
+	}
+	/**
+	* LRU-bounded map of key to delete count.
+	*/
+	get deleteKeys() {
+		return this.deleteKeysMap;
+	}
+	/**
+	* LRU-bounded map of key to error count.
+	*/
+	get errorKeys() {
+		return this.errorKeysMap;
+	}
+	/**
+	* Maximum number of entries per event-type LRU map.
+	* @default 1000
+	*/
+	get maxEntries() {
+		return this._maxEntries;
+	}
+	/**
+	* Set the maximum number of entries per event-type LRU map.
+	* @param {number} value the new maximum entries
+	*/
+	/* v8 ignore next 3 -- @preserve */
+	set maxEntries(value) {
+		this._maxEntries = value;
+	}
+	/**
+	* Whether stats tracking is enabled.
+	* @default false
+	*/
+	get enabled() {
+		return this._enabled;
+	}
+	/**
+	* Enable or disable stats tracking. If false it will unsubscribe from the events
+	* @param {boolean} value true to enable, false to disable
+	*/
+	set enabled(value) {
+		this._enabled = value;
+		if (this._enabled === false && this._listeners.size !== 0) {
+			const emitter = this._emitter;
+			this.unsubscribe();
+			this._emitter = emitter;
+		} else if (this._enabled === true && this._emitter && this._listeners.size === 0) this.subscribe(this._emitter);
+	}
+	/**
+	* Build a composite key from a telemetry event.
+	* Format: "namespace:key" if namespace is present, otherwise just "key".
+	*/
+	buildKeyEventName(event) {
+		if (event.namespace && event.key) return `${event.namespace}:${event.key}`;
+		return event.key ?? "";
+	}
+	/**
+	* Increment the count for a key in an LRU-bounded map.
+	* Deletes and re-inserts to maintain LRU order, evicts the oldest entry when full.
+	*/
+	incrementKeys(map, compositeKey) {
+		if (this.maxEntries <= 0 || !compositeKey) return;
+		const current = map.get(compositeKey) ?? 0;
+		map.delete(compositeKey);
+		map.set(compositeKey, current + 1);
+		if (map.size > this.maxEntries) {
+			const first = map.keys().next().value;
+			if (first !== void 0) map.delete(first);
+		}
+	}
+	/**
+	* Subscribe to telemetry events from an emitter (e.g. a Keyv instance).
+	* Automatically increments the corresponding stat counters and LRU key maps on each event.
+	* @param {IEventEmitter} emitter the event emitter to subscribe to
+	*/
+	subscribe(emitter) {
+		this.unsubscribe();
+		this._emitter = emitter;
+		const hitListener = (event) => {
+			this._hits++;
+			this.incrementKeys(this.hitKeysMap, this.buildKeyEventName(event));
+		};
+		const missListener = (event) => {
+			this._misses++;
+			this.incrementKeys(this.missKeysMap, this.buildKeyEventName(event));
+		};
+		const setListener = (event) => {
+			this._sets++;
+			this.incrementKeys(this.setKeysMap, this.buildKeyEventName(event));
+		};
+		const deleteListener = (event) => {
+			this._deletes++;
+			this.incrementKeys(this.deleteKeysMap, this.buildKeyEventName(event));
+		};
+		const errorListener = (event) => {
+			this._errors++;
+			this.incrementKeys(this.errorKeysMap, this.buildKeyEventName(event));
+		};
+		this._listeners.set("stat:hit", hitListener);
+		this._listeners.set("stat:miss", missListener);
+		this._listeners.set("stat:set", setListener);
+		this._listeners.set("stat:delete", deleteListener);
+		this._listeners.set("stat:error", errorListener);
+		emitter.on("stat:hit", hitListener);
+		emitter.on("stat:miss", missListener);
+		emitter.on("stat:set", setListener);
+		emitter.on("stat:delete", deleteListener);
+		emitter.on("stat:error", errorListener);
+	}
+	/**
+	* Unsubscribe from the currently subscribed emitter, removing all telemetry event listeners.
+	*/
+	unsubscribe() {
+		if (!this._emitter) return;
+		for (const [eventName, listener] of this._listeners) this._emitter.off(eventName, listener);
+		this._listeners.clear();
+		this._emitter = void 0;
+	}
+	/**
+	* Reset all counters and LRU key maps to their initial state.
+	*/
+	reset() {
+		this._hits = 0;
+		this._misses = 0;
+		this._sets = 0;
+		this._deletes = 0;
+		this._errors = 0;
+		this.hitKeysMap.clear();
+		this.missKeysMap.clear();
+		this.setKeysMap.clear();
+		this.deleteKeysMap.clear();
+		this.errorKeysMap.clear();
+	}
+};
+//#endregion
+//#region src/keyv.ts
+var Keyv = class Keyv extends hookified.Hookified {
+	/**
+	* Stats manager for tracking cache operation metrics (hits, misses, sets, deletes, errors).
+	* @default this is disabled.
+	*/
+	_stats;
+	/**
+	* Default time to live in milliseconds. Can be overridden per-key via {@link set}.
+	*/
+	_ttl;
+	/**
+	* Key prefix namespace used to isolate keys across different Keyv instances sharing the same store.
+	*/
+	_namespace;
+	/**
+	* The underlying storage adapter. Defaults to an in-memory {@link Map}.
+	*/
+	_store = new KeyvMemoryAdapter(/* @__PURE__ */ new Map());
+	/**
+	* Pluggable serialization adapter with `stringify` and `parse` methods.
+	* When `undefined`, the built-in {@link KeyvJsonSerializer} is used.
+	*/
+	_serialization;
+	/**
+	* Pluggable compression adapter with `compress` and `decompress` methods.
+	*/
+	_compression;
+	/**
+	* Pluggable encryption adapter with `encrypt` and `decrypt` methods.
+	*/
+	_encryption;
+	/**
+	* Sanitization handler for keys and namespaces. By default it is disabled.
+	*/
+	_sanitize;
+	/**
+	* When true, Keyv checks expiry at its layer on get/getMany/has/hasMany.
+	*/
+	_checkExpired = false;
+	/**
+	* 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) {
+		const mergedOptions = Keyv.resolveOptions(store, options);
+		super({
+			throwOnHookError: false,
+			throwOnEmptyListeners: true,
+			throwOnEmitError: mergedOptions.throwOnErrors ?? false
+		});
+		this.deprecatedHooks = buildDeprecatedHooks();
+		this._compression = mergedOptions.compression;
+		this._encryption = mergedOptions.encryption;
+		this.initSerialization(mergedOptions);
+		this.initSanitize(mergedOptions);
+		this.initNamespace(mergedOptions.namespace);
+		this.initStats(mergedOptions);
+		if (mergedOptions.store) this.setStore(mergedOptions.store);
+		this.setTtl(mergedOptions.ttl);
+		this._checkExpired = mergedOptions.checkExpired ?? false;
+	}
+	/**
+	* Get the current storage adapter.
+	* @returns {KeyvStorageAdapter} The current storage adapter.
+	*/
+	get store() {
+		return this._store;
+	}
+	/**
+	* Set the storage adapter.
+	* @param {KeyvStorageAdapter | Map<any, any> | any} store The storage adapter to set.
+	*/
+	set store(store) {
+		this.setStore(store);
+	}
+	/**
+	* Get the current compression adapter.
+	* @returns {KeyvCompressionAdapter | undefined} The current compression adapter.
+	*/
+	get compression() {
+		return this._compression;
+	}
+	/**
+	* Set the compression adapter.
+	* @param {KeyvCompressionAdapter | undefined} compress The compression adapter to set.
+	*/
+	set compression(compress) {
+		this._compression = compress;
+	}
+	/**
+	* Get the current encryption adapter.
+	* @returns {KeyvEncryptionAdapter | undefined} The current encryption adapter.
+	*/
+	get encryption() {
+		return this._encryption;
+	}
+	/**
+	* Set the encryption adapter.
+	* @param {KeyvEncryptionAdapter | undefined} encryption The encryption adapter to set.
+	*/
+	set encryption(encryption) {
+		this._encryption = encryption;
+	}
+	/**
+	* 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._sanitize.enabled ? this._sanitize.cleanNamespace(namespace) : namespace;
+		this._store.namespace = this._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.setTtl(ttl);
+	}
+	/**
+	* Get the current serialization adapter. If `undefined`, serialization is not enabled.
+	* @returns {KeyvSerializationAdapter | undefined} The current serialization adapter.
+	*/
+	get serialization() {
+		return this._serialization;
+	}
+	/**
+	* Set the current serialization adapter. Pass a `KeyvSerializationAdapter` to enable
+	* custom serialization, or `undefined` to disable serialization entirely.
+	* @param {KeyvSerializationAdapter | undefined} serialization The serialization adapter to set.
+	*/
+	set serialization(serialization) {
+		this._serialization = serialization === false ? void 0 : serialization;
+	}
+	/**
+	* Get the current throwOnErrors value. When enabled, all errors with throw. By default, errors
+	* will only throw if there are no listeners to the error event.
+	* @return {boolean} The current throwOnErrors value.
+	*/
+	get throwOnErrors() {
+		return this.throwOnEmitError;
+	}
+	/**
+	* Set the current throwOnErrors value. When enabled, all errors will throw. By default, errors
+	* will only throw if there are no listeners to the error event.
+	* @param {boolean} value The throwOnErrors value to set.
+	*/
+	set throwOnErrors(value) {
+		this.throwOnEmitError = value;
+	}
+	/**
+	* Get the current sanitize adapter. Sanitization is disabled by default. To
+	* enable it `sanitize.keys` or `sanitize.namespace` to true or set KeyvSanitizePatterns
+	* to each.
+	* @returns {KeyvSanitizeAdapter} The current sanitize adapter.
+	*/
+	get sanitize() {
+		return this._sanitize;
+	}
+	/**
+	* Set the sanitize adapter directly and will run sanitization on namespace.
+	* @param {KeyvSanitizeAdapter} value The sanitize adapter to use.
+	*/
+	set sanitize(value) {
+		this._sanitize = value;
+		/* v8 ignore next -- @preserve */
+		this._namespace = this._namespace && this._sanitize.enabled ? this._sanitize.cleanNamespace(this._namespace) : this._namespace;
+	}
+	/**
+	* Get the stats. This is just for this instance
+	* @returns {KeyvStats} The current stats.
+	*/
+	get stats() {
+		return this._stats;
+	}
+	/**
+	* When true, Keyv checks expiry at its layer on get/getMany/has/hasMany.
+	* When false (default), trusts the storage adapter.
+	*/
+	get checkExpired() {
+		return this._checkExpired;
+	}
+	/**
+	* Set the stats. When setting a new instance it will unsubscribe the old listeners
+	* and subscribe the new instance.
+	* @param {KeyvStats} stats The stats instance to set.
+	*/
+	set stats(stats) {
+		this._stats.unsubscribe();
+		this._stats = stats;
+		this._stats.subscribe(this);
+	}
+	/**
+	* Resolves a store to a fully-compliant KeyvStorageAdapter using a 3-tier detection chain:
+	* 1. If the store already implements the full KeyvStorageAdapter interface, use it directly.
+	* 2. If the store is map-like (synchronous get/set/delete/has), wrap it in KeyvMemoryAdapter.
+	* 3. If the store has async get/set/delete/clear, wrap it in KeyvBridgeAdapter.
+	* 4. Otherwise, emit an error and fall back to a default in-memory KeyvMemoryAdapter.
+	*
+	* NOTE: this is used for internal but provided public for custom adapter testing
+	* @param {unknown} store The store to resolve.
+	* @returns {KeyvStorageAdapter} A fully-compliant storage adapter.
+	*/
+	resolveStore(store) {
+		const cap = detectKeyvStorage(store);
+		if (cap.store === "keyvStorage") return store;
+		if (cap.store === "mapLike") return new KeyvMemoryAdapter(store);
+		if (cap.store === "asyncMap") return new KeyvBridgeAdapter(store);
+		this.emit(KeyvEvents.ERROR, /* @__PURE__ */ new Error("Could not use the provided storage adapter, falling back to KeyvMemoryAdapter with Map"));
+		return new KeyvMemoryAdapter(/* @__PURE__ */ new Map());
+	}
+	/**
+	* Sets the storage adapter by resolving it via {@link resolveStore}, then wires up
+	* error forwarding and namespace propagation.
+	* @param {KeyvStorageAdapter | Map<any, any> | any} store The storage adapter to set.
+	*/
+	setStore(store) {
+		this._store = this.resolveStore(store);
+		if (typeof this._store.on === "function") this._store.on(KeyvEvents.ERROR, (error) => this.emit(KeyvEvents.ERROR, error));
+		this._store.namespace = this._namespace;
+	}
+	/**
+	* Sets the TTL, treating zero and negative values as undefined (no TTL).
+	* @param {number | undefined} ttl The TTL to set in milliseconds.
+	*/
+	setTtl(ttl) {
+		if (typeof ttl === "number" && ttl <= 0) {
+			this._ttl = void 0;
+			return;
+		}
+		this._ttl = ttl;
+	}
+	async get(key) {
+		if (Array.isArray(key)) return this.getMany(key);
+		key = this._sanitize.enabled ? this._sanitize.cleanKey(key) : key;
+		if (key === "") return;
+		await this.hookWithDeprecated(KeyvHooks.BEFORE_GET, { key });
+		let rawData;
+		try {
+			rawData = await this._store.get(key);
+		} catch (error) {
+			this.emit(KeyvEvents.ERROR, error);
+			this.emitTelemetry(KeyvEvents.STAT_ERROR, key);
+		}
+		let data;
+		if (this._checkExpired) [data] = await this.decodeWithExpire(key, rawData);
+		else data = rawData === void 0 || rawData === null ? void 0 : typeof rawData === "string" ? await this.decode(rawData) : rawData;
+		if (data === void 0) {
+			await this.hookWithDeprecated(KeyvHooks.AFTER_GET, {
+				key,
+				value: void 0
+			});
+			this.emitTelemetry(KeyvEvents.STAT_MISS, key);
+			return;
+		}
+		await this.hookWithDeprecated(KeyvHooks.AFTER_GET, {
+			key,
+			value: data
+		});
+		this.emitTelemetry(KeyvEvents.STAT_HIT, key);
+		return data.value;
+	}
+	/**
+	* Get many values of keys
+	* @param {string[]} keys passing in a single key or multiple as an array
+	*/
+	async getMany(keys) {
+		keys = this._sanitize.enabled ? this._sanitize.cleanKeys(keys) : keys;
+		await this.hookWithDeprecated(KeyvHooks.BEFORE_GET_MANY, { keys });
+		const rawData = await this._store.getMany(keys);
+		let deserialized;
+		if (this._checkExpired) deserialized = await this.decodeWithExpire(keys, rawData);
+		else deserialized = await Promise.all(rawData.map(async (row) => {
+			if (row === void 0 || row === null) return;
+			return typeof row === "string" ? this.decode(row) : row;
+		}));
+		const result = deserialized.map((row) => row !== void 0 ? row.value : void 0);
+		await this.hookWithDeprecated(KeyvHooks.AFTER_GET_MANY, result);
+		for (let i = 0; i < result.length; i++) if (result[i] === void 0) this.emitTelemetry(KeyvEvents.STAT_MISS, keys[i]);
+		else this.emitTelemetry(KeyvEvents.STAT_HIT, keys[i]);
+		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<KeyvStorageGetResult<Value>>} will return a KeyvStorageGetResult<Value> or undefined
+	* if the key does not exist or is expired.
+	*/
+	async getRaw(key) {
+		key = this._sanitize.enabled ? this._sanitize.cleanKey(key) : key;
+		if (key === "") return;
+		await this.hookWithDeprecated(KeyvHooks.BEFORE_GET_RAW, { key });
+		const rawData = await this._store.get(key);
+		let data;
+		if (this._checkExpired) [data] = await this.decodeWithExpire(key, rawData);
+		else data = rawData === void 0 || rawData === null ? void 0 : typeof rawData === "string" ? await this.decode(rawData) : rawData;
+		if (data === void 0) {
+			await this.hookWithDeprecated(KeyvHooks.AFTER_GET_RAW, {
+				key,
+				value: void 0
+			});
+			this.emitTelemetry(KeyvEvents.STAT_MISS, key);
+			return;
+		}
+		this.emitTelemetry(KeyvEvents.STAT_HIT, key);
+		await this.hookWithDeprecated(KeyvHooks.AFTER_GET_RAW, {
+			key,
+			value: data
+		});
+		return data;
+	}
+	/**
+	* 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<KeyvStorageGetResult<Value>>>} will return an array of KeyvStorageGetResult<Value> or undefined if the key does not exist or is expired.
+	*/
+	async getManyRaw(keys) {
+		/* v8 ignore next -- @preserve */
+		keys = this._sanitize.enabled ? this._sanitize.cleanKeys(keys) : keys;
+		await this.hookWithDeprecated(KeyvHooks.BEFORE_GET_MANY_RAW, { keys });
+		if (keys.length === 0) {
+			const result = [];
+			await this.hookWithDeprecated(KeyvHooks.AFTER_GET_MANY_RAW, {
+				keys,
+				values: result
+			});
+			return result;
+		}
+		const rawData = await this._store.getMany(keys);
+		let result;
+		if (this._checkExpired) result = await this.decodeWithExpire(keys, rawData);
+		else result = await Promise.all(rawData.map(async (row) => {
+			if (row === void 0 || row === null) return;
+			return typeof row === "string" ? this.decode(row) : row;
+		}));
+		for (let i = 0; i < result.length; i++) if (result[i] === void 0) this.emitTelemetry(KeyvEvents.STAT_MISS, keys[i]);
+		else this.emitTelemetry(KeyvEvents.STAT_HIT, keys[i]);
+		await this.hookWithDeprecated(KeyvHooks.AFTER_GET_MANY_RAW, {
+			keys,
+			values: result
+		});
+		return result;
+	}
+	/**
+	* Set an item to the store
+	* @param {string | Array<KeyvEntry<Value>>} 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) {
+		key = this._sanitize.enabled ? this._sanitize.cleanKey(key) : key;
+		if (key === "") return false;
+		const data = {
+			key,
+			value,
+			ttl
+		};
+		await this.hookWithDeprecated(KeyvHooks.BEFORE_SET, data);
+		data.ttl = resolveTtl(data.ttl, this._ttl);
+		const expires = calculateExpires(data.ttl);
+		if (typeof data.value === "symbol") {
+			this.emit(KeyvEvents.ERROR, "symbol cannot be serialized");
+			this.emitTelemetry(KeyvEvents.STAT_ERROR, key);
+			return false;
+		}
+		const formattedValue = {
+			value: data.value,
+			expires
+		};
+		let result = true;
+		let encodedValue = formattedValue;
+		try {
+			encodedValue = await this.encode(formattedValue);
+			result = await this._store.set(data.key, encodedValue, data.ttl);
+		} catch (error) {
+			result = false;
+			this.emit(KeyvEvents.ERROR, error);
+			this.emitTelemetry(KeyvEvents.STAT_ERROR, key);
+		}
+		await this.hookWithDeprecated(KeyvHooks.AFTER_SET, {
+			key,
+			value: encodedValue,
+			ttl
+		});
+		if (result) this.emitTelemetry(KeyvEvents.STAT_SET, key);
+		return result;
+	}
+	/**
+	* Set many items to the store
+	* @param {Array<KeyvEntry<Value>>} 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.
+	*/
+	async setMany(entries) {
+		entries = entries.map((e) => ({
+			...e,
+			key: this._sanitize.enabled ? this._sanitize.cleanKey(e.key) : e.key
+		}));
+		const data = { entries };
+		await this.hookWithDeprecated(KeyvHooks.BEFORE_SET_MANY, data);
+		entries = data.entries;
+		let results = [];
+		try {
+			const serializedEntries = await Promise.all(entries.map(async ({ key, value, ttl }) => {
+				ttl = resolveTtl(ttl, this._ttl);
+				/* v8 ignore next -- @preserve */
+				const expires = calculateExpires(ttl);
+				/* v8 ignore next -- @preserve */
+				if (typeof value === "symbol") {
+					this.emit(KeyvEvents.ERROR, "symbol cannot be serialized");
+					this.emitTelemetry(KeyvEvents.STAT_ERROR, key);
+					throw new Error("symbol cannot be serialized");
+				}
+				const formattedValue = {
+					value,
+					expires
+				};
+				return {
+					key,
+					value: await this.encode(formattedValue),
+					ttl
+				};
+			}));
+			const storeResult = await this._store.setMany(serializedEntries);
+			/* v8 ignore next -- @preserve */
+			results = Array.isArray(storeResult) ? storeResult : entries.map(() => true);
+			this.emitTelemetry(KeyvEvents.STAT_SET, entries.map((e) => e.key));
+		} catch (error) {
+			this.emit(KeyvEvents.ERROR, error);
+			this.emitTelemetry(KeyvEvents.STAT_ERROR, entries.map((e) => e.key));
+			results = entries.map(() => false);
+		}
+		await this.hookWithDeprecated(KeyvHooks.AFTER_SET_MANY, {
+			entries,
+			values: results
+		});
+		return results;
+	}
+	/**
+	* Set a raw value to the store without wrapping or serialization. This is the write-side counterpart to getRaw().
+	* The value should be a KeyvValue object with { value, expires? }. If you need TTL-based expiration,
+	* set `expires` on the value directly (e.g. `{ value: 'bar', expires: Date.now() + 60000 }`).
+	* The store-level TTL is derived automatically from `value.expires`.
+	* @param {string} key the key to set
+	* @param {KeyvValue<Value>} value the raw value envelope to store
+	* @returns {boolean} if it sets then it will return a true. On failure will return false.
+	*/
+	async setRaw(key, value) {
+		key = this._sanitize.enabled ? this._sanitize.cleanKey(key) : key;
+		if (key === "") return false;
+		const data = {
+			key,
+			value
+		};
+		await this.hookWithDeprecated(KeyvHooks.BEFORE_SET_RAW, data);
+		const ttl = ttlFromExpires(data.value.expires);
+		let result = true;
+		try {
+			const encodedValue = await this.encode(data.value);
+			const storeResult = await this._store.set(data.key, encodedValue, ttl);
+			if (typeof storeResult === "boolean") result = storeResult;
+		} catch (error) {
+			result = false;
+			this.emit(KeyvEvents.ERROR, error);
+			this.emitTelemetry(KeyvEvents.STAT_ERROR, key);
+		}
+		await this.hookWithDeprecated(KeyvHooks.AFTER_SET_RAW, {
+			key,
+			value: data.value,
+			ttl
+		});
+		if (result) this.emitTelemetry(KeyvEvents.STAT_SET, key);
+		return result;
+	}
+	/**
+	* 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 KeyvValue object with { value, expires? }. If you need TTL-based expiration,
+	* set `expires` on each value directly. The store-level TTL is derived automatically from `value.expires`.
+	* @param {KeyvEntry<KeyvValue<Value>>[]} 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) {
+		entries = entries.map((e) => ({
+			...e,
+			key: this._sanitize.enabled ? this._sanitize.cleanKey(e.key) : e.key
+		}));
+		let results = [];
+		await this.hookWithDeprecated(KeyvHooks.BEFORE_SET_MANY_RAW, { entries });
+		try {
+			const rawEntries = await Promise.all(entries.map(async ({ key, value }) => {
+				const ttl = ttlFromExpires(value.expires);
+				return {
+					key,
+					value: await this.encode(value),
+					ttl
+				};
+			}));
+			const storeResult = await this._store.setMany(rawEntries);
+			results = Array.isArray(storeResult) ? storeResult : entries.map(() => true);
+			this.emitTelemetry(KeyvEvents.STAT_SET, entries.map((e) => e.key));
+		} catch (error) {
+			this.emit(KeyvEvents.ERROR, error);
+			this.emitTelemetry(KeyvEvents.STAT_ERROR, entries.map((e) => e.key));
+			results = entries.map(() => false);
+		}
+		await this.hookWithDeprecated(KeyvHooks.AFTER_SET_MANY_RAW, {
+			entries,
+			results
+		});
+		return results;
+	}
+	async delete(key) {
+		if (Array.isArray(key)) return this.deleteMany(key);
+		key = this._sanitize.enabled ? this._sanitize.cleanKey(key) : key;
+		if (key === "") return false;
+		await this.hookWithDeprecated(KeyvHooks.BEFORE_DELETE, { key });
+		let result = true;
+		try {
+			result = await this._store.delete(key);
+		} catch (error) {
+			result = false;
+			this.emit(KeyvEvents.ERROR, error);
+			this.emitTelemetry(KeyvEvents.STAT_ERROR, key);
+		}
+		await this.hookWithDeprecated(KeyvHooks.AFTER_DELETE, {
+			key,
+			value: result
+		});
+		this.emitTelemetry(KeyvEvents.STAT_DELETE, key);
+		return result;
+	}
+	/**
+	* Delete many items from the store
+	* @param {string[]} keys the keys to be deleted
+	* @returns {boolean[]} array of booleans indicating success for each key
+	*/
+	async deleteMany(keys) {
+		/* v8 ignore next -- @preserve */
+		keys = this._sanitize.enabled ? this._sanitize.cleanKeys(keys) : keys;
+		await this.hookWithDeprecated(KeyvHooks.BEFORE_DELETE_MANY, { keys });
+		await this.hookWithDeprecated(KeyvHooks.BEFORE_DELETE, { key: keys });
+		let results;
+		try {
+			results = await this._store.deleteMany(keys);
+			this.emitTelemetry(KeyvEvents.STAT_DELETE, keys);
+		} catch (error) {
+			this.emit(KeyvEvents.ERROR, error);
+			this.emitTelemetry(KeyvEvents.STAT_ERROR, keys);
+			results = keys.map(() => false);
+		}
+		await this.hookWithDeprecated(KeyvHooks.AFTER_DELETE_MANY, {
+			keys,
+			values: results
+		});
+		await this.hookWithDeprecated(KeyvHooks.AFTER_DELETE, {
+			key: keys,
+			value: results
+		});
+		return results;
+	}
+	async has(key) {
+		if (Array.isArray(key)) return this.hasMany(key);
+		key = this._sanitize.enabled ? this._sanitize.cleanKey(key) : key;
+		if (key === "") return false;
+		await this.hookWithDeprecated(KeyvHooks.BEFORE_HAS, { key });
+		let result = false;
+		try {
+			if (this._checkExpired) {
+				const rawData = await this._store.get(key);
+				if (rawData !== void 0 && rawData !== null) {
+					const [data] = await this.decodeWithExpire(key, rawData);
+					result = data !== void 0;
+				}
+			} else result = await this._store.has(key);
+		} catch (error) {
+			this.emit(KeyvEvents.ERROR, error);
+			this.emitTelemetry(KeyvEvents.STAT_ERROR, key);
+		}
+		await this.hookWithDeprecated(KeyvHooks.AFTER_HAS, {
+			key,
+			value: result
+		});
+		return result;
+	}
+	/**
+	* 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) {
+		keys = this._sanitize.enabled ? this._sanitize.cleanKeys(keys) : keys;
+		await this.hookWithDeprecated(KeyvHooks.BEFORE_HAS_MANY, { keys });
+		let results = [];
+		try {
+			if (this._checkExpired) {
+				const rawData = await this._store.getMany(keys);
+				results = (await this.decodeWithExpire(keys, rawData)).map((row) => row !== void 0);
+			} else results = await this._store.hasMany(keys);
+		} catch (error) {
+			this.emit(KeyvEvents.ERROR, error);
+			this.emitTelemetry(KeyvEvents.STAT_ERROR, keys);
+			results = keys.map(() => false);
+		}
+		await this.hookWithDeprecated(KeyvHooks.AFTER_HAS_MANY, {
+			keys,
+			values: results
+		});
+		return results;
+	}
+	/**
+	* Clear the store
+	* @returns {void}
+	*/
+	async clear() {
+		this.emit("clear");
+		await this.hook(KeyvHooks.BEFORE_CLEAR, { namespace: this._namespace });
+		try {
+			await this._store.clear();
+		} catch (error) {
+			this.emit(KeyvEvents.ERROR, error);
+			this.emitTelemetry(KeyvEvents.STAT_ERROR);
+		}
+		await this.hook(KeyvHooks.AFTER_CLEAR, { namespace: this._namespace });
+	}
+	/**
+	* Will disconnect the store. This is only available if the store has a disconnect method
+	* @returns {Promise<void>}
+	*/
+	async disconnect() {
+		this.emit("disconnect");
+		await this.hook(KeyvHooks.BEFORE_DISCONNECT, { namespace: this._namespace });
+		try {
+			if (this._store.disconnect) await this._store.disconnect();
+		} catch (error) {
+			this.emit(KeyvEvents.ERROR, error);
+		}
+		await this.hook(KeyvHooks.AFTER_DISCONNECT, { namespace: this._namespace });
+	}
+	/**
+	* Iterate over all key-value pairs in the store. Automatically deserializes values,
+	* filters out expired entries, and deletes them from the store.
+	* @returns {AsyncGenerator<Array<string | unknown>, void>} An async generator yielding `[key, value]` pairs.
+	*/
+	async *iterator() {
+		/* v8 ignore next 3 -- @preserve */
+		if (this._store.iterator === void 0) return;
+		for await (const [key, raw] of this._store.iterator()) {
+			const data = await this.decode(raw);
+			if (this._checkExpired && data && isDataExpired(data)) {
+				await this.delete(key);
+				continue;
+			}
+			yield [key, data?.value];
+		}
+	}
+	/**
+	* Encodes a value for storage. Pipeline: serialize → compress → encrypt.
+	* If serialization is not configured, returns the data as-is.
+	* @param {KeyvValue<T>} data The value envelope to encode.
+	* @returns {Promise<unknown>} The encoded value, or the original data on failure.
+	*/
+	async encode(data) {
+		if (!this._serialization) return data;
+		let result = await this._serialization.stringify(data);
+		if (this._compression?.compress) result = await this._compression.compress(result);
+		if (this._encryption?.encrypt) result = await this._encryption.encrypt(result);
+		return result;
+	}
+	/**
+	* Decodes a stored value. Pipeline: decrypt → decompress → deserialize (reverse of encode).
+	* If serialization is not configured, returns the data as a KeyvValue or undefined for strings.
+	* @param {unknown} data The raw data from the store.
+	* @returns {Promise<KeyvValue<T> | undefined>} The decoded value envelope, or undefined on failure.
+	*/
+	async decode(data) {
+		if (data === void 0 || data === null) return;
+		if (!this._serialization) return typeof data === "string" ? void 0 : data;
+		try {
+			let result = data;
+			if (this._encryption?.decrypt) result = await this._encryption.decrypt(result);
+			if (this._compression?.decompress) result = await this._compression.decompress(result);
+			if (typeof result === "string") return await this._serialization.parse(result);
+			return result;
+		} catch (error) {
+			this.emit(KeyvEvents.ERROR, error);
+			return;
+		}
+	}
+	/**
+	* Deserializes raw data from the store, checks for expiry, and deletes expired keys.
+	* Accepts a single key/value or arrays. Returns an array of decoded KeyvValue objects
+	* (undefined for missing or expired entries).
+	* @param {string | string[]} keys the key(s) to process
+	* @param {unknown | unknown[]} rawData the raw data from the store
+	* @returns {Promise<Array<KeyvValue<Value> | undefined>>} decoded values with expired entries removed
+	*/
+	async decodeWithExpire(keys, rawData) {
+		const keyArray = Array.isArray(keys) ? keys : [keys];
+		const dataArray = Array.isArray(rawData) ? rawData : [rawData];
+		const results = [];
+		for (const row of dataArray) {
+			if (row === void 0 || row === null) {
+				results.push(void 0);
+				continue;
+			}
+			const deserialized = typeof row === "string" ? await this.decode(row) : row;
+			if (deserialized === void 0 || deserialized === null) {
+				results.push(void 0);
+				continue;
+			}
+			results.push(deserialized);
+		}
+		await deleteExpiredKeys(keyArray, results, this);
+		return results;
+	}
+	/**
+	* Fires a hook under its new name and also under the deprecated alias (if any),
+	* so that integrations still subscribing to the old PRE_/POST_ names keep working.
+	*/
+	async hookWithDeprecated(event, ...args) {
+		await this.hook(event, ...args);
+		const deprecated = deprecatedHookAliases.get(event);
+		if (deprecated && this.getHooks(deprecated)?.length) await this.hook(deprecated, ...args);
+	}
+	/**
+	* Emit a telemetry event for cache operations.
+	* @param {KeyvEvents} event the telemetry event type
+	* @param {string | string[]} [key] the cache key or keys (emits one event per key)
+	*/
+	emitTelemetry(event, key) {
+		if (key === void 0) {
+			this.emit(event, {
+				event: event.replace("stat:", ""),
+				namespace: this._namespace,
+				timestamp: Date.now()
+			});
+			return;
+		}
+		const keys = Array.isArray(key) ? key : [key];
+		for (const k of keys) this.emit(event, {
+			event: event.replace("stat:", ""),
+			key: k,
+			namespace: this._namespace,
+			timestamp: Date.now()
+		});
+	}
+	/**
+	* Merges the overloaded constructor arguments into a single KeyvOptions object.
+	*/
+	static resolveOptions(store, options) {
+		options ??= {};
+		store ??= {};
+		const merged = { ...options };
+		if (store && store.get) merged.store = store;
+		else Object.assign(merged, store);
+		return merged;
+	}
+	/**
+	* Initializes the serialization adapter from options.
+	*/
+	initSerialization(options) {
+		if (options.serialization === false) this._serialization = void 0;
+		else this._serialization = options.serialization ?? new KeyvJsonSerializer();
+	}
+	/**
+	* Initializes the sanitization handler from options.
+	*/
+	initSanitize(options) {
+		const sanitize = new KeyvSanitize();
+		if (options.sanitize) sanitize.updateOptions(options.sanitize);
+		this._sanitize = sanitize;
+	}
+	/**
+	* Initializes the stats manager from options.
+	*/
+	initStats(options) {
+		this._stats = new KeyvStats({
+			emitter: this,
+			enabled: options.stats ?? false
+		});
+	}
+	/**
+	* Initializes the namespace, applying sanitization if enabled.
+	*/
+	initNamespace(namespace) {
+		this._namespace = namespace;
+		if (this._namespace && this._sanitize.enabled) this._namespace = this._sanitize.cleanNamespace(this._namespace);
+	}
+};
+//#endregion
+//#region src/adapters/memory.ts
+/**
+* An in-memory storage adapter for Keyv that wraps any Map-like object.
+*
+* This class provides a unified interface for using various Map-like stores
+* with Keyv, handling namespace prefixing, TTL-based expiration, and batch operations.
+*
+* @example
+* ```typescript
+* // Using with a standard Map
+* const store = new KeyvMemoryAdapter(new Map(), { namespace: 'cache' });
+*
+* // Using with a custom store
+* const customStore = new KeyvMemoryAdapter(myCustomMapLikeStore, {
+*   namespace: 'tenant-123',
+*   keySeparator: ':'
+* });
+* ```
+*/
+var KeyvMemoryAdapter = class extends hookified.Hookified {
+	_store;
+	_namespace;
+	_keySeparator = ":";
+	_capabilities;
+	/**
+	* Creates a new KeyvMemoryAdapter instance.
+	* @param store - The underlying Map or Map-like object to use for storage
+	* @param options - Configuration options for the store
+	*/
+	constructor(store, options) {
+		super({ throwOnHookError: false });
+		this._store = store;
+		this._capabilities = detectKeyvStorage(store);
+		if (options?.keySeparator) this._keySeparator = options.keySeparator;
+		if (options?.namespace) this._namespace = options?.namespace;
+	}
+	/**
+	* Gets the detected capabilities of the underlying store.
+	*/
+	get capabilities() {
+		return this._capabilities;
+	}
+	/**
+	* Gets the underlying store instance.
+	*/
+	get store() {
+		return this._store;
+	}
+	/**
+	* Sets the underlying store instance.
+	*/
+	set store(store) {
+		this._store = store;
+	}
+	/**
+	* Gets the current key separator used between namespace and key.
+	*/
+	get keySeparator() {
+		return this._keySeparator;
+	}
+	/**
+	* Sets the key separator used between namespace and key.
+	*/
+	set keySeparator(separator) {
+		this._keySeparator = separator;
+	}
+	/**
+	* Gets the current namespace.
+	*/
+	get namespace() {
+		return this._namespace;
+	}
+	/**
+	* Sets the namespace.
+	*/
+	set namespace(namespace) {
+		this._namespace = namespace;
+	}
+	/**
+	* Creates a prefixed key by combining the namespace and key with the separator.
+	* @param key - The base key
+	* @param namespace - Optional namespace to prefix the key with
+	* @returns The prefixed key if namespace is provided, otherwise the original key
+	*/
+	getKeyPrefix(key, namespace) {
+		if (namespace) return `${namespace}${this._keySeparator}${key}`;
+		return key;
+	}
+	/**
+	* Parses a prefixed key to extract the namespace and original key.
+	* @param key - The prefixed key to parse
+	* @returns An object containing the namespace (if present) and the original key
+	*/
+	getKeyPrefixData(key) {
+		if (this._namespace && key.startsWith(`${this._namespace}${this._keySeparator}`)) return {
+			namespace: this._namespace,
+			key: key.slice(this._namespace.length + this._keySeparator.length)
+		};
+		return { key };
+	}
+	/**
+	* Retrieves a value from the store by key.
+	* Automatically handles namespace prefixing and TTL expiration.
+	* @param key - The key to retrieve
+	* @returns The stored data, or undefined if not found or expired
+	*/
+	async get(key) {
+		const keyPrefix = this.getKeyPrefix(key, this._namespace);
+		const entry = this._store.get(keyPrefix);
+		if (entry === void 0 || entry === null) return;
+		if (entry.expires !== void 0 && Date.now() > entry.expires) {
+			this._store.delete(keyPrefix);
+			return;
+		}
+		return entry.value;
+	}
+	/**
+	* Stores a value in the store with an optional TTL.
+	* @param key - The key to store the value under
+	* @param value - The value to store
+	* @param ttl - Optional time-to-live in milliseconds
+	* @returns Always returns true indicating success
+	*/
+	async set(key, value, ttl) {
+		const keyPrefix = this.getKeyPrefix(key, this._namespace);
+		const entry = {
+			value,
+			expires: ttl ? Date.now() + ttl : void 0
+		};
+		this._store.set(keyPrefix, entry, ttl);
+		return true;
+	}
+	/**
+	* Stores multiple entries in the store at once.
+	* @param entries - Array of entries containing key, value, and optional TTL
+	*/
+	async setMany(entries) {
+		const results = [];
+		for (const entry of entries) {
+			const keyPrefix = this.getKeyPrefix(entry.key, this._namespace);
+			const memEntry = {
+				value: entry.value,
+				expires: entry.ttl ? Date.now() + entry.ttl : void 0
+			};
+			this._store.set(keyPrefix, memEntry, entry.ttl);
+			results.push(true);
+		}
+		return results;
+	}
+	/**
+	* Deletes a value from the store by key.
+	* @param key - The key to delete
+	* @returns True if the key was deleted, false otherwise
+	*/
+	async delete(key) {
+		const keyPrefix = this.getKeyPrefix(key, this._namespace);
+		return this._store.delete(keyPrefix);
+	}
+	/**
+	* Clears entries from the store. If a namespace is set, only entries
+	* within that namespace are removed. Otherwise, the entire store is cleared.
+	* NOTE: if there is no `keys()` then we just do a full clear.
+	*/
+	async clear() {
+		if (!this._namespace || typeof this._store.keys !== "function") {
+			this._store.clear();
+			return;
+		}
+		const prefix = `${this._namespace}${this._keySeparator}`;
+		const keysToDelete = [];
+		for (const key of this._store.keys()) if (key.startsWith(prefix)) keysToDelete.push(key);
+		for (const key of keysToDelete) this._store.delete(key);
+	}
+	/**
+	* Checks if a key exists in the store and is not expired.
+	* @param key - The key to check
+	* @returns True if the key exists and is not expired, false otherwise
+	*/
+	async has(key) {
+		const keyPrefix = this.getKeyPrefix(key, this._namespace);
+		const entry = this._store.get(keyPrefix);
+		if (entry === void 0 || entry === null) return false;
+		if (entry.expires !== void 0 && Date.now() > entry.expires) {
+			this._store.delete(keyPrefix);
+			return false;
+		}
+		return true;
+	}
+	/**
+	* Checks if multiple keys exist in the store and are not expired.
+	* @param keys - Array of keys to check
+	* @returns Array of booleans indicating existence for each key
+	*/
+	async hasMany(keys) {
+		const results = [];
+		for (const key of keys) results.push(await this.has(key));
+		return results;
+	}
+	/**
+	* Retrieves multiple values from the store by their keys.
+	* @param keys - Array of keys to retrieve
+	* @returns Array of stored data in the same order as the input keys
+	*/
+	async getMany(keys) {
+		const values = [];
+		for (const key of keys) {
+			const keyPrefix = this.getKeyPrefix(key, this._namespace);
+			const entry = this._store.get(keyPrefix);
+			if (entry === void 0 || entry === null) {
+				values.push(void 0);
+				continue;
+			}
+			if (entry.expires !== void 0 && Date.now() > entry.expires) {
+				this._store.delete(keyPrefix);
+				values.push(void 0);
+				continue;
+			}
+			values.push(entry.value);
+		}
+		return values;
+	}
+	/**
+	* Deletes multiple keys from the store at once.
+	* @param keys - Array of keys to delete
+	* @returns Array of booleans indicating success for each key
+	*/
+	async deleteMany(keys) {
+		const results = [];
+		for (const key of keys) try {
+			const keyPrefix = this.getKeyPrefix(key, this._namespace);
+			const existed = this._store.has(keyPrefix);
+			this._store.delete(keyPrefix);
+			results.push(existed);
+		} catch (error) {
+			this.emit(KeyvEvents.ERROR, error);
+			results.push(false);
+		}
+		return results;
+	}
+	/**
+	* Creates an async iterator for iterating over store entries.
+	* If the underlying store does not support iteration, returns an empty generator.
+	* @returns {AsyncGenerator<Array<string | Awaited<Value> | undefined>, void>} An async generator yielding [key, value] pairs
+	*/
+	async *iterator() {
+		if (typeof this._store.entries !== "function") return;
+		const namespace = this._namespace;
+		for (const [key, raw] of this._store.entries()) {
+			if (namespace) {
+				if (!key.startsWith(`${namespace}${this._keySeparator}`)) continue;
+			}
+			const entry = raw;
+			if (entry?.expires !== void 0 && Date.now() > entry.expires) {
+				this._store.delete(key);
+				continue;
+			}
+			yield [namespace ? key.slice(namespace.length + this._keySeparator.length) : key, entry?.value];
+		}
+	}
+	/**
+	* No-op disconnect for in-memory stores.
+	*/
+	async disconnect() {}
+};
+/**
+* Creates a Keyv instance with a memory adapter optimized for in-memory storage.
+*
+* This factory function configures Keyv to bypass serialization/deserialization
+* and key prefixing, resulting in faster performance for in-memory use cases
+* where data doesn't need to be persisted or transmitted.
+*
+* @param store - The underlying Map or Map-like object to use for storage
+* @param options - Configuration options for the memory adapter
+* @returns A configured Keyv instance with optimized settings for in-memory storage
+*
+* @example
+* ```typescript
+* // Create a simple in-memory cache
+* const cache = createKeyv(new Map());
+* await cache.set('user:1', { name: 'John' });
+*
+* // Create with namespace for multi-tenant scenarios
+* const tenantCache = createKeyv(new Map(), {
+*   namespace: 'tenant-123',
+*   keySeparator: ':'
+* });
+* ```
+*/
+function createKeyv(store, options) {
+	const { namespace, ...adapterOptions } = options ?? {};
+	return new Keyv({
+		store: new KeyvMemoryAdapter(store, adapterOptions),
+		serialization: false,
+		namespace
+	});
+}
+//#endregion
+exports.Keyv = Keyv;
+exports.KeyvBridgeAdapter = KeyvBridgeAdapter;
+exports.KeyvEvents = KeyvEvents;
+exports.KeyvHooks = KeyvHooks;
+exports.KeyvJsonSerializer = KeyvJsonSerializer;
+exports.KeyvMemoryAdapter = KeyvMemoryAdapter;
+exports.KeyvSanitize = KeyvSanitize;
+exports.KeyvStats = KeyvStats;
+exports.createKeyv = createKeyv;
+exports.default = Keyv;
+exports.detectKeyv = detectKeyv;
+exports.detectKeyvCompression = detectKeyvCompression;
+exports.detectKeyvEncryption = detectKeyvEncryption;
+exports.detectKeyvSerialization = detectKeyvSerialization;
+exports.detectKeyvStorage = detectKeyvStorage;
+exports.jsonSerializer = jsonSerializer;