memx 0.0.7 → 0.1.1

package/dist/buffers.cjs

@@ -0,0 +1,50 @@
+"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);
+
+// buffers.ts
+var buffers_exports = {};
+__export(buffers_exports, {
+  allocateBuffer: () => allocateBuffer
+});
+module.exports = __toCommonJS(buffers_exports);
+var import_constants = require("./constants.cjs");
+var pool = new Array(import_constants.BUFFERS.POOL_SIZE);
+var offset = -1;
+function allocateBuffer(size) {
+  if (size > import_constants.BUFFERS.BUFFER_SIZE) {
+    const buffer2 = Buffer.allocUnsafeSlow(size);
+    buffer2.recycle = () => void 0;
+    return buffer2;
+  }
+  const buffer = offset >= 0 ? pool[offset--] : Buffer.allocUnsafeSlow(import_constants.BUFFERS.BUFFER_SIZE);
+  const recyclable = buffer.subarray(0, size);
+  let recycled = false;
+  recyclable.recycle = () => queueMicrotask(() => {
+    if (offset >= import_constants.BUFFERS.POOL_SIZE || recycled)
+      return;
+    pool[++offset] = buffer;
+    recycled = true;
+  });
+  return recyclable;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  allocateBuffer
+});
+//# sourceMappingURL=buffers.cjs.map

package/dist/buffers.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../src/buffers.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAAwB;AAExB,IAAM,OAAiB,IAAI,MAAM,yBAAQ,SAAS;AAClD,IAAI,SAAS;AAeN,SAAS,eAAe,MAAgC;AAC7D,MAAI,OAAO,yBAAQ,aAAa;AAC9B,UAAMA,UAAS,OAAO,gBAAgB,IAAI;AAC1C,IAAAA,QAAO,UAAU,MAAM;AACvB,WAAOA;AAAA,EACT;AAEA,QAAM,SAAS,UAAU,IAAI,KAAK,QAAQ,IAAI,OAAO,gBAAgB,yBAAQ,WAAW;AACxF,QAAM,aAAa,OAAO,SAAS,GAAG,IAAI;AAC1C,MAAI,WAAW;AACf,aAAW,UAAU,MAAY,eAAe,MAAM;AACpD,QAAK,UAAU,yBAAQ,aAAc;AAAU;AAC/C,SAAK,EAAE,MAAM,IAAI;AACjB,eAAW;AAAA,EACb,CAAC;AAED,SAAO;AACT;",
+  "names": ["buffer"]
+}

package/dist/buffers.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+/** A `RecyclableBuffer` is a `Buffer` that can be recycled by a pool. */
+export interface RecyclableBuffer extends Buffer {
+    /** Recycle this buffer. */
+    recycle(): void;
+}
+/**
+ * Allocate a {@link RecyclableBuffer} of _size_ bytes.
+ *
+ * Up to {@link BUFFERS.POOL_SIZE} (64) buffers will be recycled once their
+ * `recycle()` method is called _if_ their size is not bigger than
+ * {@link BUFFERS.BUFFER_SIZE} (8192 bytes).
+ */
+export declare function allocateBuffer(size: number): RecyclableBuffer;

package/dist/buffers.mjs

@@ -0,0 +1,25 @@
+// buffers.ts
+import { BUFFERS } from "./constants.mjs";
+var pool = new Array(BUFFERS.POOL_SIZE);
+var offset = -1;
+function allocateBuffer(size) {
+  if (size > BUFFERS.BUFFER_SIZE) {
+    const buffer2 = Buffer.allocUnsafeSlow(size);
+    buffer2.recycle = () => void 0;
+    return buffer2;
+  }
+  const buffer = offset >= 0 ? pool[offset--] : Buffer.allocUnsafeSlow(BUFFERS.BUFFER_SIZE);
+  const recyclable = buffer.subarray(0, size);
+  let recycled = false;
+  recyclable.recycle = () => queueMicrotask(() => {
+    if (offset >= BUFFERS.POOL_SIZE || recycled)
+      return;
+    pool[++offset] = buffer;
+    recycled = true;
+  });
+  return recyclable;
+}
+export {
+  allocateBuffer
+};
+//# sourceMappingURL=buffers.mjs.map

