@croct/sdk 0.17.9 → 0.17.11

package/facade/userFacade.cjs

@@ -0,0 +1,43 @@
+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);
+var userFacade_exports = {};
+__export(userFacade_exports, {
+  UserFacade: () => UserFacade
+});
+module.exports = __toCommonJS(userFacade_exports);
+var import_userPatch = require("./userPatch");
+class UserFacade {
+  constructor(context, tracker) {
+    this.context = context;
+    this.tracker = tracker;
+  }
+  isIdentified() {
+    return !this.isAnonymous();
+  }
+  isAnonymous() {
+    return this.context.isAnonymous();
+  }
+  edit() {
+    return new import_userPatch.UserPatch(this.tracker);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UserFacade
+});
+//# sourceMappingURL=userFacade.cjs.map

package/facade/userPatch.cjs

@@ -0,0 +1,48 @@
+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);
+var userPatch_exports = {};
+__export(userPatch_exports, {
+  UserPatch: () => UserPatch
+});
+module.exports = __toCommonJS(userPatch_exports);
+var import_activeRecord = require("../activeRecord");
+class UserPatch extends import_activeRecord.ActiveRecord {
+  constructor(tracker) {
+    super();
+    this.tracker = tracker;
+  }
+  save() {
+    if (!this.isDirty()) {
+      return Promise.resolve({
+        type: "userProfileChanged",
+        patch: { operations: [] }
+      });
+    }
+    const promise = this.tracker.track({
+      type: "userProfileChanged",
+      patch: this.buildPatch()
+    });
+    this.reset();
+    return promise;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UserPatch
+});
+//# sourceMappingURL=userPatch.cjs.map

package/help.cjs

@@ -0,0 +1,45 @@
+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);
+var help_exports = {};
+__export(help_exports, {
+  Help: () => Help
+});
+module.exports = __toCommonJS(help_exports);
+var Help;
+((Help2) => {
+  function forStatusCode(statusCode) {
+    switch (statusCode) {
+      case 401:
+        return "The request was not authorized, most likely due to invalid credentials. For help, see https://croct.help/sdk/javascript/invalid-credentials";
+      case 403:
+        return "The origin of the request is not allowed in your application settings. For help, see https://croct.help/sdk/javascript/unauthorized-origin";
+      case 408:
+        return "The request timed out. For help, see https://croct.help/sdk/javascript/request-timeout";
+      case 423:
+        return "The application has exceeded the monthly active users (MAU) quota. For help, see https://croct.help/sdk/javascript/mau-exceeded";
+      default:
+        return void 0;
+    }
+  }
+  Help2.forStatusCode = forStatusCode;
+})(Help || (Help = {}));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Help
+});
+//# sourceMappingURL=help.cjs.map

package/index.cjs

@@ -0,0 +1,33 @@
+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);
+var index_exports = {};
+__export(index_exports, {
+  Configuration: () => import_sdk.Configuration,
+  Sdk: () => import_sdk.Sdk,
+  VERSION: () => import_constants.VERSION
+});
+module.exports = __toCommonJS(index_exports);
+var import_constants = require("./constants");
+var import_sdk = require("./sdk");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Configuration,
+  Sdk,
+  VERSION
+});
+//# sourceMappingURL=index.cjs.map

package/logging/consoleLogger.cjs

@@ -0,0 +1,50 @@
+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);
+var consoleLogger_exports = {};
+__export(consoleLogger_exports, {
+  ConsoleLogger: () => ConsoleLogger
+});
+module.exports = __toCommonJS(consoleLogger_exports);
+class ConsoleLogger {
+  constructor(namespace) {
+    this.namespace = namespace;
+  }
+  get debug() {
+    return this.bind(console.debug);
+  }
+  get info() {
+    return this.bind(console.info);
+  }
+  get warn() {
+    return this.bind(console.warn);
+  }
+  get error() {
+    return this.bind(console.error);
+  }
+  bind(method) {
+    if (this.namespace !== void 0) {
+      return method.bind(console, `[${this.namespace}]`);
+    }
+    return method.bind(console);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConsoleLogger
+});
+//# sourceMappingURL=consoleLogger.cjs.map

package/logging/filteredLogger.cjs

