memx 0.0.7 → 0.1.0

package/dist/index.mjs

@@ -1,1463 +1,18 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/decode.ts
-var decode_exports = {};
-__export(decode_exports, {
-  Decoder: () => Decoder
-});
-
-// src/constants.ts
-var constants_exports = {};
-__export(constants_exports, {
-  BUFFERS: () => BUFFERS,
-  DATA_TYPE: () => DATA_TYPE,
-  EMPTY_BUFFER: () => EMPTY_BUFFER,
-  FLAGS: () => FLAGS,
-  MAGIC: () => MAGIC,
-  OFFSETS: () => OFFSETS,
-  OPCODE: () => OPCODE,
-  STATUS: () => STATUS,
-  VBUCKET: () => VBUCKET
-});
-var EMPTY_BUFFER = Buffer.alloc(0);
-var FLAGS = /* @__PURE__ */ ((FLAGS2) => {
-  FLAGS2[FLAGS2["BUFFER"] = 0] = "BUFFER";
-  FLAGS2[FLAGS2["BIGINT"] = 3402235904] = "BIGINT";
-  FLAGS2[FLAGS2["BOOLEAN"] = 3402235905] = "BOOLEAN";
-  FLAGS2[FLAGS2["NUMBER"] = 3402235906] = "NUMBER";
-  FLAGS2[FLAGS2["STRING"] = 3402235907] = "STRING";
-  FLAGS2[FLAGS2["NULL"] = 3402235918] = "NULL";
-  FLAGS2[FLAGS2["JSON"] = 3402235919] = "JSON";
-  FLAGS2[FLAGS2["UINT8ARRAY"] = 3402235920] = "UINT8ARRAY";
-  FLAGS2[FLAGS2["UINT8CLAMPEDARRAY"] = 3402235921] = "UINT8CLAMPEDARRAY";
-  FLAGS2[FLAGS2["UINT16ARRAY"] = 3402235922] = "UINT16ARRAY";
-  FLAGS2[FLAGS2["UINT32ARRAY"] = 3402235923] = "UINT32ARRAY";
-  FLAGS2[FLAGS2["INT8ARRAY"] = 3402235924] = "INT8ARRAY";
-  FLAGS2[FLAGS2["INT16ARRAY"] = 3402235925] = "INT16ARRAY";
-  FLAGS2[FLAGS2["INT32ARRAY"] = 3402235926] = "INT32ARRAY";
-  FLAGS2[FLAGS2["BIGUINT64ARRAY"] = 3402235927] = "BIGUINT64ARRAY";
-  FLAGS2[FLAGS2["BIGINT64ARRAY"] = 3402235928] = "BIGINT64ARRAY";
-  FLAGS2[FLAGS2["FLOAT32ARRAY"] = 3402235929] = "FLOAT32ARRAY";
-  FLAGS2[FLAGS2["FLOAT64ARRAY"] = 3402235930] = "FLOAT64ARRAY";
-  return FLAGS2;
-})(FLAGS || {});
-var BUFFERS = /* @__PURE__ */ ((BUFFERS2) => {
-  BUFFERS2[BUFFERS2["POOL_SIZE"] = 64] = "POOL_SIZE";
-  BUFFERS2[BUFFERS2["BUFFER_SIZE"] = 8192] = "BUFFER_SIZE";
-  BUFFERS2[BUFFERS2["HEADER_SIZE"] = 24] = "HEADER_SIZE";
-  BUFFERS2[BUFFERS2["KEY_SIZE"] = 250] = "KEY_SIZE";
-  BUFFERS2[BUFFERS2["KEY_TOO_BIG"] = 251] = "KEY_TOO_BIG";
-  return BUFFERS2;
-})(BUFFERS || {});
-var OFFSETS = /* @__PURE__ */ ((OFFSETS2) => {
-  OFFSETS2[OFFSETS2["MAGIC_$8"] = 0] = "MAGIC_$8";
-  OFFSETS2[OFFSETS2["OPCODE_$8"] = 1] = "OPCODE_$8";
-  OFFSETS2[OFFSETS2["KEY_LENGTH_$16"] = 2] = "KEY_LENGTH_$16";
-  OFFSETS2[OFFSETS2["EXTRAS_LENGTH_$8"] = 4] = "EXTRAS_LENGTH_$8";
-  OFFSETS2[OFFSETS2["DATA_TYPE_$8"] = 5] = "DATA_TYPE_$8";
-  OFFSETS2[OFFSETS2["STATUS_$16"] = 6] = "STATUS_$16";
-  OFFSETS2[OFFSETS2["BODY_LENGTH_$32"] = 8] = "BODY_LENGTH_$32";
-  OFFSETS2[OFFSETS2["SEQUENCE_$32"] = 12] = "SEQUENCE_$32";
-  OFFSETS2[OFFSETS2["CAS_$64"] = 16] = "CAS_$64";
-  OFFSETS2[OFFSETS2["BODY"] = 24] = "BODY";
-  return OFFSETS2;
-})(OFFSETS || {});
-var MAGIC = /* @__PURE__ */ ((MAGIC2) => {
-  MAGIC2[MAGIC2["REQUEST"] = 128] = "REQUEST";
-  MAGIC2[MAGIC2["RESPONSE"] = 129] = "RESPONSE";
-  return MAGIC2;
-})(MAGIC || {});
-var STATUS = /* @__PURE__ */ ((STATUS2) => {
-  STATUS2[STATUS2["OK"] = 0] = "OK";
-  STATUS2[STATUS2["KEY_NOT_FOUND"] = 1] = "KEY_NOT_FOUND";
-  STATUS2[STATUS2["KEY_EXISTS"] = 2] = "KEY_EXISTS";
-  STATUS2[STATUS2["TOO_LARGE"] = 3] = "TOO_LARGE";
-  STATUS2[STATUS2["INVALID_ARGS"] = 4] = "INVALID_ARGS";
-  STATUS2[STATUS2["ITEM_NOT_STORED"] = 5] = "ITEM_NOT_STORED";
-  STATUS2[STATUS2["NON_NUMERIC_VALUE"] = 6] = "NON_NUMERIC_VALUE";
-  STATUS2[STATUS2["WRONG_VBUCKET"] = 7] = "WRONG_VBUCKET";
-  STATUS2[STATUS2["AUTH_ERROR"] = 8] = "AUTH_ERROR";
-  STATUS2[STATUS2["AUTH_CONTINUE"] = 9] = "AUTH_CONTINUE";
-  STATUS2[STATUS2["UNKNOWN_COMMAND"] = 129] = "UNKNOWN_COMMAND";
-  STATUS2[STATUS2["OUT_OF_MEMORY"] = 130] = "OUT_OF_MEMORY";
-  STATUS2[STATUS2["NOT_SUPPORTED"] = 131] = "NOT_SUPPORTED";
-  STATUS2[STATUS2["INTERNAL_ERROR"] = 132] = "INTERNAL_ERROR";
-  STATUS2[STATUS2["BUSY"] = 133] = "BUSY";
-  STATUS2[STATUS2["TEMPORARY_FAILURE"] = 134] = "TEMPORARY_FAILURE";
-  return STATUS2;
-})(STATUS || {});
-var OPCODE = /* @__PURE__ */ ((OPCODE3) => {
-  OPCODE3[OPCODE3["GET"] = 0] = "GET";
-  OPCODE3[OPCODE3["SET"] = 1] = "SET";
-  OPCODE3[OPCODE3["ADD"] = 2] = "ADD";
-  OPCODE3[OPCODE3["REPLACE"] = 3] = "REPLACE";
-  OPCODE3[OPCODE3["DELETE"] = 4] = "DELETE";
-  OPCODE3[OPCODE3["INCREMENT"] = 5] = "INCREMENT";
-  OPCODE3[OPCODE3["DECREMENT"] = 6] = "DECREMENT";
-  OPCODE3[OPCODE3["QUIT"] = 7] = "QUIT";
-  OPCODE3[OPCODE3["FLUSH"] = 8] = "FLUSH";
-  OPCODE3[OPCODE3["NOOP"] = 10] = "NOOP";
-  OPCODE3[OPCODE3["VERSION"] = 11] = "VERSION";
-  OPCODE3[OPCODE3["APPEND"] = 14] = "APPEND";
-  OPCODE3[OPCODE3["PREPEND"] = 15] = "PREPEND";
-  OPCODE3[OPCODE3["STAT"] = 16] = "STAT";
-  OPCODE3[OPCODE3["TOUCH"] = 28] = "TOUCH";
-  OPCODE3[OPCODE3["GAT"] = 29] = "GAT";
-  return OPCODE3;
-})(OPCODE || {});
-var DATA_TYPE = /* @__PURE__ */ ((DATA_TYPE2) => {
-  DATA_TYPE2[DATA_TYPE2["RAW"] = 0] = "RAW";
-  return DATA_TYPE2;
-})(DATA_TYPE || {});
-var VBUCKET = /* @__PURE__ */ ((VBUCKET2) => {
-  VBUCKET2[VBUCKET2["NIL"] = 0] = "NIL";
-  return VBUCKET2;
-})(VBUCKET || {});
-
-// src/buffers.ts
-var pool = new Array(64 /* POOL_SIZE */);
-var offset = -1;
-function allocateBuffer(size) {
-  if (size > 8192 /* BUFFER_SIZE */) {
-    const buffer2 = Buffer.allocUnsafeSlow(size);
-    buffer2.recycle = () => void 0;
-    return buffer2;
-  }
-  const buffer = offset >= 0 ? pool[offset--] : Buffer.allocUnsafeSlow(8192 /* BUFFER_SIZE */);
-  const recyclable = buffer.subarray(0, size);
-  let recycled = false;
-  recyclable.recycle = () => queueMicrotask(() => {
-    if (offset >= 64 /* POOL_SIZE */ || recycled)
-      return;
-    pool[++offset] = buffer;
-    recycled = true;
-  });
-  return recyclable;
-}
-
-// src/decode.ts
-import assert from "assert";
-var Decoder = class {
-  #consumer;
-  #header = Buffer.allocUnsafeSlow(24);
-  #body;
-  #pos = 0;
-  constructor(consumer) {
-    this.#consumer = consumer;
-  }
-  append(buffer, start, end) {
-    const header = this.#header;
-    while (start < end) {
-      if (this.#pos < 24) {
-        const copied = buffer.copy(header, this.#pos, start, end);
-        this.#pos += copied;
-        start += copied;
-      }
-      if (this.#pos < 24)
-        return;
-      let extras = EMPTY_BUFFER;
-      let key = EMPTY_BUFFER;
-      let value = EMPTY_BUFFER;
-      let recycle = () => void 0;
-      const bodyLength = header.readUInt32BE(8 /* BODY_LENGTH_$32 */);
-      if (bodyLength) {
-        const body = this.#body || (this.#body = allocateBuffer(bodyLength));
-        const copied = buffer.copy(body, this.#pos - 24, start, end);
-        this.#pos += copied;
-        start += copied;
-        if (this.#pos - 24 < body.length)
-          return;
-        const keyLength = header.readUInt16BE(2 /* KEY_LENGTH_$16 */);
-        const extrasLength = header.readUInt8(4 /* EXTRAS_LENGTH_$8 */);
-        const valueLength = bodyLength - keyLength - extrasLength;
-        key = keyLength ? body.subarray(extrasLength, extrasLength + keyLength) : EMPTY_BUFFER;
-        value = valueLength ? body.subarray(extrasLength + keyLength) : EMPTY_BUFFER;
-        extras = extrasLength ? body.subarray(0, extrasLength) : EMPTY_BUFFER;
-        recycle = () => void body.recycle();
-      }
-      const packet = {
-        opcode: header.readUInt8(1 /* OPCODE_$8 */),
-        status: header.readUInt16BE(6 /* STATUS_$16 */),
-        sequence: header.readUInt32BE(12 /* SEQUENCE_$32 */),
-        cas: header.readBigUInt64BE(16 /* CAS_$64 */),
-        extras,
-        key,
-        value,
-        recycle
-      };
-      const magic = header.readUInt8(0 /* MAGIC_$8 */);
-      const dataType = header.readUInt8(5 /* DATA_TYPE_$8 */);
-      assert.equal(magic, 129 /* RESPONSE */, "Invalid magic in header");
-      assert.equal(dataType, 0 /* RAW */, "Invalid data type in header");
-      this.#pos = 0;
-      this.#body = void 0;
-      this.#consumer(packet);
-    }
-  }
-};
-
-// src/encode.ts
-var encode_exports = {};
-__export(encode_exports, {
-  Encoder: () => Encoder
-});
-var CONSTANTS = /* @__PURE__ */ ((CONSTANTS2) => {
-  CONSTANTS2[CONSTANTS2["HEADER_SIZE"] = 24] = "HEADER_SIZE";
-  return CONSTANTS2;
-})(CONSTANTS || {});
-var Encoder = class {
-  encode(packet, seq = 0) {
-    const {
-      opcode,
-      sequence = seq,
-      cas = 0n,
-      extras = EMPTY_BUFFER,
-      extrasOffset = 0,
-      extrasLength = extras.length,
-      key = EMPTY_BUFFER,
-      keyOffset = 0,
-      keyLength = key.length,
-      value = EMPTY_BUFFER,
-      valueOffset = 0,
-      valueLength = value.length
-    } = packet;
-    const bodyLength = extrasLength + keyLength + valueLength;
-    const length = bodyLength + 24 /* HEADER_SIZE */;
-    const buffer = allocateBuffer(length);
-    buffer.writeUInt8(128 /* REQUEST */, 0 /* MAGIC_$8 */);
-    buffer.writeUInt8(opcode, 1 /* OPCODE_$8 */);
-    buffer.writeUInt16BE(keyLength, 2 /* KEY_LENGTH_$16 */);
-    buffer.writeUInt8(extrasLength, 4 /* EXTRAS_LENGTH_$8 */);
-    buffer.writeUInt8(0 /* RAW */, 5 /* DATA_TYPE_$8 */);
-    buffer.writeUInt16BE(0 /* NIL */, 6 /* STATUS_$16 */);
-    buffer.writeUInt32BE(bodyLength, 8 /* BODY_LENGTH_$32 */);
-    buffer.writeUInt32BE(sequence, 12 /* SEQUENCE_$32 */);
-    buffer.writeBigUInt64BE(cas, 16 /* CAS_$64 */);
-    let pos = 24;
-    if (extrasLength)
-      pos += extras.copy(buffer, pos, extrasOffset, extrasOffset + extrasLength);
-    if (keyLength)
-      pos += key.copy(buffer, pos, keyOffset, keyOffset + keyLength);
-    if (valueLength)
-      pos += value.copy(buffer, pos, valueOffset, valueOffset + valueLength);
-    return buffer;
-  }
-};
-
-// src/connection.ts
-var connection_exports = {};
-__export(connection_exports, {
-  Connection: () => Connection
-});
-
-// src/internals.ts
-import assert2 from "assert";
-import { types } from "util";
-var socketFinalizationRegistry = new FinalizationRegistry((socket) => {
-  if (!socket.destroyed)
-    socket.destroy();
-});
-function typedArrayFlags(value) {
-  const flags = types.isUint8Array(value) ? 3402235920 /* UINT8ARRAY */ : types.isUint8ClampedArray(value) ? 3402235921 /* UINT8CLAMPEDARRAY */ : types.isUint16Array(value) ? 3402235922 /* UINT16ARRAY */ : types.isUint32Array(value) ? 3402235923 /* UINT32ARRAY */ : types.isInt8Array(value) ? 3402235924 /* INT8ARRAY */ : types.isInt16Array(value) ? 3402235925 /* INT16ARRAY */ : types.isInt32Array(value) ? 3402235926 /* INT32ARRAY */ : types.isBigUint64Array(value) ? 3402235927 /* BIGUINT64ARRAY */ : types.isBigInt64Array(value) ? 3402235928 /* BIGINT64ARRAY */ : types.isFloat32Array(value) ? 3402235929 /* FLOAT32ARRAY */ : types.isFloat64Array(value) ? 3402235930 /* FLOAT64ARRAY */ : assert2.fail("Unsupported kind of TypedArray");
-  return flags;
-}
-function logPromiseError(promise, message) {
-  return promise.catch((error) => console.log(message, error)).then(() => void 0);
-}
-
-// src/connection.ts
-import assert3 from "assert";
-import net from "net";
-var Deferred = class {
-  #resolve;
-  #reject;
-  #packets = [];
-  promise;
-  opcode;
-  constructor(opcode) {
-    this.opcode = opcode;
-    this.promise = new Promise((resolve, reject) => {
-      this.#resolve = resolve;
-      this.#reject = reject;
-    });
-  }
-  append(packet) {
-    this.#packets.push(packet);
-  }
-  resolve(packet) {
-    this.#packets.push(packet);
-    this.#resolve(this.#packets);
-  }
-  reject(error) {
-    this.#reject(error);
-  }
-};
-var Connection = class {
-  #decoder = new Decoder((packet) => this.#receive(packet));
-  #encoder = new Encoder();
-  #buffer = Buffer.allocUnsafeSlow(8192 /* BUFFER_SIZE */);
-  #defers = /* @__PURE__ */ new Map();
-  #factory;
-  #socket;
-  #sequence = 0;
-  #timeout;
-  #host;
-  #port;
-  constructor(options) {
-    assert3(options, "No options specified");
-    const {
-      host,
-      port = 11211,
-      timeout = 1e3,
-      factory = net.connect
-    } = options;
-    this.#factory = factory;
-    assert3(host, "No host name specified");
-    assert3(port > 0 && port < 65536 && Math.floor(port) == port, `Invalid port ${port}`);
-    this.#timeout = timeout;
-    this.#host = host;
-    this.#port = port;
-  }
-  get connected() {
-    return !!this.#socket;
-  }
-  get host() {
-    return this.#host;
-  }
-  get port() {
-    return this.#port;
-  }
-  get timeout() {
-    return this.#timeout;
-  }
-  #connect() {
-    return this.#socket || (this.#socket = new Promise((resolve, reject) => {
-      const socket = this.#factory({
-        host: this.#host,
-        port: this.#port,
-        timeout: this.#timeout,
-        onread: {
-          buffer: this.#buffer,
-          callback: (bytes, buffer) => {
-            this.#decoder.append(buffer, 0, bytes);
-            return true;
-          }
-        }
-      });
-      socket.on("timeout", () => socket.destroy(new Error("Timeout")));
-      socket.on("error", reject);
-      socket.on("close", () => {
-        socketFinalizationRegistry.unregister(this);
-        this.#socket = void 0;
-      });
-      socket.on("connect", () => {
-        socketFinalizationRegistry.register(this, socket, this);
-        socket.off("error", reject);
-        socket.on("error", (error) => {
-          for (const deferred of this.#defers.values()) {
-            process.nextTick(() => deferred.reject(error));
-          }
-          this.#defers.clear();
-          this.#socket = void 0;
-        });
-        socket.unref();
-        resolve(socket);
-      });
-    }));
-  }
-  #receive(packet) {
-    const deferred = this.#defers.get(packet.sequence);
-    if (deferred) {
-      if (deferred.opcode === packet.opcode) {
-        if (packet.opcode === 16 /* STAT */ && packet.key.length !== 0) {
-          return deferred.append(packet);
-        }
-        return deferred.resolve(packet);
-      } else {
-        const sent = `0x${deferred.opcode.toString(16).padStart(2, "0")}`;
-        const received = `0x${packet.opcode.toString(16).padStart(2, "0")}`;
-        return deferred.reject(new Error(`Opcode mismatch (sent=${sent}, received=${received})`));
-      }
-    }
-  }
-  async send(packet) {
-    const sequence = ++this.#sequence;
-    const buffer = this.#encoder.encode(packet, sequence);
-    const deferred = new Deferred(packet.opcode);
-    this.#defers.set(sequence, deferred);
-    const socket = await this.#connect();
-    socket.write(buffer, (error) => {
-      buffer.recycle();
-      if (error)
-        return deferred.reject(error);
-    });
-    const timeout = setTimeout(() => deferred.reject(new Error("No response")), this.#timeout);
-    return deferred.promise.finally(() => {
-      clearTimeout(timeout);
-      this.#defers.delete(sequence);
-    });
-  }
-  async destroy() {
-    const socket = await this.#socket;
-    if (!socket)
-      return false;
-    return new Promise((resolve, reject) => {
-      socket.once("error", reject).once("close", resolve).destroy();
-    });
-  }
-};
-
-// src/server.ts
-var statsBigInt = [
-  "auth_cmds",
-  "auth_errors",
-  "bytes",
-  "bytes_read",
-  "bytes_written",
-  "cas_badval",
-  "cas_hits",
-  "cas_misses",
-  "cmd_flush",
-  "cmd_get",
-  "cmd_set",
-  "cmd_touch",
-  "conn_yields",
-  "crawler_items_checked",
-  "crawler_reclaimed",
-  "curr_items",
-  "decr_hits",
-  "decr_misses",
-  "delete_hits",
-  "delete_misses",
-  "direct_reclaims",
-  "evicted_active",
-  "evicted_unfetched",
-  "evictions",
-  "expired_unfetched",
-  "get_expired",
-  "get_flushed",
-  "get_hits",
-  "get_misses",
-  "hash_bytes",
-  "idle_kicks",
-  "incr_hits",
-  "incr_misses",
-  "limit_maxbytes",
-  "listen_disabled_num",
-  "log_watcher_sent",
-  "log_watcher_skipped",
-  "log_watchers",
-  "log_worker_dropped",
-  "log_worker_written",
-  "lru_crawler_running",
-  "lru_crawler_starts",
-  "lru_maintainer_juggles",
-  "lrutail_reflocked",
-  "malloc_fails",
-  "moves_to_cold",
-  "moves_to_warm",
-  "moves_within_lru",
-  "read_buf_bytes",
-  "read_buf_bytes_free",
-  "read_buf_count",
-  "read_buf_oom",
-  "reclaimed",
-  "rejected_connections",
-  "response_obj_bytes",
-  "response_obj_count",
-  "response_obj_oom",
-  "round_robin_fallback",
-  "slab_reassign_busy_deletes",
-  "slab_reassign_busy_items",
-  "slab_reassign_chunk_rescues",
-  "slab_reassign_evictions_nomem",
-  "slab_reassign_inline_reclaim",
-  "slab_reassign_rescues",
-  "slabs_moved",
-  "store_no_memory",
-  "store_too_large",
-  "time_in_listen_disabled_us",
-  "total_items",
-  "touch_hits",
-  "touch_misses",
-  "unexpected_napi_ids"
-];
-var statsNumber = [
-  "connection_structures",
-  "curr_connections",
-  "hash_power_level",
-  "max_connections",
-  "pid",
-  "pointer_size",
-  "reserved_fds",
-  "slab_global_page_pool",
-  "threads",
-  "time",
-  "total_connections",
-  "uptime"
-];
-var statsBoolean = ["accepting_conns", "hash_is_expanding", "slab_reassign_running"];
-var statsMicroseconds = ["rusage_system", "rusage_user"];
-function injectStats(key, value, stats) {
-  if (!key)
-    return stats;
-  if (statsBigInt.includes(key)) {
-    stats[key] = BigInt(value);
-  } else if (statsNumber.includes(key)) {
-    stats[key] = Number(value);
-  } else if (statsBoolean.includes(key)) {
-    stats[key] = !!Number(value);
-  } else if (statsMicroseconds.includes(key)) {
-    const splits = value.split(".");
-    stats[key] = BigInt(`${splits[0]}${splits[1].padEnd(6, "0")}`);
-  } else {
-    stats[key] = value;
-  }
-  return stats;
-}
-function fail(packet, key) {
-  const message = packet.value.toString("utf-8") || "Unknown Error";
-  const status = STATUS[packet.status] || `0x${packet.status.toString(16).padStart(4, "0")}`;
-  throw new Error(`${message} (status=${status}${key ? `, key=${key}` : ""})`);
-}
-var ServerAdapter = class {
-  #buffer = Buffer.alloc(251 /* KEY_TOO_BIG */ + 20);
-  #connection;
-  #ttl;
-  #id;
-  constructor(options) {
-    this.#connection = new Connection(options);
-    this.#ttl = options.ttl || 0;
-    this.#id = `${this.#connection.host}:${this.#connection.port}`;
-  }
-  get connected() {
-    return this.#connection.connected;
-  }
-  get host() {
-    return this.#connection.host;
-  }
-  get port() {
-    return this.#connection.port;
-  }
-  get timeout() {
-    return this.#connection.timeout;
-  }
-  get ttl() {
-    return this.#ttl;
-  }
-  get id() {
-    return this.#id;
-  }
-  #writeKey(key, offset2 = 0) {
-    const keyLength = this.#buffer.write(key, offset2, 251 /* KEY_TOO_BIG */, "utf-8");
-    if (keyLength > 250 /* KEY_SIZE */)
-      throw new Error(`Key too long (len=${keyLength})`);
-    return keyLength;
-  }
-  async #get(key, ttl) {
-    let keyOffset = 0;
-    if (ttl !== void 0)
-      keyOffset = this.#buffer.writeUInt32BE(ttl);
-    const keyLength = this.#writeKey(key, keyOffset);
-    const [response] = await this.#connection.send({
-      opcode: ttl ? 29 /* GAT */ : 0 /* GET */,
-      extras: this.#buffer,
-      extrasOffset: 0,
-      extrasLength: keyOffset,
-      key: this.#buffer,
-      keyOffset,
-      keyLength
-    });
-    switch (response.status) {
-      case 0 /* OK */:
-        return {
-          value: response.value,
-          flags: response.extras.readUInt32BE(),
-          cas: response.cas,
-          recycle: () => response.recycle()
-        };
-      case 1 /* KEY_NOT_FOUND */:
-        return;
-      default:
-        fail(response, key);
-    }
-  }
-  async get(key) {
-    return this.#get(key);
-  }
-  async gat(key, ttl) {
-    return this.#get(key, ttl || 2592e3);
-  }
-  async touch(key, ttl) {
-    const timeToLive = ttl ?? this.#ttl;
-    const keyOffset = this.#buffer.writeUInt32BE(timeToLive);
-    const keyLength = this.#writeKey(key, keyOffset);
-    const [response] = await this.#connection.send({
-      opcode: 28 /* TOUCH */,
-      extras: this.#buffer,
-      extrasOffset: 0,
-      extrasLength: keyOffset,
-      key: this.#buffer,
-      keyOffset,
-      keyLength
-    });
-    try {
-      switch (response.status) {
-        case 0 /* OK */:
-          return true;
-        case 1 /* KEY_NOT_FOUND */:
-          return false;
-        default:
-          fail(response, key);
-      }
-    } finally {
-      response.recycle();
-    }
-  }
-  async #sar(opcode, key, value, options) {
-    const { flags = 0, cas = 0n, ttl = this.#ttl } = options;
-    let keyOffset;
-    keyOffset = this.#buffer.writeUInt32BE(flags);
-    keyOffset = this.#buffer.writeUInt32BE(ttl, keyOffset);
-    const keyLength = this.#writeKey(key, keyOffset);
-    const [response] = await this.#connection.send({
-      opcode,
-      cas,
-      extras: this.#buffer,
-      extrasOffset: 0,
-      extrasLength: keyOffset,
-      key: this.#buffer,
-      keyOffset,
-      keyLength,
-      value
-    });
-    try {
-      switch (response.status) {
-        case 0 /* OK */:
-          return response.cas;
-        case 1 /* KEY_NOT_FOUND */:
-        case 2 /* KEY_EXISTS */:
-          return;
-        default:
-          fail(response, key);
-      }
-    } finally {
-      response.recycle();
-    }
-  }
-  set(key, value, options = {}) {
-    return this.#sar(1 /* SET */, key, value, options);
-  }
-  add(key, value, options = {}) {
-    return this.#sar(2 /* ADD */, key, value, options);
-  }
-  replace(key, value, options = {}) {
-    return this.#sar(3 /* REPLACE */, key, value, options);
-  }
-  async #pend(opcode, key, value, options) {
-    const { cas = 0n } = options;
-    const keyLength = this.#writeKey(key);
-    const [response] = await this.#connection.send({
-      opcode,
-      cas,
-      key: Buffer.from(key, "utf-8"),
-      keyOffset: 0,
-      keyLength,
-      value
-    });
-    try {
-      switch (response.status) {
-        case 0 /* OK */:
-          return true;
-        case 5 /* ITEM_NOT_STORED */:
-        case 2 /* KEY_EXISTS */:
-          return false;
-        default:
-          fail(response, key);
-      }
-    } finally {
-      response.recycle();
-    }
-  }
-  append(key, value, options = {}) {
-    return this.#pend(14 /* APPEND */, key, value, options);
-  }
-  prepend(key, value, options = {}) {
-    return this.#pend(15 /* PREPEND */, key, value, options);
-  }
-  async #counter(opcode, key, delta, options) {
-    const {
-      initial,
-      cas = 0n,
-      ttl = this.#ttl
-    } = options;
-    let keyOffset;
-    keyOffset = this.#buffer.writeBigUInt64BE(BigInt(delta));
-    keyOffset = this.#buffer.writeBigUInt64BE(BigInt(initial || 0n), keyOffset);
-    keyOffset = this.#buffer.writeUInt32BE(initial == void 0 ? 4294967295 : ttl, keyOffset);
-    const keyLength = this.#writeKey(key, keyOffset);
-    const [response] = await this.#connection.send({
-      opcode,
-      extras: this.#buffer,
-      extrasOffset: 0,
-      extrasLength: keyOffset,
-      key: this.#buffer,
-      keyOffset,
-      keyLength,
-      cas
-    });
-    try {
-      switch (response.status) {
-        case 0 /* OK */:
-          return {
-            value: response.value.readBigUInt64BE(0),
-            cas: response.cas
-          };
-        case 1 /* KEY_NOT_FOUND */:
-        case 2 /* KEY_EXISTS */:
-          return;
-        default:
-          fail(response, key);
-      }
-    } finally {
-      response.recycle();
-    }
-  }
-  increment(key, delta = 1, options = {}) {
-    return this.#counter(5 /* INCREMENT */, key, delta, options);
-  }
-  decrement(key, delta = 1, options = {}) {
-    return this.#counter(6 /* DECREMENT */, key, delta, options);
-  }
-  async delete(key, options = {}) {
-    const { cas = 0n } = options;
-    const keyLength = this.#writeKey(key);
-    const [response] = await this.#connection.send({
-      opcode: 4 /* DELETE */,
-      key: this.#buffer,
-      keyOffset: 0,
-      keyLength,
-      cas
-    });
-    try {
-      switch (response.status) {
-        case 0 /* OK */:
-          return true;
-        case 1 /* KEY_NOT_FOUND */:
-        case 2 /* KEY_EXISTS */:
-          return false;
-        default:
-          fail(response, key);
-      }
-    } finally {
-      response.recycle();
-    }
-  }
-  async flush(ttl = 0) {
-    const extrasLength = ttl ? this.#buffer.writeUInt32BE(ttl) : 0;
-    const [response] = await this.#connection.send({
-      opcode: 8 /* FLUSH */,
-      extras: this.#buffer,
-      extrasOffset: 0,
-      extrasLength
-    });
-    try {
-      switch (response.status) {
-        case 0 /* OK */:
-          return;
-        default:
-          fail(response);
-      }
-    } finally {
-      response.recycle();
-    }
-  }
-  async noop() {
-    const [response] = await this.#connection.send({
-      opcode: 10 /* NOOP */
-    });
-    try {
-      switch (response.status) {
-        case 0 /* OK */:
-          return;
-        default:
-          fail(response);
-      }
-    } finally {
-      response.recycle();
-    }
-  }
-  async quit() {
-    const [response] = await this.#connection.send({
-      opcode: 7 /* QUIT */
-    });
-    try {
-      switch (response.status) {
-        case 0 /* OK */:
-          return;
-        default:
-          fail(response);
-      }
-    } finally {
-      response.recycle();
-    }
-  }
-  async version() {
-    const [response] = await this.#connection.send({
-      opcode: 11 /* VERSION */
-    });
-    try {
-      switch (response.status) {
-        case 0 /* OK */:
-          return { [this.#id]: response.value.toString("utf-8") };
-        default:
-          fail(response);
-      }
-    } finally {
-      response.recycle();
-    }
-  }
-  async stats() {
-    const responses = await this.#connection.send({
-      opcode: 16 /* STAT */
-    });
-    const stats = responses.reduce((result, packet) => {
-      try {
-        if (packet.status !== 0 /* OK */)
-          fail(packet);
-        const key = packet.key.toString("utf-8");
-        const value = packet.value.toString("utf-8");
-        return injectStats(key, value, result);
-      } finally {
-        packet.recycle();
-      }
-    }, {});
-    return { [this.#id]: stats };
-  }
-};
-
-// src/cluster.ts
-import assert4 from "assert";
-function parseHosts(hosts) {
-  const result = [];
-  if (!hosts)
-    return result;
-  for (const part of hosts.split(",")) {
-    const [host, p] = part.split(":");
-    const port = parseInt(p) || void 0;
-    result.push({ host, port });
-  }
-  return result;
-}
-var ClusterAdapter = class {
-  servers;
-  ttl;
-  constructor(serversOrOptions) {
-    if (Array.isArray(serversOrOptions)) {
-      this.servers = [...serversOrOptions];
-    } else if (serversOrOptions) {
-      const { ttl, timeout, hosts: defs } = serversOrOptions;
-      const hosts = [];
-      if (Array.isArray(defs)) {
-        defs.forEach((def) => {
-          if (typeof def === "string")
-            hosts.push(...parseHosts(def));
-          else
-            hosts.push(__spreadValues({ port: 11211 }, def));
-        });
-      } else {
-        hosts.push(...parseHosts(defs));
-      }
-      this.servers = hosts.map((host) => new ServerAdapter(__spreadValues({ ttl, timeout }, host)));
-    } else {
-      const hosts = parseHosts(process.env.MEMCACHED_HOSTS);
-      const ttl = process.env.MEMCACHED_TTL && parseInt(process.env.MEMCACHED_TTL) || void 0;
-      const timeout = process.env.MEMCACHED_TIMEOUT && parseInt(process.env.MEMCACHED_TIMEOUT) || void 0;
-      this.servers = hosts.map((host) => new ServerAdapter(__spreadValues({ ttl, timeout }, host)));
-    }
-    if (this.servers.length < 1)
-      throw new Error("No hosts configured");
-    if (this.servers.length === 1)
-      this.server = () => this.servers[0];
-    this.ttl = this.servers[0].ttl;
-    this.servers.slice(1).forEach((server) => {
-      assert4.equal(server.ttl, this.ttl, `TTL Mismatch (${server.ttl} != ${this.ttl})`);
-    });
-    Object.freeze(this.servers);
-  }
-  server(key) {
-    const length = key.length;
-    let hash = 0;
-    for (let i = 0; i < length; i++)
-      hash = hash * 31 + key.charCodeAt(i);
-    return this.servers[hash % this.servers.length];
-  }
-  get(key) {
-    return this.server(key).get(key);
-  }
-  gat(key, ttl) {
-    return this.server(key).gat(key, ttl);
-  }
-  touch(key, ttl) {
-    return this.server(key).touch(key, ttl);
-  }
-  set(key, value, options) {
-    return this.server(key).set(key, value, options);
-  }
-  add(key, value, options) {
-    return this.server(key).add(key, value, options);
-  }
-  replace(key, value, options) {
-    return this.server(key).replace(key, value, options);
-  }
-  append(key, value, options) {
-    return this.server(key).append(key, value, options);
-  }
-  prepend(key, value, options) {
-    return this.server(key).prepend(key, value, options);
-  }
-  increment(key, delta, options) {
-    return this.server(key).increment(key, delta, options);
-  }
-  decrement(key, delta, options) {
-    return this.server(key).decrement(key, delta, options);
-  }
-  delete(key, options) {
-    return this.server(key).delete(key, options);
-  }
-  async flush(ttl) {
-    await Promise.all(this.servers.map((server) => server.flush(ttl)));
-  }
-  async noop() {
-    await Promise.all(this.servers.map((server) => server.noop()));
-  }
-  async quit() {
-    await Promise.all(this.servers.map((server) => server.quit()));
-  }
-  async version() {
-    const versions = await Promise.all(this.servers.map((server) => server.version()));
-    return versions.reduce((v1, v2) => __spreadValues(__spreadValues({}, v1), v2));
-  }
-  async stats() {
-    const stats = await Promise.all(this.servers.map((server) => server.stats()));
-    return stats.reduce((v1, v2) => __spreadValues(__spreadValues({}, v1), v2));
-  }
-};
-
-// src/client.ts
-import assert5 from "assert";
-import { types as types2 } from "util";
-function replacer(key, value) {
-  if (typeof this[key] === "bigint")
-    return ["\0__$BIGINT$__\0", this[key].toString()];
-  if (this[key] instanceof Date)
-    return ["\0__$DATE$__\0", this[key].toISOString()];
-  if (this[key] instanceof Set)
-    return ["\0__$SET$__\0", ...value];
-  if (this[key] instanceof Map)
-    return ["\0__$MAP$__\0", ...value.entries()];
-  return value;
-}
-function reviver(key, value) {
-  if (Array.isArray(value)) {
-    switch (value[0]) {
-      case "\0__$BIGINT$__\0":
-        return BigInt(value[1]);
-      case "\0__$DATE$__\0":
-        return new Date(value[1]);
-      case "\0__$SET$__\0":
-        return new Set(value.slice(1));
-      case "\0__$MAP$__\0":
-        return new Map(value.slice(1));
-    }
-  }
-  return value;
-}
-function toBuffer(value, options) {
-  if (Buffer.isBuffer(value))
-    return [value, __spreadProps(__spreadValues({}, options), { flags: 0 /* BUFFER */ })];
-  switch (typeof value) {
-    case "bigint":
-      return [Buffer.from(value.toString(), "utf-8"), __spreadProps(__spreadValues({}, options), { flags: 3402235904 /* BIGINT */ })];
-    case "boolean":
-      return [Buffer.alloc(1, value ? 255 : 0), __spreadProps(__spreadValues({}, options), { flags: 3402235905 /* BOOLEAN */ })];
-    case "number":
-      return [Buffer.from(value.toString(), "utf-8"), __spreadProps(__spreadValues({}, options), { flags: 3402235906 /* NUMBER */ })];
-    case "string":
-      return [Buffer.from(value, "utf-8"), __spreadProps(__spreadValues({}, options), { flags: 3402235907 /* STRING */ })];
-    case "object":
-      break;
-    default:
-      assert5.fail(`Unable to store value of type "${typeof value}"`);
-  }
-  if (types2.isTypedArray(value)) {
-    const flags = typedArrayFlags(value);
-    const buffer = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
-    return [buffer, __spreadProps(__spreadValues({}, options), { flags })];
-  }
-  if (value === null)
-    return [EMPTY_BUFFER, __spreadProps(__spreadValues({}, options), { flags: 3402235918 /* NULL */ })];
-  const json = JSON.stringify(value, replacer);
-  return [Buffer.from(json, "utf-8"), __spreadProps(__spreadValues({}, options), { flags: 3402235919 /* JSON */ })];
-}
-function fromBuffer(result) {
-  try {
-    const { flags, value, cas } = result;
-    switch (flags) {
-      case 3402235904 /* BIGINT */:
-        return { value: BigInt(value.toString("utf-8")), cas };
-      case 3402235905 /* BOOLEAN */:
-        return { value: !!value[0], cas };
-      case 3402235906 /* NUMBER */:
-        return { value: Number(value.toString("utf-8")), cas };
-      case 3402235907 /* STRING */:
-        return { value: value.toString("utf-8"), cas };
-      case 3402235918 /* NULL */:
-        return { value: null, cas };
-      case 3402235919 /* JSON */:
-        return { value: JSON.parse(value.toString("utf-8"), reviver), cas };
-      case 3402235920 /* UINT8ARRAY */:
-        return { value: makeTypedArray(Uint8Array, value), cas };
-      case 3402235921 /* UINT8CLAMPEDARRAY */:
-        return { value: makeTypedArray(Uint8ClampedArray, value), cas };
-      case 3402235922 /* UINT16ARRAY */:
-        return { value: makeTypedArray(Uint16Array, value), cas };
-      case 3402235923 /* UINT32ARRAY */:
-        return { value: makeTypedArray(Uint32Array, value), cas };
-      case 3402235924 /* INT8ARRAY */:
-        return { value: makeTypedArray(Int8Array, value), cas };
-      case 3402235925 /* INT16ARRAY */:
-        return { value: makeTypedArray(Int16Array, value), cas };
-      case 3402235926 /* INT32ARRAY */:
-        return { value: makeTypedArray(Int32Array, value), cas };
-      case 3402235927 /* BIGUINT64ARRAY */:
-        return { value: makeTypedArray(BigUint64Array, value), cas };
-      case 3402235928 /* BIGINT64ARRAY */:
-        return { value: makeTypedArray(BigInt64Array, value), cas };
-      case 3402235929 /* FLOAT32ARRAY */:
-        return { value: makeTypedArray(Float32Array, value), cas };
-      case 3402235930 /* FLOAT64ARRAY */:
-        return { value: makeTypedArray(Float64Array, value), cas };
-      case 0 /* BUFFER */:
-      default:
-        return { value: Buffer.from(value), cas };
-    }
-  } finally {
-    result.recycle();
-  }
-}
-function makeTypedArray(constructor, source) {
-  const clone = Buffer.from(source);
-  const { buffer, byteOffset, byteLength } = clone;
-  return new constructor(buffer, byteOffset, byteLength / constructor.BYTES_PER_ELEMENT);
-}
-var MemxClient = class {
-  #adapter;
-  #prefix;
-  constructor(adapterOrOptions) {
-    if (!adapterOrOptions) {
-      this.#adapter = new ClusterAdapter();
-    } else if ("get" in adapterOrOptions) {
-      this.#adapter = adapterOrOptions;
-    } else if ("hosts" in adapterOrOptions) {
-      this.#adapter = new ClusterAdapter(adapterOrOptions);
-    }
-    this.#prefix = "";
-    assert5(this.#adapter, "Invalid client constructor arguments");
-  }
-  get adapter() {
-    return this.#adapter;
-  }
-  get prefix() {
-    return this.#prefix;
-  }
-  withPrefix(prefix) {
-    assert5(prefix, "Invalid prefix");
-    const client = new MemxClient(this.#adapter);
-    client.#prefix = prefix;
-    return client;
-  }
-  async get(key) {
-    const result = await this.#adapter.get(this.#prefix + key);
-    return result && fromBuffer(result).value;
-  }
-  async gat(key, ttl) {
-    const result = await this.#adapter.gat(this.#prefix + key, ttl);
-    return result && fromBuffer(result).value;
-  }
-  async getc(key) {
-    const result = await this.#adapter.get(this.#prefix + key);
-    return result && fromBuffer(result);
-  }
-  async gatc(key, ttl) {
-    const result = await this.#adapter.gat(this.#prefix + key, ttl);
-    return result && fromBuffer(result);
-  }
-  async set(key, value, options) {
-    return this.#adapter.set(this.#prefix + key, ...toBuffer(value, options));
-  }
-  async add(key, value, options) {
-    return this.#adapter.add(this.#prefix + key, ...toBuffer(value, options));
-  }
-  async replace(key, value, options) {
-    return this.#adapter.replace(this.#prefix + key, ...toBuffer(value, options));
-  }
-  append(key, value, options) {
-    return this.#adapter.append(this.#prefix + key, ...toBuffer(value, options));
-  }
-  prepend(key, value, options) {
-    return this.#adapter.prepend(this.#prefix + key, ...toBuffer(value, options));
-  }
-  async increment(key, delta, options) {
-    const counter = await this.#adapter.increment(this.#prefix + key, delta, options);
-    if ((options == null ? void 0 : options.initial) !== void 0 && (counter == null ? void 0 : counter.value) === BigInt(options.initial)) {
-      const cas = await this.replace(key, counter.value, { cas: counter.cas, ttl: options.ttl });
-      counter.cas = cas ?? counter.cas;
-    }
-    return counter;
-  }
-  async decrement(key, delta, options) {
-    const counter = await this.#adapter.decrement(this.#prefix + key, delta, options);
-    if ((options == null ? void 0 : options.initial) !== void 0 && (counter == null ? void 0 : counter.value) === BigInt(options.initial)) {
-      const cas = await this.replace(key, counter.value, { cas: counter.cas, ttl: options.ttl });
-      counter.cas = cas ?? counter.cas;
-    }
-    return counter;
-  }
-  touch(key, ttl) {
-    return this.#adapter.touch(this.#prefix + key, ttl);
-  }
-  delete(key, options) {
-    return this.#adapter.delete(this.#prefix + key, options);
-  }
-  flush(ttl) {
-    return this.#adapter.flush(ttl);
-  }
-  noop() {
-    return this.#adapter.noop();
-  }
-  quit() {
-    return this.#adapter.quit();
-  }
-  version() {
-    return this.#adapter.version();
-  }
-  stats() {
-    return this.#adapter.stats();
-  }
-};
-
-// src/fake.ts
-function toExp(ttl = 0) {
-  if (ttl === 0)
-    return Number.MAX_SAFE_INTEGER;
-  return Date.now() + ttl * 1e3;
-}
-var FakeAdapter = class {
-  #cache = /* @__PURE__ */ new Map();
-  #cas = 1n;
-  ttl = 0;
-  #get(key) {
-    if (key.length > 250)
-      throw new TypeError(`Key too long (len=${key.length})`);
-    const entry = this.#cache.get(key);
-    if (!entry)
-      return;
-    if (Date.now() > entry.exp) {
-      this.#cache.delete(key);
-      return;
-    }
-    return entry;
-  }
-  #set(key, value, flags, ttl) {
-    this.#cache.set(key, {
-      value,
-      flags: flags || 0,
-      cas: ++this.#cas,
-      exp: toExp(ttl)
-    });
-    return this.#cas;
-  }
-  async get(key) {
-    const entry = this.#get(key);
-    if (!entry)
-      return;
-    return {
-      value: entry.value,
-      flags: entry.flags,
-      cas: entry.cas,
-      recycle: () => void 0
-    };
-  }
-  async gat(key, ttl) {
-    const entry = this.#get(key);
-    if (!entry)
-      return;
-    entry.exp = toExp(ttl);
-    return {
-      value: entry.value,
-      flags: entry.flags,
-      cas: entry.cas,
-      recycle: () => void 0
-    };
-  }
-  async touch(key, ttl) {
-    const entry = this.#get(key);
-    if (entry)
-      entry.exp = toExp(ttl);
-    return !!entry;
-  }
-  async set(key, value, options = {}) {
-    const entry = this.#get(key);
-    if (entry && options.cas !== void 0 && entry.cas !== options.cas) {
-      return;
-    }
-    return this.#set(key, value, options.flags, options.ttl);
-  }
-  async add(key, value, options = {}) {
-    if (this.#get(key))
-      return;
-    return this.#set(key, value, options.flags, options.ttl);
-  }
-  async replace(key, value, options = {}) {
-    if (!this.#get(key))
-      return;
-    return this.#set(key, value, options.flags, options.ttl);
-  }
-  async append(key, value, options = {}) {
-    const entry = this.#get(key);
-    if (!entry)
-      return false;
-    if (options.cas !== void 0 && options.cas !== entry.cas)
-      return false;
-    entry.value = Buffer.concat([entry.value, value]);
-    return true;
-  }
-  async prepend(key, value, options = {}) {
-    const entry = this.#get(key);
-    if (!entry)
-      return false;
-    if (options.cas !== void 0 && options.cas !== entry.cas)
-      return false;
-    entry.value = Buffer.concat([value, entry.value]);
-    return true;
-  }
-  async #counter(key, delta, options) {
-    const entry = this.#get(key);
-    if (!entry) {
-      if (options.initial !== void 0) {
-        const value = Buffer.from(options.initial.toString());
-        this.#set(key, value, void 0, options.ttl);
-        return { value: BigInt(options.initial), cas: this.#cas };
-      } else {
-        return;
-      }
-    }
-    if (options.cas !== void 0 && options.cas !== entry.cas)
-      return;
-    try {
-      const value = BigInt(entry.value.toString("utf-8")) + BigInt(delta);
-      this.#set(key, Buffer.from(value.toString()), void 0, options.ttl);
-      return { value, cas: this.#cas };
-    } catch (error) {
-      throw new TypeError(`${error.message} (status=NON_NUMERIC_VALUE, key=${key})`);
-    }
-  }
-  increment(key, delta = 1n, options = {}) {
-    return this.#counter(key, delta, options);
-  }
-  decrement(key, delta = 1n, options = {}) {
-    return this.#counter(key, -delta, options);
-  }
-  async delete(key, options = {}) {
-    const entry = this.#get(key);
-    if (entry && options.cas !== void 0 && entry.cas !== options.cas) {
-      return false;
-    }
-    return this.#cache.delete(key);
-  }
-  async flush(ttl) {
-    if (!ttl)
-      return this.#cache.clear();
-    const wait = toExp(ttl) - Date.now();
-    setTimeout(() => this.#cache.clear(), wait);
-  }
-  async noop() {
-  }
-  async quit() {
-  }
-  async version() {
-    return { fake: "0.0.0-fake" };
-  }
-  async stats() {
-    return { fake: { version: "0.0.0-fake" } };
-  }
-};
-var MemxFakeClient = class extends MemxClient {
-  constructor() {
-    super(new FakeAdapter());
-  }
-};
-
-// src/utils.ts
-import assert6 from "assert";
-var Factory = class {
-  #factory;
-  #client;
-  #ttl;
-  constructor(client, factory, ttl) {
-    assert6(typeof factory === "function", "Invalid or no factory specified");
-    assert6(client, "No client specified");
-    this.#factory = factory;
-    this.#client = client;
-    this.#ttl = ttl;
-  }
-  async get(key) {
-    const cached = await this.#client.getc(key);
-    if (cached) {
-      void logPromiseError(this.#client.touch(key), `Factory error touching key "${this.#client.prefix}${key}"`);
-      return cached.value;
-    }
-    const created = await this.#factory(key);
-    if (created) {
-      void logPromiseError(this.#client.set(key, created, { ttl: this.#ttl }), `Factory error setting key "${this.#client.prefix}${key}"`);
-    }
-    return created;
-  }
-};
-var Bundle = class {
-  #client;
-  #name;
-  #ttl;
-  constructor(client, name, ttl) {
-    assert6(client, "No client specified");
-    assert6(name, "No bundle name specified");
-    this.#client = client;
-    this.#name = name;
-    this.#ttl = ttl || 0;
-  }
-  async #appendKey(key) {
-    await logPromiseError((async () => {
-      const added = await this.#client.add(this.#name, key, { ttl: this.#ttl });
-      if (!added) {
-        await this.#client.append(this.#name, `\0${key}`);
-        await this.#client.touch(this.#name, this.#ttl);
-      }
-    })(), `Bundle "${this.#client.prefix}${this.#name}" error recording key "${key}"`);
-  }
-  async #removeKey(key) {
-    await logPromiseError((async () => {
-      const result = await this.#client.getc(this.#name);
-      if (!result)
-        return;
-      const keys = result.value.split("\0").filter((k) => k !== key).join("\0");
-      await this.#client.set(this.#name, keys, { cas: result.cas, ttl: this.#ttl });
-    })(), `Bundle "${this.#client.prefix}${this.#name}" error clearing key "${key}"`);
-  }
-  async add(key, value) {
-    await this.#client.set(`${this.#name}:${key}`, value, { ttl: this.#ttl });
-    await this.#appendKey(key);
-  }
-  async get(key) {
-    const result = await this.#client.getc(`${this.#name}:${key}`);
-    if (result)
-      return result.value;
-    await this.#removeKey(key);
-  }
-  async delete(key) {
-    await this.#client.delete(`${this.#name}:${key}`);
-    await this.#removeKey(key);
-  }
-  async list() {
-    const result = await this.#client.getc(this.#name);
-    if (!result)
-      return {};
-    const results = {};
-    const promises = [];
-    for (const key of new Set(result.value.split("\0"))) {
-      promises.push(this.#client.getc(`${this.#name}:${key}`).then((result2) => {
-        if (result2)
-          results[key] = result2.value;
-      }));
-    }
-    await Promise.all(promises);
-    await logPromiseError(this.#client.set(this.#name, Object.keys(results).join("\0"), { cas: result.cas, ttl: this.#ttl }), `Bundle "${this.#client.prefix}${this.#name}" error compacting keys`);
-    return results;
-  }
-};
-var PoorManLock = class {
-  #client;
-  #name;
-  constructor(client, name) {
-    assert6(client, "No client specified");
-    assert6(name, "No lock name specified");
-    this.#client = client;
-    this.#name = name;
-  }
-  async execute(executor, options) {
-    const { timeout = 5e3, owner = false } = options || {};
-    const end = Date.now() + timeout;
-    let cas;
-    do {
-      cas = await this.#client.add(this.#name, owner, { ttl: 2 });
-      if (cas !== void 0)
-        break;
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    } while (Date.now() < end);
-    if (cas === void 0) {
-      const other = await this.#client.getc(this.#name);
-      const owner2 = other && other.value ? `"${other.value}"` : "anonymous";
-      throw new Error(`Lock "${this.#client.prefix}${this.#name}" timeout (owner=${owner2})`);
-    }
-    const interval = setInterval(() => {
-      void logPromiseError((async () => {
-        const replaced = await this.#client.replace(this.#name, owner, { ttl: 2, cas });
-        assert6(replaced !== void 0, `Lock "${this.#client.prefix}${this.#name}" not replaced`);
-        cas = replaced;
-      })(), `Error extending lock "${this.#client.prefix}${this.#name}"`);
-    }, 100);
-    try {
-      return await executor();
-    } finally {
-      clearInterval(interval);
-      await logPromiseError(this.#client.delete(this.#name, { cas }), `Error deleting lock "${this.#client.prefix}${this.#name}"`);
-    }
-  }
-};
+// index.ts
+import * as decode from "./decode.mjs";
+import * as encode from "./encode.mjs";
+import * as constants from "./constants.mjs";
+import * as connection from "./connection.mjs";
+export * from "./fake.mjs";
+export * from "./types.mjs";
+export * from "./cluster.mjs";
+export * from "./server.mjs";
+export * from "./client.mjs";
+export * from "./utils.mjs";
 export {
-  Bundle,
-  ClusterAdapter,
-  Factory,
-  FakeAdapter,
-  MemxClient,
-  MemxFakeClient,
-  PoorManLock,
-  ServerAdapter,
-  connection_exports as connection,
-  constants_exports as constants,
-  decode_exports as decode,
-  encode_exports as encode
+  connection,
+  constants,
+  decode,
+  encode
 };
 //# sourceMappingURL=index.mjs.map