memx 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1124 @@
+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 {
+  isUint8Array,
+  isUint8ClampedArray,
+  isUint16Array,
+  isUint32Array,
+  isInt8Array,
+  isInt16Array,
+  isInt32Array,
+  isBigUint64Array,
+  isBigInt64Array,
+  isFloat32Array,
+  isFloat64Array
+} from "util/types";
+var socketFinalizationRegistry = new FinalizationRegistry((socket) => {
+  if (!socket.destroyed)
+    socket.destroy();
+});
+function typedArrayFlags(value) {
+  const flags = isUint8Array(value) ? 3402235920 /* UINT8ARRAY */ : isUint8ClampedArray(value) ? 3402235921 /* UINT8CLAMPEDARRAY */ : isUint16Array(value) ? 3402235922 /* UINT16ARRAY */ : isUint32Array(value) ? 3402235923 /* UINT32ARRAY */ : isInt8Array(value) ? 3402235924 /* INT8ARRAY */ : isInt16Array(value) ? 3402235925 /* INT16ARRAY */ : isInt32Array(value) ? 3402235926 /* INT32ARRAY */ : isBigUint64Array(value) ? 3402235927 /* BIGUINT64ARRAY */ : isBigInt64Array(value) ? 3402235928 /* BIGINT64ARRAY */ : isFloat32Array(value) ? 3402235929 /* FLOAT32ARRAY */ : isFloat64Array(value) ? 3402235930 /* FLOAT64ARRAY */ : assert2.fail("Unsupported kind of TypedArray");
+  return flags;
+}
+
+// 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, options = {}) {
+    const { ttl } = options;
+    let keyOffset = 0;
+    if (ttl)
+      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 touch(key, options = {}) {
+    const { ttl = this.#ttl } = options;
+    const keyOffset = this.#buffer.writeUInt32BE(ttl);
+    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
+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;
+  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];
+    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, options) {
+    return this.server(key).get(key, options);
+  }
+  touch(key, options) {
+    return this.server(key).touch(key, options);
+  }
+  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 assert4 from "assert";
+import { isTypedArray } from "util/types";
+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:
+      assert4.fail(`Unable to store value of type "${typeof value}"`);
+  }
+  if (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 */ })];
+  return [Buffer.from(JSON.stringify(value), "utf-8"), __spreadProps(__spreadValues({}, options), { flags: 3402235919 /* JSON */ })];
+}
+function makeTypedArray(constructor, source, bytesPerValue) {
+  const clone = Buffer.from(source);
+  const { buffer, byteOffset, byteLength } = clone;
+  return new constructor(buffer, byteOffset, byteLength / bytesPerValue);
+}
+var Client = class {
+  #adapter;
+  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);
+    }
+    assert4(this.#adapter, "Invalid client constructor arguments");
+  }
+  get adapter() {
+    return this.#adapter;
+  }
+  async get(key, options) {
+    const result = await this.#adapter.get(key, options);
+    if (!result)
+      return;
+    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")), cas };
+        case 3402235920 /* UINT8ARRAY */:
+          return { value: makeTypedArray(Uint8Array, value, 1), cas };
+        case 3402235921 /* UINT8CLAMPEDARRAY */:
+          return { value: makeTypedArray(Uint8ClampedArray, value, 1), cas };
+        case 3402235922 /* UINT16ARRAY */:
+          return { value: makeTypedArray(Uint16Array, value, 2), cas };
+        case 3402235923 /* UINT32ARRAY */:
+          return { value: makeTypedArray(Uint32Array, value, 4), cas };
+        case 3402235924 /* INT8ARRAY */:
+          return { value: makeTypedArray(Int8Array, value, 1), cas };
+        case 3402235925 /* INT16ARRAY */:
+          return { value: makeTypedArray(Int16Array, value, 2), cas };
+        case 3402235926 /* INT32ARRAY */:
+          return { value: makeTypedArray(Int32Array, value, 4), cas };
+        case 3402235927 /* BIGUINT64ARRAY */:
+          return { value: makeTypedArray(BigUint64Array, value, 8), cas };
+        case 3402235928 /* BIGINT64ARRAY */:
+          return { value: makeTypedArray(BigInt64Array, value, 8), cas };
+        case 3402235929 /* FLOAT32ARRAY */:
+          return { value: makeTypedArray(Float32Array, value, 4), cas };
+        case 3402235930 /* FLOAT64ARRAY */:
+          return { value: makeTypedArray(Float64Array, value, 8), cas };
+        case 0 /* BUFFER */:
+        default:
+          return { value: Buffer.from(value), cas };
+      }
+    } finally {
+      result.recycle();
+    }
+  }
+  async set(key, value, options) {
+    return this.#adapter.set(key, ...toBuffer(value, options));
+  }
+  async add(key, value, options) {
+    return this.#adapter.add(key, ...toBuffer(value, options));
+  }
+  async replace(key, value, options) {
+    return this.#adapter.replace(key, ...toBuffer(value, options));
+  }
+  append(key, value, options) {
+    return this.#adapter.append(key, ...toBuffer(value, options));
+  }
+  prepend(key, value, options) {
+    return this.#adapter.prepend(key, ...toBuffer(value, options));
+  }
+  async increment(key, delta, options) {
+    const counter = await this.#adapter.increment(key, delta, options);
+    if (counter && options && options.initial !== 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(key, delta, options);
+    if (counter && options && options.initial !== 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, options) {
+    return this.#adapter.touch(key, options);
+  }
+  delete(key, options) {
+    return this.#adapter.delete(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();
+  }
+};
+export {
+  Client,
+  ClusterAdapter,
+  ServerAdapter,
+  connection_exports as connection,
+  constants_exports as constants,
+  decode_exports as decode,
+  encode_exports as encode
+};
+//# sourceMappingURL=index.mjs.map