@@ -0,0 +1,62 @@
+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);
+var filteredLogger_exports = {};
+__export(filteredLogger_exports, {
+  FilteredLogger: () => FilteredLogger
+});
+module.exports = __toCommonJS(filteredLogger_exports);
+class FilteredLogger {
+  constructor(configuration) {
+    this.logger = configuration.logger;
+    this.allowFilter = configuration.allowFilter;
+  }
+  static include(logger, levels) {
+    return new FilteredLogger({
+      logger,
+      allowFilter: (level) => levels.includes(level)
+    });
+  }
+  static exclude(logger, levels) {
+    return new FilteredLogger({
+      logger,
+      allowFilter: (level) => !levels.includes(level)
+    });
+  }
+  debug(message) {
+    this.log("debug", message);
+  }
+  info(message) {
+    this.log("info", message);
+  }
+  warn(message) {
+    this.log("warn", message);
+  }
+  error(message) {
+    this.log("error", message);
+  }
+  log(level, message) {
+    if (this.allowFilter(level, message)) {
+      this.logger[level](message);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FilteredLogger
+});
+//# sourceMappingURL=filteredLogger.cjs.map

package/logging/index.cjs

@@ -0,0 +1,40 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var logging_exports = {};
+__export(logging_exports, {
+  ConsoleLogger: () => import_consoleLogger.ConsoleLogger,
+  FilteredLogger: () => import_filteredLogger.FilteredLogger,
+  NamespacedLogger: () => import_namespacedLogger.NamespacedLogger,
+  NullLogger: () => import_nullLogger.NullLogger
+});
+module.exports = __toCommonJS(logging_exports);
+__reExport(logging_exports, require("./logger"), module.exports);
+var import_consoleLogger = require("./consoleLogger");
+var import_namespacedLogger = require("./namespacedLogger");
+var import_nullLogger = require("./nullLogger");
+var import_filteredLogger = require("./filteredLogger");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConsoleLogger,
+  FilteredLogger,
+  NamespacedLogger,
+  NullLogger,
+  ...require("./logger")
+});
+//# sourceMappingURL=index.cjs.map

package/logging/logger.cjs

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var logger_exports = {};
+module.exports = __toCommonJS(logger_exports);
+//# sourceMappingURL=logger.cjs.map

package/logging/namespacedLogger.cjs

@@ -0,0 +1,48 @@
+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);
+var namespacedLogger_exports = {};
+__export(namespacedLogger_exports, {
+  NamespacedLogger: () => NamespacedLogger
+});
+module.exports = __toCommonJS(namespacedLogger_exports);
+class NamespacedLogger {
+  constructor(logger, namespace) {
+    this.logger = logger;
+    this.namespace = namespace;
+  }
+  debug(message) {
+    this.logger.debug(this.format(message));
+  }
+  info(message) {
+    this.logger.info(this.format(message));
+  }
+  warn(message) {
+    this.logger.warn(this.format(message));
+  }
+  error(message) {
+    this.logger.error(this.format(message));
+  }
+  format(message) {
+    return `[${this.namespace}] ${message}`;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NamespacedLogger
+});
+//# sourceMappingURL=namespacedLogger.cjs.map

package/logging/nullLogger.cjs

@@ -0,0 +1,37 @@
+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);
+var nullLogger_exports = {};
+__export(nullLogger_exports, {
+  NullLogger: () => NullLogger
+});
+module.exports = __toCommonJS(nullLogger_exports);
+class NullLogger {
+  debug() {
+  }
+  info() {
+  }
+  warn() {
+  }
+  error() {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NullLogger
+});
+//# sourceMappingURL=nullLogger.cjs.map

package/namespacedStorage.cjs