package/dist/buffers.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../src/buffers.ts"],
+  "mappings": ";AAAA,SAAS,eAAe;AAExB,IAAM,OAAiB,IAAI,MAAM,QAAQ,SAAS;AAClD,IAAI,SAAS;AAeN,SAAS,eAAe,MAAgC;AAC7D,MAAI,OAAO,QAAQ,aAAa;AAC9B,UAAMA,UAAS,OAAO,gBAAgB,IAAI;AAC1C,IAAAA,QAAO,UAAU,MAAM;AACvB,WAAOA;AAAA,EACT;AAEA,QAAM,SAAS,UAAU,IAAI,KAAK,QAAQ,IAAI,OAAO,gBAAgB,QAAQ,WAAW;AACxF,QAAM,aAAa,OAAO,SAAS,GAAG,IAAI;AAC1C,MAAI,WAAW;AACf,aAAW,UAAU,MAAY,eAAe,MAAM;AACpD,QAAK,UAAU,QAAQ,aAAc;AAAU;AAC/C,SAAK,EAAE,MAAM,IAAI;AACjB,eAAW;AAAA,EACb,CAAC;AAED,SAAO;AACT;",
+  "names": ["buffer"]
+}

package/dist/client.cjs

@@ -0,0 +1,251 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// client.ts
+var client_exports = {};
+__export(client_exports, {
+  MemxClient: () => MemxClient
+});
+module.exports = __toCommonJS(client_exports);
+var import_node_assert = __toESM(require("node:assert"));
+var import_node_util = require("node:util");
+var import_cluster = require("./cluster.cjs");
+var import_constants = require("./constants.cjs");
+var import_internals = require("./internals.cjs");
+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, { ...options, flags: import_constants.FLAGS.BUFFER }];
+  switch (typeof value) {
+    case "bigint":
+      return [Buffer.from(value.toString(), "utf-8"), { ...options, flags: import_constants.FLAGS.BIGINT }];
+    case "boolean":
+      return [Buffer.alloc(1, value ? 255 : 0), { ...options, flags: import_constants.FLAGS.BOOLEAN }];
+    case "number":
+      return [Buffer.from(value.toString(), "utf-8"), { ...options, flags: import_constants.FLAGS.NUMBER }];
+    case "string":
+      return [Buffer.from(value, "utf-8"), { ...options, flags: import_constants.FLAGS.STRING }];
+    case "object":
+      break;
+    default:
+      import_node_assert.default.fail(`Unable to store value of type "${typeof value}"`);
+  }
+  if (import_node_util.types.isTypedArray(value)) {
+    const flags = (0, import_internals.typedArrayFlags)(value);
+    const buffer = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+    return [buffer, { ...options, flags }];
+  }
+  if (value === null)
+    return [import_constants.EMPTY_BUFFER, { ...options, flags: import_constants.FLAGS.NULL }];
+  const json = JSON.stringify(value, replacer);
+  return [Buffer.from(json, "utf-8"), { ...options, flags: import_constants.FLAGS.JSON }];
+}
+function fromBuffer(result) {
+  try {
+    const { flags, value, cas } = result;
+    switch (flags) {
+      case import_constants.FLAGS.BIGINT:
+        return { value: BigInt(value.toString("utf-8")), cas };
+      case import_constants.FLAGS.BOOLEAN:
+        return { value: !!value[0], cas };
+      case import_constants.FLAGS.NUMBER:
+        return { value: Number(value.toString("utf-8")), cas };
+      case import_constants.FLAGS.STRING:
+        return { value: value.toString("utf-8"), cas };
+      case import_constants.FLAGS.NULL:
+        return { value: null, cas };
+      case import_constants.FLAGS.JSON:
+        return { value: JSON.parse(value.toString("utf-8"), reviver), cas };
+      case import_constants.FLAGS.UINT8ARRAY:
+        return { value: makeTypedArray(Uint8Array, value), cas };
+      case import_constants.FLAGS.UINT8CLAMPEDARRAY:
+        return { value: makeTypedArray(Uint8ClampedArray, value), cas };
+      case import_constants.FLAGS.UINT16ARRAY:
+        return { value: makeTypedArray(Uint16Array, value), cas };
+      case import_constants.FLAGS.UINT32ARRAY:
+        return { value: makeTypedArray(Uint32Array, value), cas };
+      case import_constants.FLAGS.INT8ARRAY:
+        return { value: makeTypedArray(Int8Array, value), cas };
+      case import_constants.FLAGS.INT16ARRAY:
+        return { value: makeTypedArray(Int16Array, value), cas };
+      case import_constants.FLAGS.INT32ARRAY:
+        return { value: makeTypedArray(Int32Array, value), cas };
+      case import_constants.FLAGS.BIGUINT64ARRAY:
+        return { value: makeTypedArray(BigUint64Array, value), cas };
+      case import_constants.FLAGS.BIGINT64ARRAY:
+        return { value: makeTypedArray(BigInt64Array, value), cas };
+      case import_constants.FLAGS.FLOAT32ARRAY:
+        return { value: makeTypedArray(Float32Array, value), cas };
+      case import_constants.FLAGS.FLOAT64ARRAY:
+        return { value: makeTypedArray(Float64Array, value), cas };
+      case import_constants.FLAGS.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 import_cluster.ClusterAdapter();
+    } else if ("get" in adapterOrOptions) {
+      this.#adapter = adapterOrOptions;
+    } else if ("hosts" in adapterOrOptions) {
+      this.#adapter = new import_cluster.ClusterAdapter(adapterOrOptions);
+    }
+    this.#prefix = "";
+    (0, import_node_assert.default)(this.#adapter, "Invalid client constructor arguments");
+  }
+  /** Return the {@link Adapter} backing this {@link MemxClient} instance */
+  get adapter() {
+    return this.#adapter;
+  }
+  /** Return the prefix prepended to all keys managed by this {@link MemxClient} */
+  get prefix() {
+    return this.#prefix;
+  }
+  /** Return a new {@link MemxClient} prefixing keys with the specified `string` */
+  withPrefix(prefix) {
+    (0, import_node_assert.default)(prefix, "Invalid prefix");
+    const client = new MemxClient(this.#adapter);
+    client.#prefix = prefix;
+    return client;
+  }
+  /** Get the value (or `undefined`) associated with the given key */
+  async get(key) {
+    const result = await this.#adapter.get(this.#prefix + key);
+    return result && fromBuffer(result).value;
+  }
+  /** Get the value (or `undefined`) associated with the given key, and update its TTL */
+  async gat(key, ttl) {
+    const result = await this.#adapter.gat(this.#prefix + key, ttl);
+    return result && fromBuffer(result).value;
+  }
+  /** Get the value and _CAS_ associated with the given key */
+  async getc(key) {
+    const result = await this.#adapter.get(this.#prefix + key);
+    return result && fromBuffer(result);
+  }
+  /** Get the value and _CAS_ associated with the given key, and update its TTL */
+  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?.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(this.#prefix + key, delta, options);
+    if (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, 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();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MemxClient
+});
+//# sourceMappingURL=client.cjs.map

package/dist/client.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../src/client.ts"],
+  "mappings": "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",
+  "names": ["assert"]
+}

package/dist/client.d.ts

@@ -0,0 +1,76 @@
+/// <reference types="node" />
+import type { ClusterOptions } from './cluster';
+import type { Adapter, Counter, Stats } from './types';
+/** Types that can be serialized by our {@link MemxClient}. */
+export type Serializable = bigint | string | number | boolean | null | object;
+/** Types that can be appended/prepended by our {@link MemxClient}. */
+export type Appendable = string | NodeJS.TypedArray;
+/** The `ClientResult` interface associate a value with its _CAS_. */
+export interface ClientResult<T extends Serializable> {
+    /** The value returned by the {@link MemxClient} */
+    value: T;
+    /** The _CAS_ of the value being returned */
+    cas: bigint;
+}
+/**
+ * A `Client` represents a high-level client for a _Memcached_ server.
+ */
+export declare class MemxClient {
+    #private;
+    /** Construct a new {@link MemxClient} from environment variables */
+    constructor();
+    /** Construct a new {@link MemxClient} wrapping an existing {@link Adapter} */
+    constructor(adapter: Adapter);
+    /** Construct a new {@link MemxClient} given the specified {@link ClusterOptions} */
+    constructor(options: ClusterOptions);
+    /** Return the {@link Adapter} backing this {@link MemxClient} instance */
+    get adapter(): Adapter;
+    /** Return the prefix prepended to all keys managed by this {@link MemxClient} */
+    get prefix(): string;
+    /** Return a new {@link MemxClient} prefixing keys with the specified `string` */
+    withPrefix(prefix: string): MemxClient;
+    /** Get the value (or `undefined`) associated with the given key */
+    get<T extends Serializable>(key: string): Promise<T | undefined>;
+    /** Get the value (or `undefined`) associated with the given key, and update its TTL */
+    gat<T extends Serializable>(key: string, ttl: number): Promise<T | undefined>;
+    /** Get the value and _CAS_ associated with the given key */
+    getc<T extends Serializable>(key: string): Promise<ClientResult<T> | undefined>;
+    /** Get the value and _CAS_ associated with the given key, and update its TTL */
+    gatc<T extends Serializable>(key: string, ttl: number): Promise<ClientResult<T> | undefined>;
+    set(key: string, value: Serializable, options?: {
+        cas?: bigint;
+        ttl?: number;
+    }): Promise<bigint | undefined>;
+    add(key: string, value: Serializable, options?: {
+        ttl?: number;
+    }): Promise<bigint | undefined>;
+    replace(key: string, value: Serializable, options?: {
+        cas?: bigint;
+        ttl?: number;
+    }): Promise<bigint | undefined>;
+    append(key: string, value: Appendable, options?: {
+        cas?: bigint;
+    }): Promise<boolean>;
+    prepend(key: string, value: Appendable, options?: {
+        cas?: bigint;
+    }): Promise<boolean>;
+    increment(key: string, delta?: bigint | number, options?: {
+        initial?: bigint | number;
+        cas?: bigint;
+        ttl?: number;
+    }): Promise<Counter | undefined>;
+    decrement(key: string, delta?: bigint | number, options?: {
+        initial?: bigint | number;
+        cas?: bigint;
+        ttl?: number;
+    }): Promise<Counter | undefined>;
+    touch(key: string, ttl?: number): Promise<boolean>;
+    delete(key: string, options?: {
+        cas?: bigint;
+    }): Promise<boolean>;
+    flush(ttl?: number): Promise<void>;
+    noop(): Promise<void>;
+    quit(): Promise<void>;
+    version(): Promise<Record<string, string>>;
+    stats(): Promise<Record<string, Stats>>;
+}

package/dist/client.mjs

@@ -0,0 +1,216 @@
+// client.ts
+import assert from "node:assert";
+import { types } from "node:util";
+import { ClusterAdapter } from "./cluster.mjs";
+import { EMPTY_BUFFER, FLAGS } from "./constants.mjs";
+import { typedArrayFlags } from "./internals.mjs";
+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, { ...options, flags: FLAGS.BUFFER }];
+  switch (typeof value) {
+    case "bigint":
+      return [Buffer.from(value.toString(), "utf-8"), { ...options, flags: FLAGS.BIGINT }];
+    case "boolean":
+      return [Buffer.alloc(1, value ? 255 : 0), { ...options, flags: FLAGS.BOOLEAN }];
+    case "number":
+      return [Buffer.from(value.toString(), "utf-8"), { ...options, flags: FLAGS.NUMBER }];
+    case "string":
+      return [Buffer.from(value, "utf-8"), { ...options, flags: FLAGS.STRING }];
+    case "object":
+      break;
+    default:
+      assert.fail(`Unable to store value of type "${typeof value}"`);
+  }
+  if (types.isTypedArray(value)) {
+    const flags = typedArrayFlags(value);
+    const buffer = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+    return [buffer, { ...options, flags }];
+  }
+  if (value === null)
+    return [EMPTY_BUFFER, { ...options, flags: FLAGS.NULL }];
+  const json = JSON.stringify(value, replacer);
+  return [Buffer.from(json, "utf-8"), { ...options, flags: FLAGS.JSON }];
+}
+function fromBuffer(result) {
+  try {
+    const { flags, value, cas } = result;
+    switch (flags) {
+      case FLAGS.BIGINT:
+        return { value: BigInt(value.toString("utf-8")), cas };
+      case FLAGS.BOOLEAN:
+        return { value: !!value[0], cas };
+      case FLAGS.NUMBER:
+        return { value: Number(value.toString("utf-8")), cas };
+      case FLAGS.STRING:
+        return { value: value.toString("utf-8"), cas };
+      case FLAGS.NULL:
+        return { value: null, cas };
+      case FLAGS.JSON:
+        return { value: JSON.parse(value.toString("utf-8"), reviver), cas };
+      case FLAGS.UINT8ARRAY:
+        return { value: makeTypedArray(Uint8Array, value), cas };
+      case FLAGS.UINT8CLAMPEDARRAY:
+        return { value: makeTypedArray(Uint8ClampedArray, value), cas };
+      case FLAGS.UINT16ARRAY:
+        return { value: makeTypedArray(Uint16Array, value), cas };
+      case FLAGS.UINT32ARRAY:
+        return { value: makeTypedArray(Uint32Array, value), cas };
+      case FLAGS.INT8ARRAY:
+        return { value: makeTypedArray(Int8Array, value), cas };
+      case FLAGS.INT16ARRAY:
+        return { value: makeTypedArray(Int16Array, value), cas };
+      case FLAGS.INT32ARRAY:
+        return { value: makeTypedArray(Int32Array, value), cas };
+      case FLAGS.BIGUINT64ARRAY:
+        return { value: makeTypedArray(BigUint64Array, value), cas };
+      case FLAGS.BIGINT64ARRAY:
+        return { value: makeTypedArray(BigInt64Array, value), cas };
+      case FLAGS.FLOAT32ARRAY:
+        return { value: makeTypedArray(Float32Array, value), cas };
+      case FLAGS.FLOAT64ARRAY:
+        return { value: makeTypedArray(Float64Array, value), cas };
+      case FLAGS.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 = "";
+    assert(this.#adapter, "Invalid client constructor arguments");
+  }
+  /** Return the {@link Adapter} backing this {@link MemxClient} instance */
+  get adapter() {
+    return this.#adapter;
+  }
+  /** Return the prefix prepended to all keys managed by this {@link MemxClient} */
+  get prefix() {
+    return this.#prefix;
+  }
+  /** Return a new {@link MemxClient} prefixing keys with the specified `string` */
+  withPrefix(prefix) {
+    assert(prefix, "Invalid prefix");
+    const client = new MemxClient(this.#adapter);
+    client.#prefix = prefix;
+    return client;
+  }
+  /** Get the value (or `undefined`) associated with the given key */
+  async get(key) {
+    const result = await this.#adapter.get(this.#prefix + key);
+    return result && fromBuffer(result).value;
+  }
+  /** Get the value (or `undefined`) associated with the given key, and update its TTL */
+  async gat(key, ttl) {
+    const result = await this.#adapter.gat(this.#prefix + key, ttl);
+    return result && fromBuffer(result).value;
+  }
+  /** Get the value and _CAS_ associated with the given key */
+  async getc(key) {
+    const result = await this.#adapter.get(this.#prefix + key);
+    return result && fromBuffer(result);
+  }
+  /** Get the value and _CAS_ associated with the given key, and update its TTL */
+  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?.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(this.#prefix + key, delta, options);
+    if (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, 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();
+  }
+};
+export {
+  MemxClient
+};
+//# sourceMappingURL=client.mjs.map