stream-chat 9.13.0 → 9.14.0

package/dist/cjs/index.node.cjs

@@ -9016,9 +9016,9 @@ var require_asynckit = __commonJS({
   }
 });
 
-// node_modules/form-data/lib/populate.js
+// node_modules/axios/node_modules/form-data/lib/populate.js
 var require_populate = __commonJS({
-  "node_modules/form-data/lib/populate.js"(exports2, module2) {
+  "node_modules/axios/node_modules/form-data/lib/populate.js"(exports2, module2) {
     module2.exports = function(dst, src) {
       Object.keys(src).forEach(function(prop) {
         dst[prop] = dst[prop] || src[prop];
@@ -9028,9 +9028,9 @@ var require_populate = __commonJS({
   }
 });
 
-// node_modules/form-data/lib/form_data.js
+// node_modules/axios/node_modules/form-data/lib/form_data.js
 var require_form_data = __commonJS({
-  "node_modules/form-data/lib/form_data.js"(exports2, module2) {
+  "node_modules/axios/node_modules/form-data/lib/form_data.js"(exports2, module2) {
     var CombinedStream = require_combined_stream();
     var util2 = require("util");
     var path = require("path");
@@ -10653,258 +10653,1436 @@ var require_follow_redirects = __commonJS({
   }
 });
 
-// node_modules/isomorphic-ws/node.js
-var require_node2 = __commonJS({
-  "node_modules/isomorphic-ws/node.js"(exports2, module2) {
+// node_modules/es-object-atoms/index.js
+var require_es_object_atoms = __commonJS({
+  "node_modules/es-object-atoms/index.js"(exports2, module2) {
     "use strict";
-    module2.exports = require("ws");
+    module2.exports = Object;
   }
 });
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AbstractOfflineDB: () => AbstractOfflineDB,
-  Allow: () => Allow,
-  AllowAll: () => AllowAll,
-  AnyResource: () => AnyResource,
-  AnyRole: () => AnyRole,
-  AttachmentManager: () => AttachmentManager,
-  BasePaginator: () => BasePaginator,
-  BaseSearchSource: () => BaseSearchSource,
-  BaseSearchSourceSync: () => BaseSearchSourceSync,
-  BuiltinPermissions: () => BuiltinPermissions,
-  BuiltinRoles: () => BuiltinRoles,
-  Campaign: () => Campaign,
-  Channel: () => Channel,
-  ChannelManager: () => ChannelManager,
-  ChannelSearchSource: () => ChannelSearchSource,
-  ChannelState: () => ChannelState,
-  CheckSignature: () => CheckSignature,
-  ClientState: () => ClientState,
-  CommandSearchSource: () => CommandSearchSource,
-  CustomDataManager: () => CustomDataManager,
-  DEFAULT_ATTACHMENT_MANAGER_CONFIG: () => DEFAULT_ATTACHMENT_MANAGER_CONFIG,
-  DEFAULT_CHANNEL_MANAGER_OPTIONS: () => DEFAULT_CHANNEL_MANAGER_OPTIONS,
-  DEFAULT_CHANNEL_MANAGER_PAGINATION_OPTIONS: () => DEFAULT_CHANNEL_MANAGER_PAGINATION_OPTIONS,
-  DEFAULT_COMPOSER_CONFIG: () => DEFAULT_COMPOSER_CONFIG,
-  DEFAULT_LINK_PREVIEW_MANAGER_CONFIG: () => DEFAULT_LINK_PREVIEW_MANAGER_CONFIG,
-  DEFAULT_LOCATION_COMPOSER_CONFIG: () => DEFAULT_LOCATION_COMPOSER_CONFIG,
-  DEFAULT_PAGINATION_OPTIONS: () => DEFAULT_PAGINATION_OPTIONS,
-  DEFAULT_REMINDER_MANAGER_CONFIG: () => DEFAULT_REMINDER_MANAGER_CONFIG,
-  DEFAULT_STOP_REFRESH_BOUNDARY_MS: () => DEFAULT_STOP_REFRESH_BOUNDARY_MS,
-  DEFAULT_TEXT_COMPOSER_CONFIG: () => DEFAULT_TEXT_COMPOSER_CONFIG,
-  Deny: () => Deny,
-  DenyAll: () => DenyAll,
-  DevToken: () => DevToken,
-  EVENT_MAP: () => EVENT_MAP,
-  ErrorFromResponse: () => ErrorFromResponse,
-  FixedSizeQueueCache: () => FixedSizeQueueCache,
-  InsightMetrics: () => InsightMetrics,
-  JWTServerToken: () => JWTServerToken,
-  JWTUserToken: () => JWTUserToken,
-  LinkPreviewStatus: () => LinkPreviewStatus,
-  LinkPreviewsManager: () => LinkPreviewsManager,
-  LiveLocationManager: () => LiveLocationManager,
-  LocationComposer: () => LocationComposer,
-  MAX_POLL_OPTIONS: () => MAX_POLL_OPTIONS,
-  MODERATION_ENTITY_TYPES: () => MODERATION_ENTITY_TYPES,
-  MaxPriority: () => MaxPriority,
-  MentionsSearchSource: () => MentionsSearchSource,
-  MergedStateStore: () => MergedStateStore,
-  MessageComposer: () => MessageComposer,
-  MessageComposerMiddlewareExecutor: () => MessageComposerMiddlewareExecutor,
-  MessageDraftComposerMiddlewareExecutor: () => MessageDraftComposerMiddlewareExecutor,
-  MessageSearchSource: () => MessageSearchSource,
-  MiddlewareExecutor: () => MiddlewareExecutor,
-  MinPriority: () => MinPriority,
-  Moderation: () => Moderation,
-  NotificationManager: () => NotificationManager,
-  OfflineDBSyncManager: () => OfflineDBSyncManager,
-  OfflineError: () => OfflineError,
-  Permission: () => Permission,
-  Poll: () => Poll,
-  PollComposer: () => PollComposer,
-  PollComposerCompositionMiddlewareExecutor: () => PollComposerCompositionMiddlewareExecutor,
-  PollComposerStateMiddlewareExecutor: () => PollComposerStateMiddlewareExecutor,
-  PollManager: () => PollManager,
-  Product: () => Product,
-  Reminder: () => Reminder,
-  ReminderManager: () => ReminderManager,
-  ReminderPaginator: () => ReminderPaginator,
-  ReminderTimer: () => ReminderTimer,
-  SearchController: () => SearchController,
-  Segment: () => Segment,
-  StableWSConnection: () => StableWSConnection,
-  StateStore: () => StateStore,
-  StreamChat: () => StreamChat,
-  THREAD_MANAGER_INITIAL_STATE: () => THREAD_MANAGER_INITIAL_STATE,
-  TextComposer: () => TextComposer,
-  TextComposerMiddlewareExecutor: () => TextComposerMiddlewareExecutor,
-  Thread: () => Thread,
-  ThreadManager: () => ThreadManager,
-  TokenManager: () => TokenManager,
-  UPDATE_LIVE_LOCATION_REQUEST_MIN_THROTTLE_TIMEOUT: () => UPDATE_LIVE_LOCATION_REQUEST_MIN_THROTTLE_TIMEOUT,
-  UserFromToken: () => UserFromToken,
-  UserSearchSource: () => UserSearchSource,
-  VALID_MAX_VOTES_VALUE_REGEX: () => VALID_MAX_VOTES_VALUE_REGEX,
-  VotingVisibility: () => VotingVisibility,
-  accentsMap: () => accentsMap,
-  buildWsFatalInsight: () => buildWsFatalInsight,
-  buildWsSuccessAfterFailureInsight: () => buildWsSuccessAfterFailureInsight,
-  calculateLevenshtein: () => calculateLevenshtein,
-  channelManagerEventToHandlerMapping: () => channelManagerEventToHandlerMapping,
-  chatCodes: () => chatCodes,
-  createActiveCommandGuardMiddleware: () => createActiveCommandGuardMiddleware,
-  createAttachmentsCompositionMiddleware: () => createAttachmentsCompositionMiddleware,
-  createCommandInjectionMiddleware: () => createCommandInjectionMiddleware,
-  createCommandStringExtractionMiddleware: () => createCommandStringExtractionMiddleware,
-  createCommandsMiddleware: () => createCommandsMiddleware,
-  createCompositionDataCleanupMiddleware: () => createCompositionDataCleanupMiddleware,
-  createCompositionValidationMiddleware: () => createCompositionValidationMiddleware,
-  createCustomDataCompositionMiddleware: () => createCustomDataCompositionMiddleware,
-  createDraftAttachmentsCompositionMiddleware: () => createDraftAttachmentsCompositionMiddleware,
-  createDraftCommandInjectionMiddleware: () => createDraftCommandInjectionMiddleware,
-  createDraftCompositionValidationMiddleware: () => createDraftCompositionValidationMiddleware,
-  createDraftCustomDataCompositionMiddleware: () => createDraftCustomDataCompositionMiddleware,
-  createDraftLinkPreviewsCompositionMiddleware: () => createDraftLinkPreviewsCompositionMiddleware,
-  createDraftMessageComposerStateCompositionMiddleware: () => createDraftMessageComposerStateCompositionMiddleware,
-  createDraftTextComposerCompositionMiddleware: () => createDraftTextComposerCompositionMiddleware,
-  createFileFromBlobs: () => createFileFromBlobs,
-  createLinkPreviewsCompositionMiddleware: () => createLinkPreviewsCompositionMiddleware,
-  createMentionsMiddleware: () => createMentionsMiddleware,
-  createMessageComposerStateCompositionMiddleware: () => createMessageComposerStateCompositionMiddleware,
-  createPollComposerStateMiddleware: () => createPollComposerStateMiddleware,
-  createSharedLocationCompositionMiddleware: () => createSharedLocationCompositionMiddleware,
-  createTextComposerCompositionMiddleware: () => createTextComposerCompositionMiddleware,
-  createTextComposerPreValidationMiddleware: () => createTextComposerPreValidationMiddleware,
-  decodeBase64: () => decodeBase64,
-  defaultPollFieldBlurEventValidators: () => defaultPollFieldBlurEventValidators,
-  defaultPollFieldChangeEventValidators: () => defaultPollFieldChangeEventValidators,
-  encodeBase64: () => encodeBase64,
-  ensureIsLocalAttachment: () => ensureIsLocalAttachment,
-  escapeRegExp: () => escapeRegExp,
-  extractPollData: () => extractPollData,
-  extractPollEnrichedData: () => extractPollEnrichedData,
-  formatMessage: () => formatMessage,
-  generateFileName: () => generateFileName,
-  getAttachmentTypeFromMimeType: () => getAttachmentTypeFromMimeType,
-  getCompleteCommandInString: () => getCompleteCommandInString,
-  getExtensionFromMimeType: () => getExtensionFromMimeType,
-  getTokenizedSuggestionDisplayName: () => getTokenizedSuggestionDisplayName,
-  getTriggerCharWithToken: () => getTriggerCharWithToken,
-  insertItemWithTrigger: () => insertItemWithTrigger,
-  isAudioAttachment: () => isAudioAttachment,
-  isBlobButNotFile: () => isBlobButNotFile,
-  isFile: () => isFile2,
-  isFileAttachment: () => isFileAttachment,
-  isFileList: () => isFileList2,
-  isFileReference: () => isFileReference,
-  isImageAttachment: () => isImageAttachment,
-  isImageFile: () => isImageFile,
-  isLocalAttachment: () => isLocalAttachment,
-  isLocalAudioAttachment: () => isLocalAudioAttachment,
-  isLocalFileAttachment: () => isLocalFileAttachment,
-  isLocalImageAttachment: () => isLocalImageAttachment,
-  isLocalUploadAttachment: () => isLocalUploadAttachment,
-  isLocalVideoAttachment: () => isLocalVideoAttachment,
-  isLocalVoiceRecordingAttachment: () => isLocalVoiceRecordingAttachment,
-  isOwnUser: () => isOwnUser,
-  isPatch: () => isPatch,
-  isScrapedContent: () => isScrapedContent,
-  isSharedLocationResponse: () => isSharedLocationResponse,
-  isTargetedOptionTextUpdate: () => isTargetedOptionTextUpdate,
-  isUploadedAttachment: () => isUploadedAttachment,
-  isVideoAttachment: () => isVideoAttachment,
-  isVoiceRecordingAttachment: () => isVoiceRecordingAttachment,
-  isVoteAnswer: () => isVoteAnswer,
-  localMessageToNewMessagePayload: () => localMessageToNewMessagePayload,
-  logChatPromiseExecution: () => logChatPromiseExecution,
-  mapPollStateToResponse: () => mapPollStateToResponse,
-  pollCompositionStateProcessors: () => pollCompositionStateProcessors,
-  pollStateChangeValidators: () => pollStateChangeValidators,
-  postInsights: () => postInsights,
-  promoteChannel: () => promoteChannel,
-  readFileAsArrayBuffer: () => readFileAsArrayBuffer,
-  removeDiacritics: () => removeDiacritics,
-  replaceWordWithEntity: () => replaceWordWithEntity,
-  textIsEmpty: () => textIsEmpty,
-  timeLeftMs: () => timeLeftMs
+// node_modules/es-errors/index.js
+var require_es_errors = __commonJS({
+  "node_modules/es-errors/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Error;
+  }
 });
-module.exports = __toCommonJS(index_exports);
 
-// src/base64.ts
-var import_base64_js = __toESM(require_base64_js());
-function isString(arrayOrString) {
-  return typeof arrayOrString === "string";
-}
-function isMapStringCallback(arrayOrString, callback) {
-  return !!callback && isString(arrayOrString);
-}
-function map(arrayOrString, callback) {
-  const res = [];
-  if (isString(arrayOrString) && isMapStringCallback(arrayOrString, callback)) {
-    for (let k = 0, len = arrayOrString.length; k < len; k++) {
-      if (arrayOrString.charAt(k)) {
-        const kValue = arrayOrString.charAt(k);
-        const mappedValue = callback(kValue, k, arrayOrString);
-        res[k] = mappedValue;
-      }
-    }
-  } else if (!isString(arrayOrString) && !isMapStringCallback(arrayOrString, callback)) {
-    for (let k = 0, len = arrayOrString.length; k < len; k++) {
-      if (k in arrayOrString) {
-        const kValue = arrayOrString[k];
-        const mappedValue = callback(kValue, k, arrayOrString);
-        res[k] = mappedValue;
-      }
-    }
+// node_modules/es-errors/eval.js
+var require_eval = __commonJS({
+  "node_modules/es-errors/eval.js"(exports2, module2) {
+    "use strict";
+    module2.exports = EvalError;
   }
-  return res;
-}
-var encodeBase64 = (data) => (0, import_base64_js.fromByteArray)(new Uint8Array(map(data, (char) => char.charCodeAt(0))));
-var decodeBase64 = (s) => {
-  const e = {}, w = String.fromCharCode, L = s.length;
-  let i, b = 0, c, x, l = 0, a, r = "";
-  const A = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-  for (i = 0; i < 64; i++) {
-    e[A.charAt(i)] = i;
+});
+
+// node_modules/es-errors/range.js
+var require_range = __commonJS({
+  "node_modules/es-errors/range.js"(exports2, module2) {
+    "use strict";
+    module2.exports = RangeError;
   }
-  for (x = 0; x < L; x++) {
-    c = e[s.charAt(x)];
-    b = (b << 6) + c;
-    l += 6;
-    while (l >= 8) {
-      ((a = b >>> (l -= 8) & 255) || x < L - 2) && (r += w(a));
-    }
+});
+
+// node_modules/es-errors/ref.js
+var require_ref = __commonJS({
+  "node_modules/es-errors/ref.js"(exports2, module2) {
+    "use strict";
+    module2.exports = ReferenceError;
   }
-  return r;
-};
+});
 
-// src/campaign.ts
-var Campaign = class {
-  constructor(client, id, data) {
-    this.client = client;
-    this.id = id;
-    this.data = data;
+// node_modules/es-errors/syntax.js
+var require_syntax = __commonJS({
+  "node_modules/es-errors/syntax.js"(exports2, module2) {
+    "use strict";
+    module2.exports = SyntaxError;
   }
-  async create() {
-    const body = {
-      id: this.id,
-      message_template: this.data?.message_template,
-      segment_ids: this.data?.segment_ids,
-      sender_id: this.data?.sender_id,
-      sender_mode: this.data?.sender_mode,
-      channel_template: this.data?.channel_template,
-      create_channels: this.data?.create_channels,
-      show_channels: this.data?.show_channels,
-      description: this.data?.description,
-      name: this.data?.name,
-      skip_push: this.data?.skip_push,
-      skip_webhook: this.data?.skip_webhook,
-      user_ids: this.data?.user_ids
-    };
-    const result = await this.client.createCampaign(body);
+});
+
+// node_modules/es-errors/type.js
+var require_type = __commonJS({
+  "node_modules/es-errors/type.js"(exports2, module2) {
+    "use strict";
+    module2.exports = TypeError;
+  }
+});
+
+// node_modules/es-errors/uri.js
+var require_uri = __commonJS({
+  "node_modules/es-errors/uri.js"(exports2, module2) {
+    "use strict";
+    module2.exports = URIError;
+  }
+});
+
+// node_modules/math-intrinsics/abs.js
+var require_abs = __commonJS({
+  "node_modules/math-intrinsics/abs.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Math.abs;
+  }
+});
+
+// node_modules/math-intrinsics/floor.js
+var require_floor = __commonJS({
+  "node_modules/math-intrinsics/floor.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Math.floor;
+  }
+});
+
+// node_modules/math-intrinsics/max.js
+var require_max = __commonJS({
+  "node_modules/math-intrinsics/max.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Math.max;
+  }
+});
+
+// node_modules/math-intrinsics/min.js
+var require_min = __commonJS({
+  "node_modules/math-intrinsics/min.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Math.min;
+  }
+});
+
+// node_modules/math-intrinsics/pow.js
+var require_pow = __commonJS({
+  "node_modules/math-intrinsics/pow.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Math.pow;
+  }
+});
+
+// node_modules/math-intrinsics/round.js
+var require_round = __commonJS({
+  "node_modules/math-intrinsics/round.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Math.round;
+  }
+});
+
+// node_modules/math-intrinsics/isNaN.js
+var require_isNaN = __commonJS({
+  "node_modules/math-intrinsics/isNaN.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Number.isNaN || function isNaN2(a) {
+      return a !== a;
+    };
+  }
+});
+
+// node_modules/math-intrinsics/sign.js
+var require_sign = __commonJS({
+  "node_modules/math-intrinsics/sign.js"(exports2, module2) {
+    "use strict";
+    var $isNaN = require_isNaN();
+    module2.exports = function sign(number) {
+      if ($isNaN(number) || number === 0) {
+        return number;
+      }
+      return number < 0 ? -1 : 1;
+    };
+  }
+});
+
+// node_modules/gopd/gOPD.js
+var require_gOPD = __commonJS({
+  "node_modules/gopd/gOPD.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Object.getOwnPropertyDescriptor;
+  }
+});
+
+// node_modules/gopd/index.js
+var require_gopd = __commonJS({
+  "node_modules/gopd/index.js"(exports2, module2) {
+    "use strict";
+    var $gOPD = require_gOPD();
+    if ($gOPD) {
+      try {
+        $gOPD([], "length");
+      } catch (e) {
+        $gOPD = null;
+      }
+    }
+    module2.exports = $gOPD;
+  }
+});
+
+// node_modules/es-define-property/index.js
+var require_es_define_property = __commonJS({
+  "node_modules/es-define-property/index.js"(exports2, module2) {
+    "use strict";
+    var $defineProperty = Object.defineProperty || false;
+    if ($defineProperty) {
+      try {
+        $defineProperty({}, "a", { value: 1 });
+      } catch (e) {
+        $defineProperty = false;
+      }
+    }
+    module2.exports = $defineProperty;
+  }
+});
+
+// node_modules/has-symbols/shams.js
+var require_shams = __commonJS({
+  "node_modules/has-symbols/shams.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function hasSymbols() {
+      if (typeof Symbol !== "function" || typeof Object.getOwnPropertySymbols !== "function") {
+        return false;
+      }
+      if (typeof Symbol.iterator === "symbol") {
+        return true;
+      }
+      var obj = {};
+      var sym = Symbol("test");
+      var symObj = Object(sym);
+      if (typeof sym === "string") {
+        return false;
+      }
+      if (Object.prototype.toString.call(sym) !== "[object Symbol]") {
+        return false;
+      }
+      if (Object.prototype.toString.call(symObj) !== "[object Symbol]") {
+        return false;
+      }
+      var symVal = 42;
+      obj[sym] = symVal;
+      for (var _ in obj) {
+        return false;
+      }
+      if (typeof Object.keys === "function" && Object.keys(obj).length !== 0) {
+        return false;
+      }
+      if (typeof Object.getOwnPropertyNames === "function" && Object.getOwnPropertyNames(obj).length !== 0) {
+        return false;
+      }
+      var syms = Object.getOwnPropertySymbols(obj);
+      if (syms.length !== 1 || syms[0] !== sym) {
+        return false;
+      }
+      if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) {
+        return false;
+      }
+      if (typeof Object.getOwnPropertyDescriptor === "function") {
+        var descriptor = (
+          /** @type {PropertyDescriptor} */
+          Object.getOwnPropertyDescriptor(obj, sym)
+        );
+        if (descriptor.value !== symVal || descriptor.enumerable !== true) {
+          return false;
+        }
+      }
+      return true;
+    };
+  }
+});
+
+// node_modules/has-symbols/index.js
+var require_has_symbols = __commonJS({
+  "node_modules/has-symbols/index.js"(exports2, module2) {
+    "use strict";
+    var origSymbol = typeof Symbol !== "undefined" && Symbol;
+    var hasSymbolSham = require_shams();
+    module2.exports = function hasNativeSymbols() {
+      if (typeof origSymbol !== "function") {
+        return false;
+      }
+      if (typeof Symbol !== "function") {
+        return false;
+      }
+      if (typeof origSymbol("foo") !== "symbol") {
+        return false;
+      }
+      if (typeof Symbol("bar") !== "symbol") {
+        return false;
+      }
+      return hasSymbolSham();
+    };
+  }
+});
+
+// node_modules/get-proto/Reflect.getPrototypeOf.js
+var require_Reflect_getPrototypeOf = __commonJS({
+  "node_modules/get-proto/Reflect.getPrototypeOf.js"(exports2, module2) {
+    "use strict";
+    module2.exports = typeof Reflect !== "undefined" && Reflect.getPrototypeOf || null;
+  }
+});
+
+// node_modules/get-proto/Object.getPrototypeOf.js
+var require_Object_getPrototypeOf = __commonJS({
+  "node_modules/get-proto/Object.getPrototypeOf.js"(exports2, module2) {
+    "use strict";
+    var $Object = require_es_object_atoms();
+    module2.exports = $Object.getPrototypeOf || null;
+  }
+});
+
+// node_modules/function-bind/implementation.js
+var require_implementation = __commonJS({
+  "node_modules/function-bind/implementation.js"(exports2, module2) {
+    "use strict";
+    var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
+    var toStr = Object.prototype.toString;
+    var max = Math.max;
+    var funcType = "[object Function]";
+    var concatty = function concatty2(a, b) {
+      var arr = [];
+      for (var i = 0; i < a.length; i += 1) {
+        arr[i] = a[i];
+      }
+      for (var j = 0; j < b.length; j += 1) {
+        arr[j + a.length] = b[j];
+      }
+      return arr;
+    };
+    var slicy = function slicy2(arrLike, offset) {
+      var arr = [];
+      for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) {
+        arr[j] = arrLike[i];
+      }
+      return arr;
+    };
+    var joiny = function(arr, joiner) {
+      var str = "";
+      for (var i = 0; i < arr.length; i += 1) {
+        str += arr[i];
+        if (i + 1 < arr.length) {
+          str += joiner;
+        }
+      }
+      return str;
+    };
+    module2.exports = function bind2(that) {
+      var target = this;
+      if (typeof target !== "function" || toStr.apply(target) !== funcType) {
+        throw new TypeError(ERROR_MESSAGE + target);
+      }
+      var args = slicy(arguments, 1);
+      var bound;
+      var binder = function() {
+        if (this instanceof bound) {
+          var result = target.apply(
+            this,
+            concatty(args, arguments)
+          );
+          if (Object(result) === result) {
+            return result;
+          }
+          return this;
+        }
+        return target.apply(
+          that,
+          concatty(args, arguments)
+        );
+      };
+      var boundLength = max(0, target.length - args.length);
+      var boundArgs = [];
+      for (var i = 0; i < boundLength; i++) {
+        boundArgs[i] = "$" + i;
+      }
+      bound = Function("binder", "return function (" + joiny(boundArgs, ",") + "){ return binder.apply(this,arguments); }")(binder);
+      if (target.prototype) {
+        var Empty = function Empty2() {
+        };
+        Empty.prototype = target.prototype;
+        bound.prototype = new Empty();
+        Empty.prototype = null;
+      }
+      return bound;
+    };
+  }
+});
+
+// node_modules/function-bind/index.js
+var require_function_bind = __commonJS({
+  "node_modules/function-bind/index.js"(exports2, module2) {
+    "use strict";
+    var implementation = require_implementation();
+    module2.exports = Function.prototype.bind || implementation;
+  }
+});
+
+// node_modules/call-bind-apply-helpers/functionCall.js
+var require_functionCall = __commonJS({
+  "node_modules/call-bind-apply-helpers/functionCall.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Function.prototype.call;
+  }
+});
+
+// node_modules/call-bind-apply-helpers/functionApply.js
+var require_functionApply = __commonJS({
+  "node_modules/call-bind-apply-helpers/functionApply.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Function.prototype.apply;
+  }
+});
+
+// node_modules/call-bind-apply-helpers/reflectApply.js
+var require_reflectApply = __commonJS({
+  "node_modules/call-bind-apply-helpers/reflectApply.js"(exports2, module2) {
+    "use strict";
+    module2.exports = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
+  }
+});
+
+// node_modules/call-bind-apply-helpers/actualApply.js
+var require_actualApply = __commonJS({
+  "node_modules/call-bind-apply-helpers/actualApply.js"(exports2, module2) {
+    "use strict";
+    var bind2 = require_function_bind();
+    var $apply = require_functionApply();
+    var $call = require_functionCall();
+    var $reflectApply = require_reflectApply();
+    module2.exports = $reflectApply || bind2.call($call, $apply);
+  }
+});
+
+// node_modules/call-bind-apply-helpers/index.js
+var require_call_bind_apply_helpers = __commonJS({
+  "node_modules/call-bind-apply-helpers/index.js"(exports2, module2) {
+    "use strict";
+    var bind2 = require_function_bind();
+    var $TypeError = require_type();
+    var $call = require_functionCall();
+    var $actualApply = require_actualApply();
+    module2.exports = function callBindBasic(args) {
+      if (args.length < 1 || typeof args[0] !== "function") {
+        throw new $TypeError("a function is required");
+      }
+      return $actualApply(bind2, $call, args);
+    };
+  }
+});
+
+// node_modules/dunder-proto/get.js
+var require_get = __commonJS({
+  "node_modules/dunder-proto/get.js"(exports2, module2) {
+    "use strict";
+    var callBind = require_call_bind_apply_helpers();
+    var gOPD = require_gopd();
+    var hasProtoAccessor;
+    try {
+      hasProtoAccessor = /** @type {{ __proto__?: typeof Array.prototype }} */
+      [].__proto__ === Array.prototype;
+    } catch (e) {
+      if (!e || typeof e !== "object" || !("code" in e) || e.code !== "ERR_PROTO_ACCESS") {
+        throw e;
+      }
+    }
+    var desc = !!hasProtoAccessor && gOPD && gOPD(
+      Object.prototype,
+      /** @type {keyof typeof Object.prototype} */
+      "__proto__"
+    );
+    var $Object = Object;
+    var $getPrototypeOf = $Object.getPrototypeOf;
+    module2.exports = desc && typeof desc.get === "function" ? callBind([desc.get]) : typeof $getPrototypeOf === "function" ? (
+      /** @type {import('./get')} */
+      function getDunder(value) {
+        return $getPrototypeOf(value == null ? value : $Object(value));
+      }
+    ) : false;
+  }
+});
+
+// node_modules/get-proto/index.js
+var require_get_proto = __commonJS({
+  "node_modules/get-proto/index.js"(exports2, module2) {
+    "use strict";
+    var reflectGetProto = require_Reflect_getPrototypeOf();
+    var originalGetProto = require_Object_getPrototypeOf();
+    var getDunderProto = require_get();
+    module2.exports = reflectGetProto ? function getProto(O) {
+      return reflectGetProto(O);
+    } : originalGetProto ? function getProto(O) {
+      if (!O || typeof O !== "object" && typeof O !== "function") {
+        throw new TypeError("getProto: not an object");
+      }
+      return originalGetProto(O);
+    } : getDunderProto ? function getProto(O) {
+      return getDunderProto(O);
+    } : null;
+  }
+});
+
+// node_modules/hasown/index.js
+var require_hasown = __commonJS({
+  "node_modules/hasown/index.js"(exports2, module2) {
+    "use strict";
+    var call = Function.prototype.call;
+    var $hasOwn = Object.prototype.hasOwnProperty;
+    var bind2 = require_function_bind();
+    module2.exports = bind2.call(call, $hasOwn);
+  }
+});
+
+// node_modules/get-intrinsic/index.js
+var require_get_intrinsic = __commonJS({
+  "node_modules/get-intrinsic/index.js"(exports2, module2) {
+    "use strict";
+    var undefined2;
+    var $Object = require_es_object_atoms();
+    var $Error = require_es_errors();
+    var $EvalError = require_eval();
+    var $RangeError = require_range();
+    var $ReferenceError = require_ref();
+    var $SyntaxError = require_syntax();
+    var $TypeError = require_type();
+    var $URIError = require_uri();
+    var abs = require_abs();
+    var floor = require_floor();
+    var max = require_max();
+    var min = require_min();
+    var pow = require_pow();
+    var round = require_round();
+    var sign = require_sign();
+    var $Function = Function;
+    var getEvalledConstructor = function(expressionSyntax) {
+      try {
+        return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
+      } catch (e) {
+      }
+    };
+    var $gOPD = require_gopd();
+    var $defineProperty = require_es_define_property();
+    var throwTypeError = function() {
+      throw new $TypeError();
+    };
+    var ThrowTypeError = $gOPD ? function() {
+      try {
+        arguments.callee;
+        return throwTypeError;
+      } catch (calleeThrows) {
+        try {
+          return $gOPD(arguments, "callee").get;
+        } catch (gOPDthrows) {
+          return throwTypeError;
+        }
+      }
+    }() : throwTypeError;
+    var hasSymbols = require_has_symbols()();
+    var getProto = require_get_proto();
+    var $ObjectGPO = require_Object_getPrototypeOf();
+    var $ReflectGPO = require_Reflect_getPrototypeOf();
+    var $apply = require_functionApply();
+    var $call = require_functionCall();
+    var needsEval = {};
+    var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined2 : getProto(Uint8Array);
+    var INTRINSICS = {
+      __proto__: null,
+      "%AggregateError%": typeof AggregateError === "undefined" ? undefined2 : AggregateError,
+      "%Array%": Array,
+      "%ArrayBuffer%": typeof ArrayBuffer === "undefined" ? undefined2 : ArrayBuffer,
+      "%ArrayIteratorPrototype%": hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined2,
+      "%AsyncFromSyncIteratorPrototype%": undefined2,
+      "%AsyncFunction%": needsEval,
+      "%AsyncGenerator%": needsEval,
+      "%AsyncGeneratorFunction%": needsEval,
+      "%AsyncIteratorPrototype%": needsEval,
+      "%Atomics%": typeof Atomics === "undefined" ? undefined2 : Atomics,
+      "%BigInt%": typeof BigInt === "undefined" ? undefined2 : BigInt,
+      "%BigInt64Array%": typeof BigInt64Array === "undefined" ? undefined2 : BigInt64Array,
+      "%BigUint64Array%": typeof BigUint64Array === "undefined" ? undefined2 : BigUint64Array,
+      "%Boolean%": Boolean,
+      "%DataView%": typeof DataView === "undefined" ? undefined2 : DataView,
+      "%Date%": Date,
+      "%decodeURI%": decodeURI,
+      "%decodeURIComponent%": decodeURIComponent,
+      "%encodeURI%": encodeURI,
+      "%encodeURIComponent%": encodeURIComponent,
+      "%Error%": $Error,
+      "%eval%": eval,
+      // eslint-disable-line no-eval
+      "%EvalError%": $EvalError,
+      "%Float16Array%": typeof Float16Array === "undefined" ? undefined2 : Float16Array,
+      "%Float32Array%": typeof Float32Array === "undefined" ? undefined2 : Float32Array,
+      "%Float64Array%": typeof Float64Array === "undefined" ? undefined2 : Float64Array,
+      "%FinalizationRegistry%": typeof FinalizationRegistry === "undefined" ? undefined2 : FinalizationRegistry,
+      "%Function%": $Function,
+      "%GeneratorFunction%": needsEval,
+      "%Int8Array%": typeof Int8Array === "undefined" ? undefined2 : Int8Array,
+      "%Int16Array%": typeof Int16Array === "undefined" ? undefined2 : Int16Array,
+      "%Int32Array%": typeof Int32Array === "undefined" ? undefined2 : Int32Array,
+      "%isFinite%": isFinite,
+      "%isNaN%": isNaN,
+      "%IteratorPrototype%": hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined2,
+      "%JSON%": typeof JSON === "object" ? JSON : undefined2,
+      "%Map%": typeof Map === "undefined" ? undefined2 : Map,
+      "%MapIteratorPrototype%": typeof Map === "undefined" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Map())[Symbol.iterator]()),
+      "%Math%": Math,
+      "%Number%": Number,
+      "%Object%": $Object,
+      "%Object.getOwnPropertyDescriptor%": $gOPD,
+      "%parseFloat%": parseFloat,
+      "%parseInt%": parseInt,
+      "%Promise%": typeof Promise === "undefined" ? undefined2 : Promise,
+      "%Proxy%": typeof Proxy === "undefined" ? undefined2 : Proxy,
+      "%RangeError%": $RangeError,
+      "%ReferenceError%": $ReferenceError,
+      "%Reflect%": typeof Reflect === "undefined" ? undefined2 : Reflect,
+      "%RegExp%": RegExp,
+      "%Set%": typeof Set === "undefined" ? undefined2 : Set,
+      "%SetIteratorPrototype%": typeof Set === "undefined" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Set())[Symbol.iterator]()),
+      "%SharedArrayBuffer%": typeof SharedArrayBuffer === "undefined" ? undefined2 : SharedArrayBuffer,
+      "%String%": String,
+      "%StringIteratorPrototype%": hasSymbols && getProto ? getProto(""[Symbol.iterator]()) : undefined2,
+      "%Symbol%": hasSymbols ? Symbol : undefined2,
+      "%SyntaxError%": $SyntaxError,
+      "%ThrowTypeError%": ThrowTypeError,
+      "%TypedArray%": TypedArray,
+      "%TypeError%": $TypeError,
+      "%Uint8Array%": typeof Uint8Array === "undefined" ? undefined2 : Uint8Array,
+      "%Uint8ClampedArray%": typeof Uint8ClampedArray === "undefined" ? undefined2 : Uint8ClampedArray,
+      "%Uint16Array%": typeof Uint16Array === "undefined" ? undefined2 : Uint16Array,
+      "%Uint32Array%": typeof Uint32Array === "undefined" ? undefined2 : Uint32Array,
+      "%URIError%": $URIError,
+      "%WeakMap%": typeof WeakMap === "undefined" ? undefined2 : WeakMap,
+      "%WeakRef%": typeof WeakRef === "undefined" ? undefined2 : WeakRef,
+      "%WeakSet%": typeof WeakSet === "undefined" ? undefined2 : WeakSet,
+      "%Function.prototype.call%": $call,
+      "%Function.prototype.apply%": $apply,
+      "%Object.defineProperty%": $defineProperty,
+      "%Object.getPrototypeOf%": $ObjectGPO,
+      "%Math.abs%": abs,
+      "%Math.floor%": floor,
+      "%Math.max%": max,
+      "%Math.min%": min,
+      "%Math.pow%": pow,
+      "%Math.round%": round,
+      "%Math.sign%": sign,
+      "%Reflect.getPrototypeOf%": $ReflectGPO
+    };
+    if (getProto) {
+      try {
+        null.error;
+      } catch (e) {
+        errorProto = getProto(getProto(e));
+        INTRINSICS["%Error.prototype%"] = errorProto;
+      }
+    }
+    var errorProto;
+    var doEval = function doEval2(name) {
+      var value;
+      if (name === "%AsyncFunction%") {
+        value = getEvalledConstructor("async function () {}");
+      } else if (name === "%GeneratorFunction%") {
+        value = getEvalledConstructor("function* () {}");
+      } else if (name === "%AsyncGeneratorFunction%") {
+        value = getEvalledConstructor("async function* () {}");
+      } else if (name === "%AsyncGenerator%") {
+        var fn = doEval2("%AsyncGeneratorFunction%");
+        if (fn) {
+          value = fn.prototype;
+        }
+      } else if (name === "%AsyncIteratorPrototype%") {
+        var gen = doEval2("%AsyncGenerator%");
+        if (gen && getProto) {
+          value = getProto(gen.prototype);
+        }
+      }
+      INTRINSICS[name] = value;
+      return value;
+    };
+    var LEGACY_ALIASES = {
+      __proto__: null,
+      "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"],
+      "%ArrayPrototype%": ["Array", "prototype"],
+      "%ArrayProto_entries%": ["Array", "prototype", "entries"],
+      "%ArrayProto_forEach%": ["Array", "prototype", "forEach"],
+      "%ArrayProto_keys%": ["Array", "prototype", "keys"],
+      "%ArrayProto_values%": ["Array", "prototype", "values"],
+      "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"],
+      "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"],
+      "%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype", "prototype"],
+      "%BooleanPrototype%": ["Boolean", "prototype"],
+      "%DataViewPrototype%": ["DataView", "prototype"],
+      "%DatePrototype%": ["Date", "prototype"],
+      "%ErrorPrototype%": ["Error", "prototype"],
+      "%EvalErrorPrototype%": ["EvalError", "prototype"],
+      "%Float32ArrayPrototype%": ["Float32Array", "prototype"],
+      "%Float64ArrayPrototype%": ["Float64Array", "prototype"],
+      "%FunctionPrototype%": ["Function", "prototype"],
+      "%Generator%": ["GeneratorFunction", "prototype"],
+      "%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"],
+      "%Int8ArrayPrototype%": ["Int8Array", "prototype"],
+      "%Int16ArrayPrototype%": ["Int16Array", "prototype"],
+      "%Int32ArrayPrototype%": ["Int32Array", "prototype"],
+      "%JSONParse%": ["JSON", "parse"],
+      "%JSONStringify%": ["JSON", "stringify"],
+      "%MapPrototype%": ["Map", "prototype"],
+      "%NumberPrototype%": ["Number", "prototype"],
+      "%ObjectPrototype%": ["Object", "prototype"],
+      "%ObjProto_toString%": ["Object", "prototype", "toString"],
+      "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"],
+      "%PromisePrototype%": ["Promise", "prototype"],
+      "%PromiseProto_then%": ["Promise", "prototype", "then"],
+      "%Promise_all%": ["Promise", "all"],
+      "%Promise_reject%": ["Promise", "reject"],
+      "%Promise_resolve%": ["Promise", "resolve"],
+      "%RangeErrorPrototype%": ["RangeError", "prototype"],
+      "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"],
+      "%RegExpPrototype%": ["RegExp", "prototype"],
+      "%SetPrototype%": ["Set", "prototype"],
+      "%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"],
+      "%StringPrototype%": ["String", "prototype"],
+      "%SymbolPrototype%": ["Symbol", "prototype"],
+      "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"],
+      "%TypedArrayPrototype%": ["TypedArray", "prototype"],
+      "%TypeErrorPrototype%": ["TypeError", "prototype"],
+      "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"],
+      "%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"],
+      "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"],
+      "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"],
+      "%URIErrorPrototype%": ["URIError", "prototype"],
+      "%WeakMapPrototype%": ["WeakMap", "prototype"],
+      "%WeakSetPrototype%": ["WeakSet", "prototype"]
+    };
+    var bind2 = require_function_bind();
+    var hasOwn = require_hasown();
+    var $concat = bind2.call($call, Array.prototype.concat);
+    var $spliceApply = bind2.call($apply, Array.prototype.splice);
+    var $replace = bind2.call($call, String.prototype.replace);
+    var $strSlice = bind2.call($call, String.prototype.slice);
+    var $exec = bind2.call($call, RegExp.prototype.exec);
+    var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
+    var reEscapeChar = /\\(\\)?/g;
+    var stringToPath = function stringToPath2(string) {
+      var first = $strSlice(string, 0, 1);
+      var last = $strSlice(string, -1);
+      if (first === "%" && last !== "%") {
+        throw new $SyntaxError("invalid intrinsic syntax, expected closing `%`");
+      } else if (last === "%" && first !== "%") {
+        throw new $SyntaxError("invalid intrinsic syntax, expected opening `%`");
+      }
+      var result = [];
+      $replace(string, rePropName, function(match, number, quote, subString) {
+        result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number || match;
+      });
+      return result;
+    };
+    var getBaseIntrinsic = function getBaseIntrinsic2(name, allowMissing) {
+      var intrinsicName = name;
+      var alias;
+      if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
+        alias = LEGACY_ALIASES[intrinsicName];
+        intrinsicName = "%" + alias[0] + "%";
+      }
+      if (hasOwn(INTRINSICS, intrinsicName)) {
+        var value = INTRINSICS[intrinsicName];
+        if (value === needsEval) {
+          value = doEval(intrinsicName);
+        }
+        if (typeof value === "undefined" && !allowMissing) {
+          throw new $TypeError("intrinsic " + name + " exists, but is not available. Please file an issue!");
+        }
+        return {
+          alias,
+          name: intrinsicName,
+          value
+        };
+      }
+      throw new $SyntaxError("intrinsic " + name + " does not exist!");
+    };
+    module2.exports = function GetIntrinsic(name, allowMissing) {
+      if (typeof name !== "string" || name.length === 0) {
+        throw new $TypeError("intrinsic name must be a non-empty string");
+      }
+      if (arguments.length > 1 && typeof allowMissing !== "boolean") {
+        throw new $TypeError('"allowMissing" argument must be a boolean');
+      }
+      if ($exec(/^%?[^%]*%?$/, name) === null) {
+        throw new $SyntaxError("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
+      }
+      var parts = stringToPath(name);
+      var intrinsicBaseName = parts.length > 0 ? parts[0] : "";
+      var intrinsic = getBaseIntrinsic("%" + intrinsicBaseName + "%", allowMissing);
+      var intrinsicRealName = intrinsic.name;
+      var value = intrinsic.value;
+      var skipFurtherCaching = false;
+      var alias = intrinsic.alias;
+      if (alias) {
+        intrinsicBaseName = alias[0];
+        $spliceApply(parts, $concat([0, 1], alias));
+      }
+      for (var i = 1, isOwn = true; i < parts.length; i += 1) {
+        var part = parts[i];
+        var first = $strSlice(part, 0, 1);
+        var last = $strSlice(part, -1);
+        if ((first === '"' || first === "'" || first === "`" || (last === '"' || last === "'" || last === "`")) && first !== last) {
+          throw new $SyntaxError("property names with quotes must have matching quotes");
+        }
+        if (part === "constructor" || !isOwn) {
+          skipFurtherCaching = true;
+        }
+        intrinsicBaseName += "." + part;
+        intrinsicRealName = "%" + intrinsicBaseName + "%";
+        if (hasOwn(INTRINSICS, intrinsicRealName)) {
+          value = INTRINSICS[intrinsicRealName];
+        } else if (value != null) {
+          if (!(part in value)) {
+            if (!allowMissing) {
+              throw new $TypeError("base intrinsic for " + name + " exists, but the property is not available.");
+            }
+            return void undefined2;
+          }
+          if ($gOPD && i + 1 >= parts.length) {
+            var desc = $gOPD(value, part);
+            isOwn = !!desc;
+            if (isOwn && "get" in desc && !("originalValue" in desc.get)) {
+              value = desc.get;
+            } else {
+              value = value[part];
+            }
+          } else {
+            isOwn = hasOwn(value, part);
+            value = value[part];
+          }
+          if (isOwn && !skipFurtherCaching) {
+            INTRINSICS[intrinsicRealName] = value;
+          }
+        }
+      }
+      return value;
+    };
+  }
+});
+
+// node_modules/has-tostringtag/shams.js
+var require_shams2 = __commonJS({
+  "node_modules/has-tostringtag/shams.js"(exports2, module2) {
+    "use strict";
+    var hasSymbols = require_shams();
+    module2.exports = function hasToStringTagShams() {
+      return hasSymbols() && !!Symbol.toStringTag;
+    };
+  }
+});
+
+// node_modules/es-set-tostringtag/index.js
+var require_es_set_tostringtag = __commonJS({
+  "node_modules/es-set-tostringtag/index.js"(exports2, module2) {
+    "use strict";
+    var GetIntrinsic = require_get_intrinsic();
+    var $defineProperty = GetIntrinsic("%Object.defineProperty%", true);
+    var hasToStringTag = require_shams2()();
+    var hasOwn = require_hasown();
+    var $TypeError = require_type();
+    var toStringTag = hasToStringTag ? Symbol.toStringTag : null;
+    module2.exports = function setToStringTag(object, value) {
+      var overrideIfSet = arguments.length > 2 && !!arguments[2] && arguments[2].force;
+      var nonConfigurable = arguments.length > 2 && !!arguments[2] && arguments[2].nonConfigurable;
+      if (typeof overrideIfSet !== "undefined" && typeof overrideIfSet !== "boolean" || typeof nonConfigurable !== "undefined" && typeof nonConfigurable !== "boolean") {
+        throw new $TypeError("if provided, the `overrideIfSet` and `nonConfigurable` options must be booleans");
+      }
+      if (toStringTag && (overrideIfSet || !hasOwn(object, toStringTag))) {
+        if ($defineProperty) {
+          $defineProperty(object, toStringTag, {
+            configurable: !nonConfigurable,
+            enumerable: false,
+            value,
+            writable: false
+          });
+        } else {
+          object[toStringTag] = value;
+        }
+      }
+    };
+  }
+});
+
+// node_modules/form-data/lib/populate.js
+var require_populate2 = __commonJS({
+  "node_modules/form-data/lib/populate.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function(dst, src) {
+      Object.keys(src).forEach(function(prop) {
+        dst[prop] = dst[prop] || src[prop];
+      });
+      return dst;
+    };
+  }
+});
+
+// node_modules/form-data/lib/form_data.js
+var require_form_data2 = __commonJS({
+  "node_modules/form-data/lib/form_data.js"(exports2, module2) {
+    "use strict";
+    var CombinedStream = require_combined_stream();
+    var util2 = require("util");
+    var path = require("path");
+    var http2 = require("http");
+    var https3 = require("https");
+    var parseUrl = require("url").parse;
+    var fs = require("fs");
+    var Stream = require("stream").Stream;
+    var crypto3 = require("crypto");
+    var mime = require_mime_types();
+    var asynckit = require_asynckit();
+    var setToStringTag = require_es_set_tostringtag();
+    var hasOwn = require_hasown();
+    var populate = require_populate2();
+    function FormData4(options) {
+      if (!(this instanceof FormData4)) {
+        return new FormData4(options);
+      }
+      this._overheadLength = 0;
+      this._valueLength = 0;
+      this._valuesToMeasure = [];
+      CombinedStream.call(this);
+      options = options || {};
+      for (var option in options) {
+        this[option] = options[option];
+      }
+    }
+    util2.inherits(FormData4, CombinedStream);
+    FormData4.LINE_BREAK = "\r\n";
+    FormData4.DEFAULT_CONTENT_TYPE = "application/octet-stream";
+    FormData4.prototype.append = function(field, value, options) {
+      options = options || {};
+      if (typeof options === "string") {
+        options = { filename: options };
+      }
+      var append2 = CombinedStream.prototype.append.bind(this);
+      if (typeof value === "number" || value == null) {
+        value = String(value);
+      }
+      if (Array.isArray(value)) {
+        this._error(new Error("Arrays are not supported."));
+        return;
+      }
+      var header = this._multiPartHeader(field, value, options);
+      var footer = this._multiPartFooter();
+      append2(header);
+      append2(value);
+      append2(footer);
+      this._trackLength(header, value, options);
+    };
+    FormData4.prototype._trackLength = function(header, value, options) {
+      var valueLength = 0;
+      if (options.knownLength != null) {
+        valueLength += Number(options.knownLength);
+      } else if (Buffer.isBuffer(value)) {
+        valueLength = value.length;
+      } else if (typeof value === "string") {
+        valueLength = Buffer.byteLength(value);
+      }
+      this._valueLength += valueLength;
+      this._overheadLength += Buffer.byteLength(header) + FormData4.LINE_BREAK.length;
+      if (!value || !value.path && !(value.readable && hasOwn(value, "httpVersion")) && !(value instanceof Stream)) {
+        return;
+      }
+      if (!options.knownLength) {
+        this._valuesToMeasure.push(value);
+      }
+    };
+    FormData4.prototype._lengthRetriever = function(value, callback) {
+      if (hasOwn(value, "fd")) {
+        if (value.end != void 0 && value.end != Infinity && value.start != void 0) {
+          callback(null, value.end + 1 - (value.start ? value.start : 0));
+        } else {
+          fs.stat(value.path, function(err, stat) {
+            if (err) {
+              callback(err);
+              return;
+            }
+            var fileSize = stat.size - (value.start ? value.start : 0);
+            callback(null, fileSize);
+          });
+        }
+      } else if (hasOwn(value, "httpVersion")) {
+        callback(null, Number(value.headers["content-length"]));
+      } else if (hasOwn(value, "httpModule")) {
+        value.on("response", function(response) {
+          value.pause();
+          callback(null, Number(response.headers["content-length"]));
+        });
+        value.resume();
+      } else {
+        callback("Unknown stream");
+      }
+    };
+    FormData4.prototype._multiPartHeader = function(field, value, options) {
+      if (typeof options.header === "string") {
+        return options.header;
+      }
+      var contentDisposition = this._getContentDisposition(value, options);
+      var contentType = this._getContentType(value, options);
+      var contents = "";
+      var headers = {
+        // add custom disposition as third element or keep it two elements if not
+        "Content-Disposition": ["form-data", 'name="' + field + '"'].concat(contentDisposition || []),
+        // if no content type. allow it to be empty array
+        "Content-Type": [].concat(contentType || [])
+      };
+      if (typeof options.header === "object") {
+        populate(headers, options.header);
+      }
+      var header;
+      for (var prop in headers) {
+        if (hasOwn(headers, prop)) {
+          header = headers[prop];
+          if (header == null) {
+            continue;
+          }
+          if (!Array.isArray(header)) {
+            header = [header];
+          }
+          if (header.length) {
+            contents += prop + ": " + header.join("; ") + FormData4.LINE_BREAK;
+          }
+        }
+      }
+      return "--" + this.getBoundary() + FormData4.LINE_BREAK + contents + FormData4.LINE_BREAK;
+    };
+    FormData4.prototype._getContentDisposition = function(value, options) {
+      var filename;
+      if (typeof options.filepath === "string") {
+        filename = path.normalize(options.filepath).replace(/\\/g, "/");
+      } else if (options.filename || value && (value.name || value.path)) {
+        filename = path.basename(options.filename || value && (value.name || value.path));
+      } else if (value && value.readable && hasOwn(value, "httpVersion")) {
+        filename = path.basename(value.client._httpMessage.path || "");
+      }
+      if (filename) {
+        return 'filename="' + filename + '"';
+      }
+    };
+    FormData4.prototype._getContentType = function(value, options) {
+      var contentType = options.contentType;
+      if (!contentType && value && value.name) {
+        contentType = mime.lookup(value.name);
+      }
+      if (!contentType && value && value.path) {
+        contentType = mime.lookup(value.path);
+      }
+      if (!contentType && value && value.readable && hasOwn(value, "httpVersion")) {
+        contentType = value.headers["content-type"];
+      }
+      if (!contentType && (options.filepath || options.filename)) {
+        contentType = mime.lookup(options.filepath || options.filename);
+      }
+      if (!contentType && value && typeof value === "object") {
+        contentType = FormData4.DEFAULT_CONTENT_TYPE;
+      }
+      return contentType;
+    };
+    FormData4.prototype._multiPartFooter = function() {
+      return function(next) {
+        var footer = FormData4.LINE_BREAK;
+        var lastPart = this._streams.length === 0;
+        if (lastPart) {
+          footer += this._lastBoundary();
+        }
+        next(footer);
+      }.bind(this);
+    };
+    FormData4.prototype._lastBoundary = function() {
+      return "--" + this.getBoundary() + "--" + FormData4.LINE_BREAK;
+    };
+    FormData4.prototype.getHeaders = function(userHeaders) {
+      var header;
+      var formHeaders = {
+        "content-type": "multipart/form-data; boundary=" + this.getBoundary()
+      };
+      for (header in userHeaders) {
+        if (hasOwn(userHeaders, header)) {
+          formHeaders[header.toLowerCase()] = userHeaders[header];
+        }
+      }
+      return formHeaders;
+    };
+    FormData4.prototype.setBoundary = function(boundary) {
+      if (typeof boundary !== "string") {
+        throw new TypeError("FormData boundary must be a string");
+      }
+      this._boundary = boundary;
+    };
+    FormData4.prototype.getBoundary = function() {
+      if (!this._boundary) {
+        this._generateBoundary();
+      }
+      return this._boundary;
+    };
+    FormData4.prototype.getBuffer = function() {
+      var dataBuffer = new Buffer.alloc(0);
+      var boundary = this.getBoundary();
+      for (var i = 0, len = this._streams.length; i < len; i++) {
+        if (typeof this._streams[i] !== "function") {
+          if (Buffer.isBuffer(this._streams[i])) {
+            dataBuffer = Buffer.concat([dataBuffer, this._streams[i]]);
+          } else {
+            dataBuffer = Buffer.concat([dataBuffer, Buffer.from(this._streams[i])]);
+          }
+          if (typeof this._streams[i] !== "string" || this._streams[i].substring(2, boundary.length + 2) !== boundary) {
+            dataBuffer = Buffer.concat([dataBuffer, Buffer.from(FormData4.LINE_BREAK)]);
+          }
+        }
+      }
+      return Buffer.concat([dataBuffer, Buffer.from(this._lastBoundary())]);
+    };
+    FormData4.prototype._generateBoundary = function() {
+      this._boundary = "--------------------------" + crypto3.randomBytes(12).toString("hex");
+    };
+    FormData4.prototype.getLengthSync = function() {
+      var knownLength = this._overheadLength + this._valueLength;
+      if (this._streams.length) {
+        knownLength += this._lastBoundary().length;
+      }
+      if (!this.hasKnownLength()) {
+        this._error(new Error("Cannot calculate proper length in synchronous way."));
+      }
+      return knownLength;
+    };
+    FormData4.prototype.hasKnownLength = function() {
+      var hasKnownLength = true;
+      if (this._valuesToMeasure.length) {
+        hasKnownLength = false;
+      }
+      return hasKnownLength;
+    };
+    FormData4.prototype.getLength = function(cb) {
+      var knownLength = this._overheadLength + this._valueLength;
+      if (this._streams.length) {
+        knownLength += this._lastBoundary().length;
+      }
+      if (!this._valuesToMeasure.length) {
+        process.nextTick(cb.bind(this, null, knownLength));
+        return;
+      }
+      asynckit.parallel(this._valuesToMeasure, this._lengthRetriever, function(err, values) {
+        if (err) {
+          cb(err);
+          return;
+        }
+        values.forEach(function(length) {
+          knownLength += length;
+        });
+        cb(null, knownLength);
+      });
+    };
+    FormData4.prototype.submit = function(params, cb) {
+      var request;
+      var options;
+      var defaults2 = { method: "post" };
+      if (typeof params === "string") {
+        params = parseUrl(params);
+        options = populate({
+          port: params.port,
+          path: params.pathname,
+          host: params.hostname,
+          protocol: params.protocol
+        }, defaults2);
+      } else {
+        options = populate(params, defaults2);
+        if (!options.port) {
+          options.port = options.protocol === "https:" ? 443 : 80;
+        }
+      }
+      options.headers = this.getHeaders(params.headers);
+      if (options.protocol === "https:") {
+        request = https3.request(options);
+      } else {
+        request = http2.request(options);
+      }
+      this.getLength(function(err, length) {
+        if (err && err !== "Unknown stream") {
+          this._error(err);
+          return;
+        }
+        if (length) {
+          request.setHeader("Content-Length", length);
+        }
+        this.pipe(request);
+        if (cb) {
+          var onResponse;
+          var callback = function(error, responce) {
+            request.removeListener("error", callback);
+            request.removeListener("response", onResponse);
+            return cb.call(this, error, responce);
+          };
+          onResponse = callback.bind(this, null);
+          request.on("error", callback);
+          request.on("response", onResponse);
+        }
+      }.bind(this));
+      return request;
+    };
+    FormData4.prototype._error = function(err) {
+      if (!this.error) {
+        this.error = err;
+        this.pause();
+        this.emit("error", err);
+      }
+    };
+    FormData4.prototype.toString = function() {
+      return "[object FormData]";
+    };
+    setToStringTag(FormData4, "FormData");
+    module2.exports = FormData4;
+  }
+});
+
+// node_modules/isomorphic-ws/node.js
+var require_node2 = __commonJS({
+  "node_modules/isomorphic-ws/node.js"(exports2, module2) {
+    "use strict";
+    module2.exports = require("ws");
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AbstractOfflineDB: () => AbstractOfflineDB,
+  Allow: () => Allow,
+  AllowAll: () => AllowAll,
+  AnyResource: () => AnyResource,
+  AnyRole: () => AnyRole,
+  AttachmentManager: () => AttachmentManager,
+  BasePaginator: () => BasePaginator,
+  BaseSearchSource: () => BaseSearchSource,
+  BaseSearchSourceSync: () => BaseSearchSourceSync,
+  BuiltinPermissions: () => BuiltinPermissions,
+  BuiltinRoles: () => BuiltinRoles,
+  Campaign: () => Campaign,
+  Channel: () => Channel,
+  ChannelManager: () => ChannelManager,
+  ChannelSearchSource: () => ChannelSearchSource,
+  ChannelState: () => ChannelState,
+  CheckSignature: () => CheckSignature,
+  ClientState: () => ClientState,
+  CommandSearchSource: () => CommandSearchSource,
+  CustomDataManager: () => CustomDataManager,
+  DEFAULT_ATTACHMENT_MANAGER_CONFIG: () => DEFAULT_ATTACHMENT_MANAGER_CONFIG,
+  DEFAULT_CHANNEL_MANAGER_OPTIONS: () => DEFAULT_CHANNEL_MANAGER_OPTIONS,
+  DEFAULT_CHANNEL_MANAGER_PAGINATION_OPTIONS: () => DEFAULT_CHANNEL_MANAGER_PAGINATION_OPTIONS,
+  DEFAULT_COMPOSER_CONFIG: () => DEFAULT_COMPOSER_CONFIG,
+  DEFAULT_LINK_PREVIEW_MANAGER_CONFIG: () => DEFAULT_LINK_PREVIEW_MANAGER_CONFIG,
+  DEFAULT_LOCATION_COMPOSER_CONFIG: () => DEFAULT_LOCATION_COMPOSER_CONFIG,
+  DEFAULT_PAGINATION_OPTIONS: () => DEFAULT_PAGINATION_OPTIONS,
+  DEFAULT_REMINDER_MANAGER_CONFIG: () => DEFAULT_REMINDER_MANAGER_CONFIG,
+  DEFAULT_STOP_REFRESH_BOUNDARY_MS: () => DEFAULT_STOP_REFRESH_BOUNDARY_MS,
+  DEFAULT_TEXT_COMPOSER_CONFIG: () => DEFAULT_TEXT_COMPOSER_CONFIG,
+  Deny: () => Deny,
+  DenyAll: () => DenyAll,
+  DevToken: () => DevToken,
+  EVENT_MAP: () => EVENT_MAP,
+  ErrorFromResponse: () => ErrorFromResponse,
+  FixedSizeQueueCache: () => FixedSizeQueueCache,
+  InsightMetrics: () => InsightMetrics,
+  JWTServerToken: () => JWTServerToken,
+  JWTUserToken: () => JWTUserToken,
+  LinkPreviewStatus: () => LinkPreviewStatus,
+  LinkPreviewsManager: () => LinkPreviewsManager,
+  LiveLocationManager: () => LiveLocationManager,
+  LocationComposer: () => LocationComposer,
+  MAX_POLL_OPTIONS: () => MAX_POLL_OPTIONS,
+  MODERATION_ENTITY_TYPES: () => MODERATION_ENTITY_TYPES,
+  MaxPriority: () => MaxPriority,
+  MentionsSearchSource: () => MentionsSearchSource,
+  MergedStateStore: () => MergedStateStore,
+  MessageComposer: () => MessageComposer,
+  MessageComposerMiddlewareExecutor: () => MessageComposerMiddlewareExecutor,
+  MessageDraftComposerMiddlewareExecutor: () => MessageDraftComposerMiddlewareExecutor,
+  MessageSearchSource: () => MessageSearchSource,
+  MiddlewareExecutor: () => MiddlewareExecutor,
+  MinPriority: () => MinPriority,
+  Moderation: () => Moderation,
+  NotificationManager: () => NotificationManager,
+  OfflineDBSyncManager: () => OfflineDBSyncManager,
+  OfflineError: () => OfflineError,
+  Permission: () => Permission,
+  Poll: () => Poll,
+  PollComposer: () => PollComposer,
+  PollComposerCompositionMiddlewareExecutor: () => PollComposerCompositionMiddlewareExecutor,
+  PollComposerStateMiddlewareExecutor: () => PollComposerStateMiddlewareExecutor,
+  PollManager: () => PollManager,
+  Product: () => Product,
+  Reminder: () => Reminder,
+  ReminderManager: () => ReminderManager,
+  ReminderPaginator: () => ReminderPaginator,
+  ReminderTimer: () => ReminderTimer,
+  SearchController: () => SearchController,
+  Segment: () => Segment,
+  StableWSConnection: () => StableWSConnection,
+  StateStore: () => StateStore,
+  StreamChat: () => StreamChat,
+  THREAD_MANAGER_INITIAL_STATE: () => THREAD_MANAGER_INITIAL_STATE,
+  TextComposer: () => TextComposer,
+  TextComposerMiddlewareExecutor: () => TextComposerMiddlewareExecutor,
+  Thread: () => Thread,
+  ThreadManager: () => ThreadManager,
+  TokenManager: () => TokenManager,
+  UPDATE_LIVE_LOCATION_REQUEST_MIN_THROTTLE_TIMEOUT: () => UPDATE_LIVE_LOCATION_REQUEST_MIN_THROTTLE_TIMEOUT,
+  UserFromToken: () => UserFromToken,
+  UserSearchSource: () => UserSearchSource,
+  VALID_MAX_VOTES_VALUE_REGEX: () => VALID_MAX_VOTES_VALUE_REGEX,
+  VotingVisibility: () => VotingVisibility,
+  accentsMap: () => accentsMap,
+  buildWsFatalInsight: () => buildWsFatalInsight,
+  buildWsSuccessAfterFailureInsight: () => buildWsSuccessAfterFailureInsight,
+  calculateLevenshtein: () => calculateLevenshtein,
+  channelManagerEventToHandlerMapping: () => channelManagerEventToHandlerMapping,
+  chatCodes: () => chatCodes,
+  createActiveCommandGuardMiddleware: () => createActiveCommandGuardMiddleware,
+  createAttachmentsCompositionMiddleware: () => createAttachmentsCompositionMiddleware,
+  createCommandInjectionMiddleware: () => createCommandInjectionMiddleware,
+  createCommandStringExtractionMiddleware: () => createCommandStringExtractionMiddleware,
+  createCommandsMiddleware: () => createCommandsMiddleware,
+  createCompositionDataCleanupMiddleware: () => createCompositionDataCleanupMiddleware,
+  createCompositionValidationMiddleware: () => createCompositionValidationMiddleware,
+  createCustomDataCompositionMiddleware: () => createCustomDataCompositionMiddleware,
+  createDraftAttachmentsCompositionMiddleware: () => createDraftAttachmentsCompositionMiddleware,
+  createDraftCommandInjectionMiddleware: () => createDraftCommandInjectionMiddleware,
+  createDraftCompositionValidationMiddleware: () => createDraftCompositionValidationMiddleware,
+  createDraftCustomDataCompositionMiddleware: () => createDraftCustomDataCompositionMiddleware,
+  createDraftLinkPreviewsCompositionMiddleware: () => createDraftLinkPreviewsCompositionMiddleware,
+  createDraftMessageComposerStateCompositionMiddleware: () => createDraftMessageComposerStateCompositionMiddleware,
+  createDraftTextComposerCompositionMiddleware: () => createDraftTextComposerCompositionMiddleware,
+  createFileFromBlobs: () => createFileFromBlobs,
+  createLinkPreviewsCompositionMiddleware: () => createLinkPreviewsCompositionMiddleware,
+  createMentionsMiddleware: () => createMentionsMiddleware,
+  createMessageComposerStateCompositionMiddleware: () => createMessageComposerStateCompositionMiddleware,
+  createPollComposerStateMiddleware: () => createPollComposerStateMiddleware,
+  createSharedLocationCompositionMiddleware: () => createSharedLocationCompositionMiddleware,
+  createTextComposerCompositionMiddleware: () => createTextComposerCompositionMiddleware,
+  createTextComposerPreValidationMiddleware: () => createTextComposerPreValidationMiddleware,
+  decodeBase64: () => decodeBase64,
+  defaultPollFieldBlurEventValidators: () => defaultPollFieldBlurEventValidators,
+  defaultPollFieldChangeEventValidators: () => defaultPollFieldChangeEventValidators,
+  encodeBase64: () => encodeBase64,
+  ensureIsLocalAttachment: () => ensureIsLocalAttachment,
+  escapeRegExp: () => escapeRegExp,
+  extractPollData: () => extractPollData,
+  extractPollEnrichedData: () => extractPollEnrichedData,
+  formatMessage: () => formatMessage,
+  generateFileName: () => generateFileName,
+  getAttachmentTypeFromMimeType: () => getAttachmentTypeFromMimeType,
+  getCompleteCommandInString: () => getCompleteCommandInString,
+  getExtensionFromMimeType: () => getExtensionFromMimeType,
+  getTokenizedSuggestionDisplayName: () => getTokenizedSuggestionDisplayName,
+  getTriggerCharWithToken: () => getTriggerCharWithToken,
+  insertItemWithTrigger: () => insertItemWithTrigger,
+  isAudioAttachment: () => isAudioAttachment,
+  isBlobButNotFile: () => isBlobButNotFile,
+  isFile: () => isFile2,
+  isFileAttachment: () => isFileAttachment,
+  isFileList: () => isFileList2,
+  isFileReference: () => isFileReference,
+  isImageAttachment: () => isImageAttachment,
+  isImageFile: () => isImageFile,
+  isLocalAttachment: () => isLocalAttachment,
+  isLocalAudioAttachment: () => isLocalAudioAttachment,
+  isLocalFileAttachment: () => isLocalFileAttachment,
+  isLocalImageAttachment: () => isLocalImageAttachment,
+  isLocalUploadAttachment: () => isLocalUploadAttachment,
+  isLocalVideoAttachment: () => isLocalVideoAttachment,
+  isLocalVoiceRecordingAttachment: () => isLocalVoiceRecordingAttachment,
+  isOwnUser: () => isOwnUser,
+  isPatch: () => isPatch,
+  isScrapedContent: () => isScrapedContent,
+  isSharedLocationResponse: () => isSharedLocationResponse,
+  isTargetedOptionTextUpdate: () => isTargetedOptionTextUpdate,
+  isUploadedAttachment: () => isUploadedAttachment,
+  isVideoAttachment: () => isVideoAttachment,
+  isVoiceRecordingAttachment: () => isVoiceRecordingAttachment,
+  isVoteAnswer: () => isVoteAnswer,
+  localMessageToNewMessagePayload: () => localMessageToNewMessagePayload,
+  logChatPromiseExecution: () => logChatPromiseExecution,
+  mapPollStateToResponse: () => mapPollStateToResponse,
+  pollCompositionStateProcessors: () => pollCompositionStateProcessors,
+  pollStateChangeValidators: () => pollStateChangeValidators,
+  postInsights: () => postInsights,
+  promoteChannel: () => promoteChannel,
+  readFileAsArrayBuffer: () => readFileAsArrayBuffer,
+  removeDiacritics: () => removeDiacritics,
+  replaceWordWithEntity: () => replaceWordWithEntity,
+  textIsEmpty: () => textIsEmpty,
+  timeLeftMs: () => timeLeftMs
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/base64.ts
+var import_base64_js = __toESM(require_base64_js());
+function isString(arrayOrString) {
+  return typeof arrayOrString === "string";
+}
+function isMapStringCallback(arrayOrString, callback) {
+  return !!callback && isString(arrayOrString);
+}
+function map(arrayOrString, callback) {
+  const res = [];
+  if (isString(arrayOrString) && isMapStringCallback(arrayOrString, callback)) {
+    for (let k = 0, len = arrayOrString.length; k < len; k++) {
+      if (arrayOrString.charAt(k)) {
+        const kValue = arrayOrString.charAt(k);
+        const mappedValue = callback(kValue, k, arrayOrString);
+        res[k] = mappedValue;
+      }
+    }
+  } else if (!isString(arrayOrString) && !isMapStringCallback(arrayOrString, callback)) {
+    for (let k = 0, len = arrayOrString.length; k < len; k++) {
+      if (k in arrayOrString) {
+        const kValue = arrayOrString[k];
+        const mappedValue = callback(kValue, k, arrayOrString);
+        res[k] = mappedValue;
+      }
+    }
+  }
+  return res;
+}
+var encodeBase64 = (data) => (0, import_base64_js.fromByteArray)(new Uint8Array(map(data, (char) => char.charCodeAt(0))));
+var decodeBase64 = (s) => {
+  const e = {}, w = String.fromCharCode, L = s.length;
+  let i, b = 0, c, x, l = 0, a, r = "";
+  const A = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  for (i = 0; i < 64; i++) {
+    e[A.charAt(i)] = i;
+  }
+  for (x = 0; x < L; x++) {
+    c = e[s.charAt(x)];
+    b = (b << 6) + c;
+    l += 6;
+    while (l >= 8) {
+      ((a = b >>> (l -= 8) & 255) || x < L - 2) && (r += w(a));
+    }
+  }
+  return r;
+};
+
+// src/campaign.ts
+var Campaign = class {
+  constructor(client, id, data) {
+    this.client = client;
+    this.id = id;
+    this.data = data;
+  }
+  async create() {
+    const body = {
+      id: this.id,
+      message_template: this.data?.message_template,
+      segment_ids: this.data?.segment_ids,
+      sender_id: this.data?.sender_id,
+      sender_mode: this.data?.sender_mode,
+      channel_template: this.data?.channel_template,
+      create_channels: this.data?.create_channels,
+      show_channels: this.data?.show_channels,
+      description: this.data?.description,
+      name: this.data?.name,
+      skip_push: this.data?.skip_push,
+      skip_webhook: this.data?.skip_webhook,
+      user_ids: this.data?.user_ids
+    };
+    const result = await this.client.createCampaign(body);
     this.id = result.campaign.id;
     this.data = result.campaign;
     return result;
@@ -13885,7 +15063,7 @@ var {
 var import_https2 = __toESM(require("https"));
 
 // src/utils.ts
-var import_form_data2 = __toESM(require_form_data());
+var import_form_data2 = __toESM(require_form_data2());
 
 // src/constants.ts
 var DEFAULT_QUERY_CHANNELS_MESSAGE_LIST_PAGE_SIZE = 25;
@@ -14494,7 +15672,8 @@ var messagePaginationLinear = ({
   return newPagination;
 };
 var messageSetPagination = (params) => {
-  if (params.parentSet.messages.length < params.returnedPage.length) {
+  const messagesFilteredLocally = params.returnedPage.filter(({ shadowed }) => shadowed);
+  if (params.parentSet.messages.length + messagesFilteredLocally.length < params.returnedPage.length) {
     params.logger?.(
       "error",
       "Corrupted message set state: parent set size < returned page size"
@@ -15416,19 +16595,307 @@ var getAttachmentTypeFromMimeType = (mimeType) => {
   if (mimeType.includes("audio/")) return "audio";
   return "file";
 };
-var ensureIsLocalAttachment = (attachment) => {
-  if (!attachment) return null;
-  if (isLocalAttachment(attachment)) {
-    return attachment;
+var ensureIsLocalAttachment = (attachment) => {
+  if (!attachment) return null;
+  if (isLocalAttachment(attachment)) {
+    return attachment;
+  }
+  const { localMetadata, ...rest } = attachment;
+  return {
+    localMetadata: {
+      ...localMetadata ?? {},
+      id: localMetadata?.id || generateUUIDv4()
+    },
+    ...rest
+  };
+};
+
+// src/messageComposer/middleware/attachmentManager/postUpload/attachmentEnrichment.ts
+var createPostUploadAttachmentEnrichmentMiddleware = () => ({
+  id: "stream-io/attachment-manager-middleware/post-upload-enrichment",
+  handlers: {
+    postProcess: ({
+      state,
+      discard,
+      forward,
+      next
+    }) => {
+      const { attachment, error, response } = state;
+      if (error) return forward();
+      if (!attachment || !response) return discard();
+      const enrichedAttachment = { ...attachment };
+      if (isLocalImageAttachment(attachment)) {
+        if (attachment.localMetadata.previewUri) {
+          URL.revokeObjectURL(attachment.localMetadata.previewUri);
+          delete enrichedAttachment.localMetadata.previewUri;
+        }
+        enrichedAttachment.image_url = response.file;
+      } else {
+        enrichedAttachment.asset_url = response.file;
+      }
+      if (response.thumb_url) {
+        enrichedAttachment.thumb_url = response.thumb_url;
+      }
+      return next({
+        ...state,
+        attachment: enrichedAttachment
+      });
+    }
+  }
+});
+
+// src/utils/concurrency.ts
+var withoutConcurrency = createRunner(wrapWithContinuationTracking);
+var withCancellation = createRunner(wrapWithCancellation);
+var pendingPromises = /* @__PURE__ */ new Map();
+function createRunner(wrapper) {
+  return function run(tag, cb) {
+    const { cb: wrapped, onContinued } = wrapper(tag, cb);
+    const pending = pendingPromises.get(tag);
+    pending?.onContinued();
+    const promise = pending ? pending.promise.then(wrapped, wrapped) : wrapped();
+    pendingPromises.set(tag, { promise, onContinued });
+    return promise;
+  };
+}
+function wrapWithContinuationTracking(tag, cb) {
+  let hasContinuation = false;
+  const wrapped = () => cb().finally(() => {
+    if (!hasContinuation) {
+      pendingPromises.delete(tag);
+    }
+  });
+  const onContinued = () => hasContinuation = true;
+  return { cb: wrapped, onContinued };
+}
+function wrapWithCancellation(tag, cb) {
+  const ac = new AbortController();
+  const wrapped = () => {
+    if (ac.signal.aborted) {
+      return Promise.resolve("canceled");
+    }
+    return cb(ac.signal).finally(() => {
+      if (!ac.signal.aborted) {
+        pendingPromises.delete(tag);
+      }
+    });
+  };
+  const onContinued = () => ac.abort();
+  return { cb: wrapped, onContinued };
+}
+
+// src/middleware.ts
+var MiddlewareExecutor = class {
+  constructor() {
+    this.middleware = [];
+    this.id = generateUUIDv4();
+  }
+  use(middleware) {
+    this.middleware = this.middleware.concat(middleware);
+    return this;
+  }
+  // todo: document how to re-arrange the order of middleware using replace
+  replace(middleware) {
+    const newMiddleware = [...this.middleware];
+    middleware.forEach((upserted) => {
+      const existingIndex = this.middleware.findIndex(
+        (existing) => existing.id === upserted.id
+      );
+      if (existingIndex >= 0) {
+        newMiddleware.splice(existingIndex, 1, upserted);
+      } else {
+        newMiddleware.push(upserted);
+      }
+    });
+    this.middleware = newMiddleware;
+    return this;
+  }
+  insert({
+    middleware,
+    position,
+    unique
+  }) {
+    if (unique) {
+      middleware.forEach((md) => {
+        const existingMiddlewareIndex = this.middleware.findIndex((m) => m.id === md.id);
+        if (existingMiddlewareIndex >= 0) {
+          this.middleware.splice(existingMiddlewareIndex, 1);
+        }
+      });
+    }
+    const targetId = position.after || position.before;
+    const targetIndex = this.middleware.findIndex((m) => m.id === targetId);
+    const insertionIndex = position.after ? targetIndex + 1 : targetIndex;
+    this.middleware.splice(insertionIndex, 0, ...middleware);
+    return this;
+  }
+  setOrder(order) {
+    this.middleware = order.map((id) => this.middleware.find((middleware) => middleware.id === id)).filter(Boolean);
+  }
+  async executeMiddlewareChain({
+    eventName,
+    initialValue,
+    mode = "cancelable"
+  }) {
+    let index = -1;
+    const execute = async (i, state, status) => {
+      if (i <= index) {
+        throw new Error("next() called multiple times");
+      }
+      index = i;
+      const returnFromChain = i === this.middleware.length || status && ["complete", "discard"].includes(status);
+      if (returnFromChain) return { state, status };
+      const middleware = this.middleware[i];
+      const handler = middleware.handlers[eventName];
+      if (!handler) {
+        return execute(i + 1, state, status);
+      }
+      const next = (adjustedState) => execute(i + 1, adjustedState);
+      const complete = (adjustedState) => execute(i + 1, adjustedState, "complete");
+      const discard = () => execute(i + 1, state, "discard");
+      const forward = () => execute(i + 1, state);
+      return await handler({
+        state,
+        next,
+        complete,
+        discard,
+        forward
+      });
+    };
+    const result = mode === "cancelable" ? await withCancellation(
+      `middleware-execution-${this.id}-${eventName}`,
+      async (abortSignal) => {
+        const result2 = await execute(0, initialValue);
+        if (abortSignal.aborted) {
+          return "canceled";
+        }
+        return result2;
+      }
+    ) : await execute(0, initialValue);
+    return result === "canceled" ? { state: initialValue, status: "discard" } : result;
+  }
+  async execute({
+    eventName,
+    initialValue: initialState,
+    mode
+  }) {
+    return await this.executeMiddlewareChain({
+      eventName,
+      initialValue: initialState,
+      mode
+    });
+  }
+};
+
+// src/messageComposer/middleware/attachmentManager/postUpload/uploadErrorHandler.ts
+var createUploadErrorHandlerMiddleware = (composer) => ({
+  id: "stream-io/attachment-manager-middleware/upload-error",
+  handlers: {
+    postProcess: ({
+      state,
+      discard,
+      forward
+    }) => {
+      const { attachment, error } = state;
+      if (!error) return forward();
+      if (!attachment) return discard();
+      const reason = error instanceof Error ? error.message : "unknown error";
+      composer.client.notifications.addError({
+        message: "Error uploading attachment",
+        origin: {
+          emitter: "AttachmentManager",
+          context: { attachment }
+        },
+        options: {
+          type: "api:attachment:upload:failed",
+          metadata: { reason },
+          originalError: error
+        }
+      });
+      return forward();
+    }
+  }
+});
+
+// src/messageComposer/middleware/attachmentManager/postUpload/AttachmentPostUploadMiddlewareExecutor.ts
+var AttachmentPostUploadMiddlewareExecutor = class extends MiddlewareExecutor {
+  constructor({ composer }) {
+    super();
+    this.use([
+      createUploadErrorHandlerMiddleware(composer),
+      createPostUploadAttachmentEnrichmentMiddleware()
+    ]);
+  }
+};
+
+// src/messageComposer/middleware/attachmentManager/preUpload/serverUploadConfigCheck.ts
+var createUploadConfigCheckMiddleware = (composer) => ({
+  id: "stream-io/attachment-manager-middleware/file-upload-config-check",
+  handlers: {
+    prepare: async ({
+      state,
+      next,
+      discard
+    }) => {
+      const { attachmentManager } = composer;
+      if (!attachmentManager || !state.attachment) return discard();
+      const uploadPermissionCheck = await attachmentManager.getUploadConfigCheck(
+        state.attachment.localMetadata.file
+      );
+      const attachment = {
+        ...state.attachment,
+        localMetadata: {
+          ...state.attachment.localMetadata,
+          uploadPermissionCheck,
+          uploadState: uploadPermissionCheck.uploadBlocked ? "blocked" : "pending"
+        }
+      };
+      return next({
+        ...state,
+        attachment
+      });
+    }
+  }
+});
+
+// src/messageComposer/middleware/attachmentManager/preUpload/blockedUploadNotification.ts
+var createBlockedAttachmentUploadNotificationMiddleware = (composer) => ({
+  id: "stream-io/attachment-manager-middleware/blocked-upload-notification",
+  handlers: {
+    prepare: ({
+      state: { attachment },
+      forward
+    }) => {
+      if (!attachment) return forward();
+      if (attachment.localMetadata.uploadPermissionCheck?.uploadBlocked) {
+        composer.client.notifications.addError({
+          message: `The attachment upload was blocked`,
+          origin: {
+            emitter: "AttachmentManager",
+            context: { blockedAttachment: attachment }
+          },
+          options: {
+            type: "validation:attachment:upload:blocked",
+            metadata: {
+              reason: attachment.localMetadata.uploadPermissionCheck?.reason
+            }
+          }
+        });
+      }
+      return forward();
+    }
+  }
+});
+
+// src/messageComposer/middleware/attachmentManager/preUpload/AttachmentPreUploadMiddlewareExecutor.ts
+var AttachmentPreUploadMiddlewareExecutor = class extends MiddlewareExecutor {
+  constructor({ composer }) {
+    super();
+    this.use([
+      createUploadConfigCheckMiddleware(composer),
+      createBlockedAttachmentUploadNotificationMiddleware(composer)
+    ]);
   }
-  const { localMetadata, ...rest } = attachment;
-  return {
-    localMetadata: {
-      ...localMetadata ?? {},
-      id: localMetadata?.id || generateUUIDv4()
-    },
-    ...rest
-  };
 };
 
 // src/store.ts
@@ -16022,7 +17489,7 @@ var initState = ({
     };
   })
 });
-var AttachmentManager = class {
+var _AttachmentManager = class _AttachmentManager {
   constructor({ composer, message }) {
     this.setCustomUploadFn = (doUploadRequest) => {
       this.composer.updateConfig({ attachments: { doUploadRequest } });
@@ -16129,42 +17596,18 @@ var AttachmentManager = class {
       }
       return { uploadBlocked: false };
     };
+    // @deprecated use AttachmentManager.toLocalUploadAttachment(file)
     this.fileToLocalUploadAttachment = async (fileLike) => {
-      const file = isFileReference(fileLike) || isFile2(fileLike) ? fileLike : createFileFromBlobs({
-        blobsArray: [fileLike],
-        fileName: generateFileName(fileLike.type),
-        mimeType: fileLike.type
-      });
-      const uploadPermissionCheck = await this.getUploadConfigCheck(file);
-      const localAttachment = {
-        file_size: file.size,
-        mime_type: file.type,
-        localMetadata: {
-          file,
-          id: generateUUIDv4(),
-          uploadPermissionCheck,
-          uploadState: uploadPermissionCheck.uploadBlocked ? "blocked" : "pending"
-        },
-        type: getAttachmentTypeFromMimeType(file.type)
-      };
-      localAttachment[isImageFile(file) ? "fallback" : "title"] = file.name;
-      if (isImageFile(file)) {
-        localAttachment.localMetadata.previewUri = isFileReference(fileLike) ? fileLike.uri : URL.createObjectURL?.(fileLike);
-        if (isFileReference(fileLike) && fileLike.height && fileLike.width) {
-          localAttachment.original_height = fileLike.height;
-          localAttachment.original_width = fileLike.width;
-        }
-      }
-      if (isFileReference(fileLike) && fileLike.thumb_url) {
-        localAttachment.thumb_url = fileLike.thumb_url;
-      }
-      if (isFileReference(fileLike) && fileLike.duration) {
-        localAttachment.duration = fileLike.duration;
-      }
+      const localAttachment = _AttachmentManager.toLocalUploadAttachment(fileLike);
+      const uploadPermissionCheck = await this.getUploadConfigCheck(
+        localAttachment.localMetadata.file
+      );
+      localAttachment.localMetadata.uploadPermissionCheck = uploadPermissionCheck;
+      localAttachment.localMetadata.uploadState = uploadPermissionCheck.uploadBlocked ? "blocked" : "pending";
       return localAttachment;
     };
     this.ensureLocalUploadAttachment = async (attachment) => {
-      if (!attachment.localMetadata?.file || !attachment.localMetadata.id) {
+      if (!attachment.localMetadata?.file) {
         this.client.notifications.addError({
           message: "File is required for upload attachment",
           origin: { emitter: "AttachmentManager", context: { attachment } },
@@ -16172,6 +17615,14 @@ var AttachmentManager = class {
         });
         return;
       }
+      if (!attachment.localMetadata.id) {
+        this.client.notifications.addError({
+          message: "Local upload attachment missing local id",
+          origin: { emitter: "AttachmentManager", context: { attachment } },
+          options: { type: "validation:attachment:id:missing" }
+        });
+        return;
+      }
       if (!this.fileUploadFilter(attachment)) return;
       const newAttachment = await this.fileToLocalUploadAttachment(
         attachment.localMetadata.file
@@ -16211,6 +17662,7 @@ var AttachmentManager = class {
       }
       return this.doDefaultUploadRequest(fileLike);
     };
+    // @deprecated use attachmentManager.uploadFile(file)
     this.uploadAttachment = async (attachment) => {
       if (!this.isUploadEnabled) return;
       const localAttachment = await this.ensureLocalUploadAttachment(attachment);
@@ -16294,19 +17746,75 @@ var AttachmentManager = class {
       this.updateAttachment(uploadedAttachment);
       return uploadedAttachment;
     };
+    this.uploadFile = async (file) => {
+      const preUpload = await this.preUploadMiddlewareExecutor.execute({
+        eventName: "prepare",
+        initialValue: {
+          attachment: _AttachmentManager.toLocalUploadAttachment(file)
+        },
+        mode: "concurrent"
+      });
+      let attachment = preUpload.state.attachment;
+      if (preUpload.status === "discard") return attachment;
+      if (!this.fileUploadFilter(attachment)) return attachment;
+      if (attachment.localMetadata.uploadState === "blocked") {
+        this.upsertAttachments([attachment]);
+        return preUpload.state.attachment;
+      }
+      attachment = {
+        ...attachment,
+        localMetadata: {
+          ...attachment.localMetadata,
+          uploadState: "uploading"
+        }
+      };
+      this.upsertAttachments([attachment]);
+      let response;
+      let error;
+      try {
+        response = await this.doUploadRequest(file);
+      } catch (err) {
+        error = err instanceof Error ? err : void 0;
+      }
+      const postUpload = await this.postUploadMiddlewareExecutor.execute({
+        eventName: "postProcess",
+        initialValue: {
+          attachment: {
+            ...attachment,
+            localMetadata: {
+              ...attachment.localMetadata,
+              uploadState: error ? "failed" : "finished"
+            }
+          },
+          error,
+          response
+        },
+        mode: "concurrent"
+      });
+      attachment = postUpload.state.attachment;
+      if (postUpload.status === "discard") {
+        this.removeAttachments([attachment.localMetadata.id]);
+        return attachment;
+      }
+      this.updateAttachment(attachment);
+      return attachment;
+    };
     this.uploadFiles = async (files) => {
       if (!this.isUploadEnabled) return;
       const iterableFiles = isFileList2(files) ? Array.from(files) : files;
-      const attachments = await Promise.all(
-        iterableFiles.map(this.fileToLocalUploadAttachment)
-      );
-      return Promise.all(
-        attachments.filter(this.fileUploadFilter).slice(0, this.availableUploadSlots).map(this.uploadAttachment)
+      return await Promise.all(
+        iterableFiles.slice(0, this.availableUploadSlots).map(this.uploadFile)
       );
     };
     this.composer = composer;
     this.state = new StateStore(initState({ message }));
     this.attachmentsByIdGetterCache = { attachmentsById: {}, attachments: [] };
+    this.preUploadMiddlewareExecutor = new AttachmentPreUploadMiddlewareExecutor({
+      composer
+    });
+    this.postUploadMiddlewareExecutor = new AttachmentPostUploadMiddlewareExecutor({
+      composer
+    });
   }
   get attachmentsById() {
     const { attachments } = this.state.getLatestValue();
@@ -16336,9 +17844,15 @@ var AttachmentManager = class {
   set acceptedFiles(acceptedFiles) {
     this.composer.updateConfig({ attachments: { acceptedFiles } });
   }
+  /*
+  @deprecated attachments can be filtered using injecting pre-upload middleware
+   */
   get fileUploadFilter() {
     return this.config.fileUploadFilter;
   }
+  /*
+  @deprecated attachments can be filtered using injecting pre-upload middleware
+   */
   set fileUploadFilter(fileUploadFilter) {
     this.composer.updateConfig({ attachments: { fileUploadFilter } });
   }
@@ -16385,6 +17899,39 @@ var AttachmentManager = class {
     );
   }
 };
+_AttachmentManager.toLocalUploadAttachment = (fileLike) => {
+  const file = isFileReference(fileLike) || isFile2(fileLike) ? fileLike : createFileFromBlobs({
+    blobsArray: [fileLike],
+    fileName: generateFileName(fileLike.type),
+    mimeType: fileLike.type
+  });
+  const localAttachment = {
+    file_size: file.size,
+    mime_type: file.type,
+    localMetadata: {
+      file,
+      id: generateUUIDv4(),
+      uploadState: "pending"
+    },
+    type: getAttachmentTypeFromMimeType(file.type)
+  };
+  localAttachment[isImageFile(file) ? "fallback" : "title"] = file.name;
+  if (isImageFile(file)) {
+    localAttachment.localMetadata.previewUri = isFileReference(fileLike) ? fileLike.uri : URL.createObjectURL?.(fileLike);
+    if (isFileReference(fileLike) && fileLike.height && fileLike.width) {
+      localAttachment.original_height = fileLike.height;
+      localAttachment.original_width = fileLike.width;
+    }
+  }
+  if (isFileReference(fileLike) && fileLike.thumb_url) {
+    localAttachment.thumb_url = fileLike.thumb_url;
+  }
+  if (isFileReference(fileLike) && fileLike.duration) {
+    localAttachment.duration = fileLike.duration;
+  }
+  return localAttachment;
+};
+var AttachmentManager = _AttachmentManager;
 
 // src/messageComposer/configuration/configuration.ts
 var import_linkifyjs = require("linkifyjs");
@@ -16724,146 +18271,6 @@ var LocationComposer = class {
   }
 };
 
-// src/utils/concurrency.ts
-var withoutConcurrency = createRunner(wrapWithContinuationTracking);
-var withCancellation = createRunner(wrapWithCancellation);
-var pendingPromises = /* @__PURE__ */ new Map();
-function createRunner(wrapper) {
-  return function run(tag, cb) {
-    const { cb: wrapped, onContinued } = wrapper(tag, cb);
-    const pending = pendingPromises.get(tag);
-    pending?.onContinued();
-    const promise = pending ? pending.promise.then(wrapped, wrapped) : wrapped();
-    pendingPromises.set(tag, { promise, onContinued });
-    return promise;
-  };
-}
-function wrapWithContinuationTracking(tag, cb) {
-  let hasContinuation = false;
-  const wrapped = () => cb().finally(() => {
-    if (!hasContinuation) {
-      pendingPromises.delete(tag);
-    }
-  });
-  const onContinued = () => hasContinuation = true;
-  return { cb: wrapped, onContinued };
-}
-function wrapWithCancellation(tag, cb) {
-  const ac = new AbortController();
-  const wrapped = () => {
-    if (ac.signal.aborted) {
-      return Promise.resolve("canceled");
-    }
-    return cb(ac.signal).finally(() => {
-      if (!ac.signal.aborted) {
-        pendingPromises.delete(tag);
-      }
-    });
-  };
-  const onContinued = () => ac.abort();
-  return { cb: wrapped, onContinued };
-}
-
-// src/middleware.ts
-var MiddlewareExecutor = class {
-  constructor() {
-    this.middleware = [];
-    this.id = generateUUIDv4();
-  }
-  use(middleware) {
-    this.middleware = this.middleware.concat(middleware);
-    return this;
-  }
-  // todo: document how to re-arrange the order of middleware using replace
-  replace(middleware) {
-    const newMiddleware = [...this.middleware];
-    middleware.forEach((upserted) => {
-      const existingIndex = this.middleware.findIndex(
-        (existing) => existing.id === upserted.id
-      );
-      if (existingIndex >= 0) {
-        newMiddleware.splice(existingIndex, 1, upserted);
-      } else {
-        newMiddleware.push(upserted);
-      }
-    });
-    this.middleware = newMiddleware;
-    return this;
-  }
-  insert({
-    middleware,
-    position,
-    unique
-  }) {
-    if (unique) {
-      middleware.forEach((md) => {
-        const existingMiddlewareIndex = this.middleware.findIndex((m) => m.id === md.id);
-        if (existingMiddlewareIndex >= 0) {
-          this.middleware.splice(existingMiddlewareIndex, 1);
-        }
-      });
-    }
-    const targetId = position.after || position.before;
-    const targetIndex = this.middleware.findIndex((m) => m.id === targetId);
-    const insertionIndex = position.after ? targetIndex + 1 : targetIndex;
-    this.middleware.splice(insertionIndex, 0, ...middleware);
-    return this;
-  }
-  setOrder(order) {
-    this.middleware = order.map((id) => this.middleware.find((middleware) => middleware.id === id)).filter(Boolean);
-  }
-  async executeMiddlewareChain({
-    eventName,
-    initialValue
-  }) {
-    let index = -1;
-    const execute = async (i, state, status) => {
-      if (i <= index) {
-        throw new Error("next() called multiple times");
-      }
-      index = i;
-      const returnFromChain = i === this.middleware.length || status && ["complete", "discard"].includes(status);
-      if (returnFromChain) return { state, status };
-      const middleware = this.middleware[i];
-      const handler = middleware.handlers[eventName];
-      if (!handler) {
-        return execute(i + 1, state, status);
-      }
-      const next = (adjustedState) => execute(i + 1, adjustedState);
-      const complete = (adjustedState) => execute(i + 1, adjustedState, "complete");
-      const discard = () => execute(i + 1, state, "discard");
-      const forward = () => execute(i + 1, state);
-      return await handler({
-        state,
-        next,
-        complete,
-        discard,
-        forward
-      });
-    };
-    const result = await withCancellation(
-      `middleware-execution-${this.id}-${eventName}`,
-      async (abortSignal) => {
-        const result2 = await execute(0, initialValue);
-        if (abortSignal.aborted) {
-          return "canceled";
-        }
-        return result2;
-      }
-    );
-    return result === "canceled" ? { state: initialValue, status: "discard" } : result;
-  }
-  async execute({
-    eventName,
-    initialValue: initialState
-  }) {
-    return await this.executeMiddlewareChain({
-      eventName,
-      initialValue: initialState
-    });
-  }
-};
-
 // src/messageComposer/middleware/pollComposer/state.ts
 var VALID_MAX_VOTES_VALUE_REGEX = /^([2-9]|10)$/;
 var MAX_POLL_OPTIONS = 100;
@@ -19798,7 +21205,7 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
             id: this.id,
             mentioned_users: [],
             parent_id: this.threadId ?? void 0,
-            pinned_at: null,
+            pinned_at: this.editedMessage?.pinned_at || null,
             reaction_groups: null,
             status: this.editedMessage ? this.editedMessage.status : "sending",
             text,
@@ -27105,7 +28512,7 @@ var StreamChat = class _StreamChat {
     if (this.userAgent) {
       return this.userAgent;
     }
-    const version = "9.13.0";
+    const version = "9.14.0";
     const clientBundle = "node-cjs";
     let userAgentString = "";
     if (this.sdkIdentifier) {