@scotthamilton77/discord-bot-lib 0.1.0

package/dist/index.cjs

@@ -0,0 +1,766 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Bot: () => Bot,
+  BotOnboarding: () => BotOnboarding,
+  ConnectorManager: () => ConnectorManager,
+  DEFAULT_SENT_MESSAGE_CACHE_SIZE: () => DEFAULT_SENT_MESSAGE_CACHE_SIZE,
+  DISCORD_MAX_MESSAGE_LENGTH: () => DISCORD_MAX_MESSAGE_LENGTH,
+  EventBuffer: () => EventBuffer,
+  MAX_ATTACHMENT_BYTES: () => MAX_ATTACHMENT_BYTES,
+  chunkMessage: () => chunkMessage,
+  downloadAttachment: () => downloadAttachment,
+  sanitizeAttachmentName: () => sanitizeAttachmentName,
+  validateAttachmentSize: () => validateAttachmentSize
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/bot.ts
+var import_discord = require("discord.js");
+var import_promises = require("fs/promises");
+
+// src/event-buffer.ts
+var EventBuffer = class {
+  buffer = [];
+  resolve = null;
+  closed = false;
+  push(value) {
+    if (this.closed) return;
+    if (this.resolve) {
+      const r = this.resolve;
+      this.resolve = null;
+      r({ value, done: false });
+    } else {
+      this.buffer.push(value);
+    }
+  }
+  close() {
+    this.closed = true;
+    if (this.resolve) {
+      const r = this.resolve;
+      this.resolve = null;
+      r({ value: void 0, done: true });
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        if (this.buffer.length > 0) {
+          const value = this.buffer.shift();
+          return Promise.resolve({ value, done: false });
+        }
+        if (this.closed) {
+          return Promise.resolve({
+            value: void 0,
+            done: true
+          });
+        }
+        return new Promise((resolve) => {
+          this.resolve = resolve;
+        });
+      }
+    };
+  }
+};
+
+// src/message-utils.ts
+var DISCORD_MAX_MESSAGE_LENGTH = 2e3;
+function chunkMessage(text, limit = DISCORD_MAX_MESSAGE_LENGTH) {
+  if (!text) return [];
+  if (text.length <= limit) return [text];
+  const chunks = [];
+  const halfLimit = limit / 2;
+  let rest = text;
+  while (rest.length > limit) {
+    const para = rest.lastIndexOf("\n\n", limit);
+    const line = rest.lastIndexOf("\n", limit);
+    const space = rest.lastIndexOf(" ", limit);
+    const cut = para > halfLimit ? para : line > halfLimit ? line : space > 0 ? space : limit;
+    chunks.push(rest.slice(0, cut));
+    rest = rest.slice(cut).replace(/^\n+/, "");
+  }
+  if (rest) chunks.push(rest);
+  return chunks;
+}
+
+// src/attachment-utils.ts
+var MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
+function validateAttachmentSize(attachment) {
+  if (attachment.size > MAX_ATTACHMENT_BYTES) {
+    const actualMB = (attachment.size / 1024 / 1024).toFixed(1);
+    const limitMB = MAX_ATTACHMENT_BYTES / 1024 / 1024;
+    const nameInfo = attachment.name ? `: ${attachment.name}` : "";
+    throw new Error(
+      `Attachment too large (${actualMB} MB > ${String(limitMB)} MB limit)${nameInfo}`
+    );
+  }
+}
+var UNSAFE_CHARS = /[[\]\r\n;]/g;
+function sanitizeAttachmentName(attachment) {
+  const raw = attachment.name;
+  if (!raw || raw.replace(UNSAFE_CHARS, "").length === 0) {
+    return attachment.id;
+  }
+  return raw.replace(UNSAFE_CHARS, "_");
+}
+async function downloadAttachment(attachment) {
+  validateAttachmentSize(attachment);
+  const res = await fetch(attachment.url);
+  if (!res.ok) {
+    throw new Error(
+      `Failed to download attachment: ${String(res.status)} ${res.statusText}`
+    );
+  }
+  const ab = await res.arrayBuffer();
+  const buffer = Buffer.from(ab, 0, ab.byteLength);
+  const filename = sanitizeAttachmentName(attachment);
+  const contentType = attachment.contentType ?? "application/octet-stream";
+  return { buffer, filename, contentType };
+}
+
+// src/bot.ts
+var DEFAULT_SENT_MESSAGE_CACHE_SIZE = 1e3;
+var DEFAULT_INTENTS = [
+  import_discord.GatewayIntentBits.Guilds,
+  import_discord.GatewayIntentBits.GuildMessages,
+  import_discord.GatewayIntentBits.MessageContent,
+  import_discord.GatewayIntentBits.DirectMessages
+];
+var Bot = class _Bot {
+  id;
+  name;
+  _status;
+  client;
+  sentMessages;
+  _connectedAt = null;
+  mentionHandlers = [];
+  replyHandlers = [];
+  channelSubscriptions = /* @__PURE__ */ new Map();
+  errorHandlers = [];
+  _includeBotMessages;
+  constructor(id, name, client, sentMessageCacheSize, includeBotMessages) {
+    this.id = id;
+    this.name = name;
+    this.client = client;
+    this.sentMessages = new import_discord.LimitedCollection({ maxSize: sentMessageCacheSize });
+    this._includeBotMessages = includeBotMessages;
+    this._status = "connecting";
+  }
+  get includeBotMessages() {
+    return this._includeBotMessages;
+  }
+  get status() {
+    return this._status;
+  }
+  get guildCount() {
+    return this.client.guilds.cache.size;
+  }
+  get connectedAt() {
+    return this._connectedAt;
+  }
+  /**
+   * Fast path: create a bot from a complete config, connect, verify, and
+   * return a ready Bot — or throw with diagnostics.
+   */
+  static async fromConfig(config) {
+    const cacheSize = config.sentMessageCacheSize ?? DEFAULT_SENT_MESSAGE_CACHE_SIZE;
+    if (cacheSize < 1 || !Number.isInteger(cacheSize)) {
+      throw new Error(
+        `sentMessageCacheSize must be a positive integer, got ${String(cacheSize)}`
+      );
+    }
+    const includeBotMessages = config.includeBotMessages ?? false;
+    const client = new import_discord.Client({
+      intents: config.intents ?? [...DEFAULT_INTENTS]
+    });
+    const bot = new _Bot(config.id, config.name, client, cacheSize, includeBotMessages);
+    await bot.connect(config.token);
+    bot.verify();
+    bot.setupEventHandlers();
+    bot._status = "ready";
+    bot._connectedAt = /* @__PURE__ */ new Date();
+    return bot;
+  }
+  // --- Sending ---
+  async send(channelId, content) {
+    const channel = await this.fetchTextChannel(channelId);
+    if (!("send" in channel)) {
+      throw new Error(`Channel ${channelId} is not a sendable channel`);
+    }
+    return this.sendPayloads(
+      content,
+      (payload) => channel.send(payload)
+    );
+  }
+  async sendDM(userId, content) {
+    const user = await this.client.users.fetch(userId);
+    return this.sendPayloads(
+      content,
+      (payload) => user.send(payload)
+    );
+  }
+  async reply(channelId, messageId, content) {
+    const channel = await this.fetchTextChannel(channelId);
+    if (!("send" in channel)) {
+      throw new Error(`Channel ${channelId} is not a sendable channel`);
+    }
+    let message;
+    try {
+      message = await channel.messages.fetch(messageId);
+    } catch (error) {
+      throw new Error(
+        `Cannot reply to message ${messageId}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    return this.sendPayloads(content, (payload, i) => {
+      if (i === 0) {
+        return message.reply(payload);
+      }
+      return channel.send(payload);
+    });
+  }
+  // --- Channel operations ---
+  async react(channelId, messageId, emoji) {
+    const channel = await this.fetchTextChannel(channelId);
+    try {
+      const message = await channel.messages.fetch(messageId);
+      await message.react(emoji);
+    } catch (error) {
+      throw new Error(
+        `Cannot react to message ${messageId}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  async editMessage(channelId, messageId, content) {
+    const channel = await this.fetchTextChannel(channelId);
+    try {
+      const message = await channel.messages.fetch(messageId);
+      await message.edit(content);
+    } catch (error) {
+      throw new Error(
+        `Cannot edit message ${messageId}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  async fetchMessages(channelId, limit) {
+    const channel = await this.fetchTextChannel(channelId);
+    const clamped = Math.max(1, Math.min(limit ?? 20, 100));
+    const messages = await channel.messages.fetch({ limit: clamped });
+    return [...messages.values()].reverse().map((m) => this.toFetchedMessage(m));
+  }
+  async *fetchHistory(channelId, options) {
+    const { after, before, limit = 500 } = options;
+    if (after && before) {
+      throw new Error('Cannot specify both "after" and "before"');
+    }
+    let cursor;
+    let direction;
+    if (after) {
+      cursor = after;
+      direction = "after";
+    } else if (before) {
+      cursor = before;
+      direction = "before";
+    } else {
+      throw new Error('At least one of "after" or "before" must be specified');
+    }
+    const effectiveLimit = Math.min(limit, 5e3);
+    const channel = await this.fetchTextChannel(channelId);
+    let totalFetched = 0;
+    while (totalFetched < effectiveLimit) {
+      const pageSize = Math.min(100, effectiveLimit - totalFetched);
+      const fetched = await this.fetchPageWithRetry(channel, {
+        limit: pageSize,
+        [direction]: cursor
+      });
+      if (fetched.size === 0) break;
+      const rawMessages = [...fetched.values()];
+      const messages = rawMessages.map((m) => this.toFetchedMessage(m));
+      yield messages;
+      totalFetched += messages.length;
+      const lastMessage = rawMessages.at(-1);
+      if (!lastMessage) break;
+      cursor = lastMessage.id;
+      if (fetched.size < pageSize) break;
+    }
+  }
+  async getMessageAttachments(channelId, messageId) {
+    const channel = await this.fetchTextChannel(channelId);
+    try {
+      const message = await channel.messages.fetch(messageId);
+      return [...message.attachments.values()].map((att) => ({
+        id: att.id,
+        size: att.size,
+        name: att.name,
+        url: att.url,
+        contentType: att.contentType
+      }));
+    } catch (error) {
+      throw new Error(
+        `Cannot fetch attachments for message ${messageId}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  // --- Receiving (event-driven) ---
+  onMention(handler) {
+    this.mentionHandlers.push(handler);
+  }
+  onReply(handler) {
+    this.replyHandlers.push(handler);
+  }
+  onMessage(channelId, handlerOrOpts, maybeHandler) {
+    let filter;
+    let handler;
+    if (typeof handlerOrOpts === "function") {
+      handler = handlerOrOpts;
+    } else {
+      filter = handlerOrOpts.filter;
+      if (!maybeHandler) {
+        throw new Error("Handler is required when providing filter options");
+      }
+      handler = maybeHandler;
+    }
+    const subs = this.channelSubscriptions.get(channelId) ?? [];
+    subs.push({ filter, handler });
+    this.channelSubscriptions.set(channelId, subs);
+  }
+  // --- Receiving (async iterable) ---
+  mentions() {
+    const buffer = new EventBuffer();
+    this.onMention((event) => {
+      buffer.push(event);
+    });
+    return buffer;
+  }
+  replies() {
+    const buffer = new EventBuffer();
+    this.onReply((event, original) => {
+      buffer.push([event, original]);
+    });
+    return buffer;
+  }
+  messages(channelId, options) {
+    const buffer = new EventBuffer();
+    if (options?.filter) {
+      this.onMessage(channelId, { filter: options.filter }, (event) => {
+        buffer.push(event);
+      });
+    } else {
+      this.onMessage(channelId, (event) => {
+        buffer.push(event);
+      });
+    }
+    return buffer;
+  }
+  // --- Error handling ---
+  on(_event, handler) {
+    this.errorHandlers.push(handler);
+  }
+  emitError(error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    for (const handler of this.errorHandlers) {
+      handler(err);
+    }
+  }
+  // --- Lifecycle ---
+  async disconnect() {
+    this.client.removeAllListeners();
+    await this.client.destroy();
+    this._status = "disconnected";
+    this._connectedAt = null;
+  }
+  // --- Private ---
+  async fetchTextChannel(channelId) {
+    const channel = await this.client.channels.fetch(channelId);
+    if (!channel?.isTextBased()) {
+      throw new Error(
+        `Channel ${channelId} is not a text-based channel or does not exist`
+      );
+    }
+    return channel;
+  }
+  toFetchedMessage(msg) {
+    return {
+      messageId: msg.id,
+      channelId: msg.channelId,
+      author: {
+        id: msg.author.id,
+        username: msg.author.username,
+        bot: msg.author.bot
+      },
+      content: msg.content,
+      timestamp: msg.createdAt,
+      attachmentCount: msg.attachments.size
+    };
+  }
+  async fetchPageWithRetry(channel, options, maxRetryMs = 5e3) {
+    try {
+      return await channel.messages.fetch(options);
+    } catch (err) {
+      if (err instanceof Error && "retryAfter" in err) {
+        const { retryAfter } = err;
+        if (typeof retryAfter === "number" && retryAfter <= maxRetryMs) {
+          await new Promise((resolve) => setTimeout(resolve, retryAfter));
+          return channel.messages.fetch(options);
+        }
+      }
+      throw err;
+    }
+  }
+  async connect(token) {
+    this._status = "connecting";
+    await this.client.login(token);
+  }
+  verify() {
+    this._status = "verifying";
+    if (this.client.guilds.cache.size === 0) {
+      this._status = "failed";
+      throw new Error(
+        "Bot is not in any guild. Invite the bot to at least one server before connecting."
+      );
+    }
+  }
+  setupEventHandlers() {
+    this.client.on(import_discord.Events.MessageCreate, (message) => {
+      try {
+        if (message.author.id === this.client.user?.id) return;
+        if (message.author.bot && !this._includeBotMessages) return;
+        const event = this.toMessageEvent(message);
+        const botUser = this.client.user;
+        if (botUser && message.mentions.has(botUser.id)) {
+          for (const handler of this.mentionHandlers) {
+            handler(event);
+          }
+        }
+        if (message.reference?.messageId) {
+          const original = this.sentMessages.get(message.reference.messageId);
+          if (original) {
+            for (const handler of this.replyHandlers) {
+              handler(event, original);
+            }
+          }
+        }
+        const subs = this.channelSubscriptions.get(message.channelId);
+        if (subs) {
+          for (const sub of subs) {
+            if (sub.filter && !sub.filter(event)) continue;
+            sub.handler(event);
+          }
+        }
+      } catch (error) {
+        this.emitError(error);
+      }
+    });
+  }
+  toMessageEvent(message) {
+    return {
+      messageId: message.id,
+      author: {
+        id: message.author.id,
+        username: message.author.username,
+        bot: message.author.bot
+      },
+      content: message.content,
+      channelId: message.channelId,
+      guildId: message.guildId ?? null,
+      timestamp: message.createdAt,
+      mentions: [...message.mentions.users.keys()],
+      raw: message
+    };
+  }
+  async sendPayloads(content, dispatcher) {
+    const files = typeof content !== "string" && content.files?.length ? await validateAndBuildAttachments(content.files) : void 0;
+    const payloads = toChunkedPayloads(content, files);
+    const results = [];
+    let i = 0;
+    for (const payload of payloads) {
+      const msg = await dispatcher(payload, i++);
+      results.push(this.trackSentMessage(msg));
+    }
+    return results;
+  }
+  trackSentMessage(message) {
+    const sent = {
+      messageId: message.id,
+      channelId: message.channelId,
+      timestamp: message.createdAt,
+      raw: message
+    };
+    this.sentMessages.set(sent.messageId, sent);
+    return sent;
+  }
+};
+function toChunkedPayloads(content, files) {
+  if (typeof content === "string") {
+    const chunks2 = chunkMessage(content);
+    return chunks2.map((text2, i) => ({
+      content: text2,
+      ...i === 0 && files?.length ? { files } : {}
+    }));
+  }
+  const text = content.content ?? "";
+  const chunks = chunkMessage(text);
+  if (chunks.length === 0) {
+    return [{ embeds: content.embeds, ...files?.length ? { files } : {} }];
+  }
+  return chunks.map((chunk, i) => ({
+    content: chunk,
+    ...i === 0 && content.embeds ? { embeds: content.embeds } : {},
+    ...i === 0 && files?.length ? { files } : {}
+  }));
+}
+var MAX_FILES_PER_MESSAGE = 10;
+async function validateAndBuildAttachments(files) {
+  if (files.length > MAX_FILES_PER_MESSAGE) {
+    throw new Error(
+      `Too many attachments: ${String(files.length)} exceeds Discord's limit of ${String(MAX_FILES_PER_MESSAGE)} attachments per message`
+    );
+  }
+  const sizes = await Promise.all(
+    files.map(
+      (file) => typeof file.data === "string" ? (0, import_promises.stat)(file.data).then((st) => st.size) : Promise.resolve(file.data.byteLength)
+    )
+  );
+  return files.map((file, i) => {
+    const size = sizes[i];
+    if (size === void 0) throw new Error(`Missing size for attachment: ${file.name}`);
+    validateAttachmentSize({ size, name: file.name, id: file.name });
+    return new import_discord.AttachmentBuilder(file.data, { name: file.name });
+  });
+}
+
+// src/onboarding.ts
+var import_discord2 = require("discord.js");
+function toErrorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+var OnboardingStepImpl = class {
+  id;
+  label;
+  instructions;
+  status;
+  error;
+  nextSibling;
+  _action;
+  _dependencies;
+  constructor(id, label, instructions, action, dependencies = [], initialStatus = "pending") {
+    this.id = id;
+    this.label = label;
+    this.instructions = instructions;
+    this._action = action;
+    this._dependencies = dependencies;
+    this.status = initialStatus;
+  }
+  async complete(...args) {
+    for (const dep of this._dependencies) {
+      if (dep.status !== "completed") {
+        const error = `Cannot complete '${this.id}': dependency '${dep.id}' is not completed.`;
+        this.status = "failed";
+        this.error = error;
+        return { success: false, error };
+      }
+    }
+    try {
+      const result = await this._action(...args);
+      if (result.success) {
+        this.status = "completed";
+        this.error = void 0;
+        if (this.nextSibling?.status === "pending") {
+          this.nextSibling.status = "ready";
+          result.nextStep = this.nextSibling;
+        }
+      } else {
+        this.status = "failed";
+        this.error = result.error;
+      }
+      return result;
+    } catch (err) {
+      const message = toErrorMessage(err);
+      this.status = "failed";
+      this.error = message;
+      return { success: false, error: message };
+    }
+  }
+};
+var BotOnboarding = class {
+  id;
+  name;
+  steps;
+  _bot;
+  _token;
+  constructor(id, name) {
+    this.id = id;
+    this.name = name;
+    const provideToken = new OnboardingStepImpl(
+      "provide_token",
+      "Provide Bot Token",
+      "Enter your Discord bot token. You can find this in the Discord Developer Portal under your application's Bot settings.",
+      async (...args) => {
+        const token = args[0];
+        const client = new import_discord2.Client({ intents: [...DEFAULT_INTENTS] });
+        try {
+          await client.login(token);
+          await client.destroy();
+          this._token = token;
+          return { success: true };
+        } catch (err) {
+          return { success: false, error: toErrorMessage(err) };
+        }
+      },
+      [],
+      "ready"
+    );
+    const inviteToServer = new OnboardingStepImpl(
+      "invite_to_server",
+      "Invite Bot to Server",
+      "Add the bot to at least one Discord server using the OAuth2 URL from the Developer Portal.",
+      async () => {
+        if (!this._token) {
+          return {
+            success: false,
+            error: "Token not set \u2014 complete the provide_token step first."
+          };
+        }
+        const client = new import_discord2.Client({ intents: [...DEFAULT_INTENTS] });
+        try {
+          await client.login(this._token);
+          if (client.guilds.cache.size === 0) {
+            await client.destroy();
+            return { success: false, error: "Bot is not in any server yet" };
+          }
+          await client.destroy();
+          return { success: true };
+        } catch (err) {
+          return { success: false, error: toErrorMessage(err) };
+        }
+      },
+      [provideToken]
+    );
+    const verifyPermissions = new OnboardingStepImpl(
+      "verify_permissions",
+      "Verify Permissions",
+      "Verify the bot has the required permissions in your server.",
+      async () => {
+        if (!this._token) {
+          return {
+            success: false,
+            error: "Token not set \u2014 complete the provide_token step first."
+          };
+        }
+        try {
+          this._bot = await Bot.fromConfig({
+            id: this.id,
+            name: this.name,
+            token: this._token
+          });
+          return { success: true };
+        } catch (err) {
+          return { success: false, error: toErrorMessage(err) };
+        }
+      },
+      [inviteToServer]
+    );
+    provideToken.nextSibling = inviteToServer;
+    inviteToServer.nextSibling = verifyPermissions;
+    this.steps = [provideToken, inviteToServer, verifyPermissions];
+  }
+  get bot() {
+    return this._bot;
+  }
+};
+
+// src/connector-manager.ts
+var ConnectorManager = class {
+  botMap = /* @__PURE__ */ new Map();
+  mentionHandlers = [];
+  lifecycleHandlers = /* @__PURE__ */ new Map();
+  addBot(bot) {
+    if (this.botMap.has(bot.id)) {
+      throw new Error(`Bot with id "${bot.id}" already exists in this manager.`);
+    }
+    this.botMap.set(bot.id, bot);
+    bot.onMention((event) => {
+      for (const handler of this.mentionHandlers) {
+        handler(event, bot);
+      }
+    });
+    bot.on("error", (error) => {
+      this.emitLifecycle("botError", bot, error);
+    });
+  }
+  getBot(id) {
+    return this.botMap.get(id);
+  }
+  get bots() {
+    return this.botMap.values();
+  }
+  removeBot(id) {
+    this.botMap.delete(id);
+  }
+  status() {
+    return [...this.botMap.values()].map((bot) => ({
+      id: bot.id,
+      name: bot.name,
+      status: bot.status
+    }));
+  }
+  onMention(callback) {
+    this.mentionHandlers.push(callback);
+  }
+  on(event, callback) {
+    const handlers = this.lifecycleHandlers.get(event) ?? [];
+    handlers.push(callback);
+    this.lifecycleHandlers.set(event, handlers);
+  }
+  emitLifecycle(event, ...args) {
+    const handlers = this.lifecycleHandlers.get(event);
+    if (handlers) {
+      for (const handler of handlers) {
+        handler(...args);
+      }
+    }
+  }
+  onboardBot(id, name) {
+    return new BotOnboarding(id, name);
+  }
+  async disconnectAll() {
+    await Promise.all([...this.botMap.values()].map((bot) => bot.disconnect()));
+  }
+  async shutdown() {
+    await this.disconnectAll();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Bot,
+  BotOnboarding,
+  ConnectorManager,
+  DEFAULT_SENT_MESSAGE_CACHE_SIZE,
+  DISCORD_MAX_MESSAGE_LENGTH,
+  EventBuffer,
+  MAX_ATTACHMENT_BYTES,
+  chunkMessage,
+  downloadAttachment,
+  sanitizeAttachmentName,
+  validateAttachmentSize
+});
+//# sourceMappingURL=index.cjs.map