@@ -0,0 +1,77 @@
+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);
+var namespacedStorage_exports = {};
+__export(namespacedStorage_exports, {
+  NamespacedStorage: () => NamespacedStorage
+});
+module.exports = __toCommonJS(namespacedStorage_exports);
+class NamespacedStorage {
+  constructor(storage, namespace) {
+    if (namespace === "") {
+      throw new Error("The namespace cannot be empty.");
+    }
+    this.storage = storage;
+    this.namespace = namespace;
+  }
+  get length() {
+    return this.getKeys().length;
+  }
+  clear() {
+    for (const key of this.getKeys()) {
+      this.storage.removeItem(key);
+    }
+  }
+  getItem(key) {
+    return this.storage.getItem(this.getPrefixedKey(key));
+  }
+  key(index) {
+    const keys = this.getKeys();
+    if (index >= keys.length) {
+      return null;
+    }
+    return keys[index].substring(this.namespace.length + 1);
+  }
+  removeItem(key) {
+    this.storage.removeItem(this.getPrefixedKey(key));
+  }
+  setItem(key, value) {
+    this.storage.setItem(this.getPrefixedKey(key), value);
+  }
+  getKeys() {
+    const keys = [];
+    const prefix = this.getPrefix();
+    for (let index = 0; index < this.storage.length; index++) {
+      const key = this.storage.key(index);
+      if (key !== null && key.indexOf(prefix) === 0) {
+        keys.push(key);
+      }
+    }
+    return keys;
+  }
+  getPrefixedKey(key) {
+    return this.getPrefix() + key;
+  }
+  getPrefix() {
+    return `${this.namespace}.`;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NamespacedStorage
+});
+//# sourceMappingURL=namespacedStorage.cjs.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@croct/sdk",
-  "version": "0.17.9",
+  "version": "0.17.11",
   "description": "Croct SDK for JavaScript.",
   "license": "MIT",
   "author": {
@@ -9,12 +9,12 @@
     "url": "https://croct.com"
   },
   "type": "module",
-  "main": "./index.mjs",
-  "types": "./index.d.mts",
+  "main": "./index.js",
+  "types": "./index.d.js",
   "exports": {
     "./*": {
-      "import": "./*.mjs",
-      "require": "./*.js"
+      "import": "./*.js",
+      "require": "./*.cjs"
     },
     "./cache": {
       "import": "./cache/index.js",
@@ -97,8 +97,9 @@
     "typescript": "^5.0.0"
   },
   "files": [
-    "**/*.mjs",
     "**/*.js",
+    "**/*.cjs",
+    "**/*.mjs",
     "**/*.ts",
     "**/*.map"
   ],

package/patch.cjs

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var patch_exports = {};
+module.exports = __toCommonJS(patch_exports);
+//# sourceMappingURL=patch.cjs.map

package/queue/capacityRestrictedQueue.cjs

@@ -0,0 +1,57 @@
+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);
+var capacityRestrictedQueue_exports = {};
+__export(capacityRestrictedQueue_exports, {
+  CapacityRestrictedQueue: () => CapacityRestrictedQueue
+});
+module.exports = __toCommonJS(capacityRestrictedQueue_exports);
+class CapacityRestrictedQueue {
+  constructor(queue, capacity) {
+    this.queue = queue;
+    this.capacity = capacity;
+  }
+  all() {
+    return this.queue.all();
+  }
+  getCapacity() {
+    return this.capacity;
+  }
+  isEmpty() {
+    return this.queue.isEmpty();
+  }
+  length() {
+    return Math.min(this.capacity, this.queue.length());
+  }
+  peek() {
+    return this.queue.peek();
+  }
+  push(value) {
+    if (this.queue.length() >= this.capacity) {
+      throw new Error("Maximum queue capacity reached.");
+    }
+    this.queue.push(value);
+  }
+  shift() {
+    return this.queue.shift();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CapacityRestrictedQueue
+});
+//# sourceMappingURL=capacityRestrictedQueue.cjs.map

package/queue/inMemoryQueue.cjs

@@ -0,0 +1,58 @@
+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);
+var inMemoryQueue_exports = {};
+__export(inMemoryQueue_exports, {
+  InMemoryQueue: () => InMemoryQueue
+});
+module.exports = __toCommonJS(inMemoryQueue_exports);
+class InMemoryQueue {
+  constructor(...values) {
+    this.queue = [];
+    this.queue.unshift(...values);
+  }
+  all() {
+    return this.queue.slice();
+  }
+  getCapacity() {
+    return Infinity;
+  }
+  isEmpty() {
+    return this.queue.length === 0;
+  }
+  push(value) {
+    this.queue.push(value);
+  }
+  peek() {
+    return this.queue[0] ?? null;
+  }
+  shift() {
+    const value = this.queue.shift();
+    if (value === void 0) {
+      throw new Error("The queue is empty.");
+    }
+    return value;
+  }
+  length() {
+    return this.queue.length;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InMemoryQueue
+});
+//# sourceMappingURL=inMemoryQueue.cjs.map