bakit 2.0.0-alpha.2 → 2.0.0-alpha.4

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as discord_js from 'discord.js';
-import { GatewayIntentBits, ClientOptions, ChatInputCommandInteraction, CacheType, Message, User, MessageCreateOptions, InteractionReplyOptions, Awaitable, Collection, ClientEvents, Events, Client } from 'discord.js';
+import { GatewayIntentBits, ClientOptions, ChatInputCommandInteraction, CacheType, Message, User, MessageCreateOptions, InteractionReplyOptions, Awaitable, Collection, ClientEvents, Events, IntentsBitField, Client } from 'discord.js';
 import z$1, { z } from 'zod';
 import { inspect } from 'node:util';
 
@@ -7,6 +7,8 @@ declare const ProjectConfigSchema: z.ZodObject<{
     intents: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodBigInt, z.ZodArray<z.ZodEnum<typeof GatewayIntentBits>>]>>;
     clientOptions: z.ZodOptional<z.ZodCustom<Omit<ClientOptions, "intents">, Omit<ClientOptions, "intents">>>;
     entryDir: z.ZodDefault<z.ZodString>;
+    prefixes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    token: z.ZodString;
 }, z.core.$strip>;
 type ProjectConfigInput = z.input<typeof ProjectConfigSchema>;
 type ProjectConfig = z.output<typeof ProjectConfigSchema>;
@@ -118,6 +120,7 @@ type BaseParamOptions = z.input<typeof BaseParamSchema>;
 type StringOptions = z.input<typeof StringParamSchema>;
 type NumberOptions = z.input<typeof NumberParamSchema>;
 
+type ParamResolvedOutputType<OutputType, Required extends boolean = true> = Required extends true ? OutputType : OutputType | null;
 declare abstract class BaseParam<Options extends BaseParamOptions, OutputType, Required extends boolean = true> {
     options: Options & {
         required: Required;
@@ -136,6 +139,9 @@ declare abstract class BaseParam<Options extends BaseParamOptions, OutputType, R
     name(value: string): this;
     description(value: string): this;
     required<V extends boolean>(value: V): BaseParam<Options, OutputType, V>;
+    resolve(context: CommandContext, value?: string): Promise<ParamResolvedOutputType<OutputType, Required>>;
+    abstract resolveMessage(context: MessageContext, value: string | undefined): Awaitable<ParamResolvedOutputType<OutputType, Required>>;
+    abstract resolveChatInput(context: ChatInputContext): Awaitable<ParamResolvedOutputType<OutputType, Required>>;
     /**
      * Helper to normalize string inputs into an options object.
      */
@@ -144,6 +150,8 @@ declare abstract class BaseParam<Options extends BaseParamOptions, OutputType, R
 declare class StringParam<Required extends boolean = true> extends BaseParam<StringOptions, string, Required> {
     constructor(options: string | StringOptions);
     required<V extends boolean>(value: V): StringParam<V>;
+    resolveMessage(_context: CommandContext, value: string | undefined): ParamResolvedOutputType<string, Required>;
+    resolveChatInput(context: ChatInputContext): ParamResolvedOutputType<string, Required>;
     /**
      * Sets the minimum allowed length for this string.
      * Pass `null` to remove this constraint.
@@ -158,6 +166,8 @@ declare class StringParam<Required extends boolean = true> extends BaseParam<Str
 declare class NumberParam<Required extends boolean = true> extends BaseParam<NumberOptions, number, Required> {
     constructor(options: string | NumberOptions);
     required<V extends boolean>(value: V): NumberParam<V>;
+    resolveMessage(ctx: CommandContext, value: string | undefined): ParamResolvedOutputType<number, Required>;
+    resolveChatInput(context: ChatInputContext): ParamResolvedOutputType<number, Required>;
     /**
      * Sets the minimum allowed value for this number.
      * Pass `null` to remove this constraint.
@@ -194,6 +204,7 @@ declare const CommandOptionsSchema: z.ZodPipe<z.ZodObject<{
         description?: string | undefined;
         required?: boolean | undefined;
     }, unknown, boolean>>>>;
+    quotes: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>, z.ZodTransform<{
     description: string;
     name: string;
@@ -202,6 +213,7 @@ declare const CommandOptionsSchema: z.ZodPipe<z.ZodObject<{
         description?: string | undefined;
         required?: boolean | undefined;
     }, unknown, boolean>[];
+    quotes: boolean;
 }, {
     name: string;
     params: BaseParam<{
@@ -209,6 +221,7 @@ declare const CommandOptionsSchema: z.ZodPipe<z.ZodObject<{
         description?: string | undefined;
         required?: boolean | undefined;
     }, unknown, boolean>[];
+    quotes: boolean;
     description?: string | undefined;
 }>>;
 type CommandOptionsInput = z.input<typeof CommandOptionsSchema>;
@@ -216,13 +229,14 @@ type CommandOptions = z.output<typeof CommandOptionsSchema>;
 /**
  * The command entry, used for registering command.
  */
-declare class Command<ParamsList extends readonly AnyParam<any>[] = []> extends LifecycleManager<CommandContext, [
+declare class Command<ParamsList extends readonly AnyParam<any>[] = any[]> extends LifecycleManager<CommandContext, [
     ...args: InferParamTuple<ParamsList>
 ]> {
     options: CommandOptions;
     constructor(options: (Omit<CommandOptionsInput, "params"> & {
         params?: ParamsList;
     }) | string);
+    private handleSyntaxError;
 }
 /**
  * Define command entry, usually for modules.
@@ -244,7 +258,7 @@ declare class Command<ParamsList extends readonly AnyParam<any>[] = []> extends
  * export default command;
  * ```
  */
-declare function defineCommand<const ParamsList extends readonly AnyParam<any>[] = []>(options: (Omit<CommandOptionsInput, "params"> & {
+declare function defineCommand<const ParamsList extends readonly AnyParam<any>[] = any[]>(options: (Omit<CommandOptionsInput, "params"> & {
     params?: ParamsList;
 }) | string): Command<ParamsList>;
 
@@ -254,11 +268,11 @@ declare class BaseClientManager {
 }
 
 declare class CommandManager extends BaseClientManager {
-    commands: Collection<string, Command<[]>>;
+    commands: Collection<string, Command<any[]>>;
     loadModules(): Promise<Command[]>;
     add(command: Command): void;
     remove(target: string | Command): Command | undefined;
-    get(name: string): Command<[]> | undefined;
+    get(name: string): Command<any[]> | undefined;
 }
 
 declare const ListenerOptionsSchema: z$1.ZodObject<{
@@ -281,6 +295,8 @@ declare class ListenerManager extends BaseClientManager {
     loadModules(): Promise<Listener[]>;
     add(listener: Listener): void;
     remove(target: string | Listener): Listener[];
+    getBaseIntents(): IntentsBitField;
+    getNeededIntents(): IntentsBitField;
 }
 
 type GetPrefixFunction = (message: Message) => Awaitable<string[] | string>;
@@ -294,7 +310,6 @@ declare class BakitClient<Ready extends boolean = boolean> extends Client<Ready>
         listeners: ListenerManager;
     };
     constructor(options: ClientOptions);
-    start(token?: string): Promise<string>;
     /**
      * Check if the client is connected to gateway successfully and finished initialization.
      */
@@ -312,6 +327,28 @@ declare class BakitClient<Ready extends boolean = boolean> extends Client<Ready>
     [inspect.custom](): string;
 }
 
+declare class Instance {
+    client: BakitClient;
+    start(): Promise<void>;
+    private loadModules;
+    private initIntents;
+}
+declare function useApp(): Instance;
+
+declare const EVENT_INTENT_MAPPING: Record<string, number[]>;
+
+declare function tokenize(content: string): string[];
+
+declare class BakitError extends Error {
+    constructor(message: string);
+}
+
+declare class ArgumentError extends BakitError {
+    target: string;
+    reason: string;
+    constructor(target: string, reason: string);
+}
+
 declare const Params: {
     readonly string: <Required extends boolean = true>(options: string | {
         name: string;
@@ -329,4 +366,4 @@ declare const Params: {
     }) => NumberParam<Required>;
 };
 
-export { type AnyParam, BakitClient, type BakitClientEvents, BaseCommandContext, BaseParam, type BaseParamOptions, BaseParamSchema, ChatInputContext, type ChatInputContextSendOptions, Command, type CommandContext, CommandManager, type CommandOptions, type CommandOptionsInput, CommandOptionsSchema, type ContextSendOptions, type GetPrefixFunction, type InferParamTuple, type InferParamValue, Listener, ListenerManager, type ListenerOptions, ListenerOptionsSchema, MessageContext, type MessageContextSendOptions, type NumberOptions, NumberParam, NumberParamSchema, ParamUserType, Params, type ProjectConfig, type ProjectConfigInput, ProjectConfigSchema, type StringOptions, StringParam, StringParamSchema, defineCommand, defineConfig, defineListener, getConfig, loadConfig };
+export { type AnyParam, ArgumentError, BakitClient, type BakitClientEvents, BakitError, BaseClientManager, BaseCommandContext, BaseParam, type BaseParamOptions, BaseParamSchema, ChatInputContext, type ChatInputContextSendOptions, Command, type CommandContext, CommandManager, type CommandOptions, type CommandOptionsInput, CommandOptionsSchema, Context, type ContextSendOptions, EVENT_INTENT_MAPPING, type ErrorHookCallback, type GetPrefixFunction, HookOrder, HookState, type InferParamTuple, type InferParamValue, Instance, LifecycleManager, Listener, ListenerManager, type ListenerOptions, ListenerOptionsSchema, type MainHookCallback, MessageContext, type MessageContextSendOptions, type NumberOptions, NumberParam, NumberParamSchema, type ParamResolvedOutputType, ParamUserType, Params, type ProjectConfig, type ProjectConfigInput, ProjectConfigSchema, type StringOptions, StringParam, StringParamSchema, defineCommand, defineConfig, defineListener, getConfig, loadConfig, tokenize, useApp };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { GatewayIntentBits, Events, Client, Collection, ChatInputCommandInteraction, Message } from 'discord.js';
+import { GatewayIntentBits, Events, Client, IntentsBitField, Collection, ChatInputCommandInteraction, Message } from 'discord.js';
 import z3, { z } from 'zod';
 import { pathToFileURL } from 'url';
 import glob from 'tiny-glob';
@@ -30,7 +30,9 @@ var ProjectConfigSchema = z.object({
    *
    * @defaultvalue `src`
    */
-  entryDir: z.string().default("src")
+  entryDir: z.string().default("src"),
+  prefixes: z.array(z.string()).default([]),
+  token: z.string()
 });
 function defineConfig(config) {
   return config;
@@ -128,7 +130,7 @@ var BaseCommandContext = class extends Context {
     return await channel.send(options);
   }
 };
-var LifecycleManager = class {
+var HookState = /* @__PURE__ */ ((HookState2) => (HookState2.Pre = "PRE", HookState2.Main = "MAIN", HookState2.Post = "POST", HookState2.Error = "ERROR", HookState2))(HookState || {}), HookOrder = /* @__PURE__ */ ((HookOrder2) => (HookOrder2[HookOrder2.First = 0] = "First", HookOrder2[HookOrder2.Last = 1] = "Last", HookOrder2))(HookOrder || {}), LifecycleManager = class {
   constructor(id) {
     this.id = id;
   }
@@ -199,6 +201,22 @@ var LifecycleManager = class {
   }
 };
 
+// src/errors/BakitError.ts
+var BakitError = class extends Error {
+  constructor(message) {
+    super(message), this.name = this.constructor.name, Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/errors/ArgumentError.ts
+var ArgumentError = class extends BakitError {
+  constructor(target, reason) {
+    super(`Invalid argument for '${target}': ${reason}`);
+    this.target = target;
+    this.reason = reason;
+  }
+};
+
 // src/command/param/Param.ts
 var BaseParam = class {
   options;
@@ -218,6 +236,13 @@ var BaseParam = class {
   required(value) {
     return this.setOption("required", value);
   }
+  async resolve(context, value) {
+    if (context.isChatInput())
+      return await this.resolveChatInput(context);
+    if (context.isMessage())
+      return await this.resolveMessage(context, value);
+    throw new Error("Invalid context type provided");
+  }
   /**
    * Helper to normalize string inputs into an options object.
    */
@@ -231,6 +256,23 @@ var BaseParam = class {
   required(value) {
     return super.required(value);
   }
+  resolveMessage(_context, value) {
+    let { required, minLength, maxLength, name } = this.options;
+    if (value === void 0) {
+      if (required)
+        throw new ArgumentError(name, "is required");
+      return null;
+    }
+    if (minLength && value.length < minLength)
+      throw new ArgumentError(name, `must be at least ${minLength} chars long`);
+    if (maxLength && value.length > maxLength)
+      throw new ArgumentError(name, `must be at most ${maxLength} chars long`);
+    return value;
+  }
+  resolveChatInput(context) {
+    let { name, required } = this.options;
+    return context.source.options.getString(name, required);
+  }
   /**
    * Sets the minimum allowed length for this string.
    * Pass `null` to remove this constraint.
@@ -252,6 +294,26 @@ var BaseParam = class {
   required(value) {
     return super.required(value);
   }
+  resolveMessage(ctx, value) {
+    let { required, minValue, maxValue, name } = this.options;
+    if (value === void 0) {
+      if (required)
+        throw new ArgumentError(name, "is required");
+      return null;
+    }
+    let num = Number(value);
+    if (isNaN(num))
+      throw new ArgumentError(name, "must be a number");
+    if (minValue !== void 0 && num < minValue)
+      throw new ArgumentError(name, `must be greater than ${minValue}`);
+    if (maxValue !== void 0 && num > maxValue)
+      throw new ArgumentError(name, `must be less than ${minValue}`);
+    return num;
+  }
+  resolveChatInput(context) {
+    let { name, required } = this.options;
+    return context.source.options.getString(name, required);
+  }
   /**
    * Sets the minimum allowed value for this number.
    * Pass `null` to remove this constraint.
@@ -272,14 +334,20 @@ var BaseParam = class {
 var CommandOptionsSchema = z.object({
   name: z.string(),
   description: z.string().min(1).max(100).optional(),
-  params: z.array(z.instanceof(BaseParam)).default([])
+  params: z.array(z.instanceof(BaseParam)).default([]),
+  quotes: z.boolean().default(true)
 }).transform((data) => ({
   ...data,
   description: data.description ?? `Command ${data.name}`
 })), Command = class extends LifecycleManager {
   constructor(options) {
     let _options = CommandOptionsSchema.parse(typeof options == "string" ? { name: options } : options);
-    super(`command:${_options.name}`), this.options = _options;
+    super(`command:${_options.name}`), this.options = _options, this.setHook("syntaxError", "ERROR" /* Error */, async (ctx, error, ...args) => {
+      await this.handleSyntaxError(ctx, error, args);
+    });
+  }
+  async handleSyntaxError(context, error, _args) {
+    error instanceof BakitError && await context.send(error.message);
   }
 };
 function defineCommand(options) {
@@ -343,12 +411,107 @@ var ListenerOptionsSchema = z3.object({
   options;
   constructor(options) {
     let _options = ListenerOptionsSchema.parse(typeof options == "string" ? { name: options } : options);
-    super(`listener:${_options.name}`), this.options = options;
+    super(`listener:${_options.name}`), this.options = _options;
   }
 };
 function defineListener(options) {
   return new Listener(options);
 }
+var INTENT_GROUPS = {
+  [GatewayIntentBits.Guilds]: [
+    Events.GuildCreate,
+    Events.GuildDelete,
+    Events.GuildUpdate,
+    Events.GuildUnavailable,
+    Events.GuildRoleCreate,
+    Events.GuildRoleDelete,
+    Events.GuildRoleUpdate,
+    Events.ChannelCreate,
+    Events.ChannelDelete,
+    Events.ChannelUpdate,
+    Events.ChannelPinsUpdate,
+    Events.ThreadCreate,
+    Events.ThreadDelete,
+    Events.ThreadUpdate,
+    Events.ThreadListSync,
+    Events.ThreadMemberUpdate,
+    Events.ThreadMembersUpdate,
+    Events.StageInstanceCreate,
+    Events.StageInstanceUpdate,
+    Events.StageInstanceDelete
+  ],
+  [GatewayIntentBits.GuildMembers]: [
+    Events.GuildMemberAdd,
+    Events.GuildMemberUpdate,
+    Events.GuildMemberRemove,
+    Events.ThreadMembersUpdate
+  ],
+  [GatewayIntentBits.GuildModeration]: [Events.GuildAuditLogEntryCreate, Events.GuildBanAdd, Events.GuildBanRemove],
+  [GatewayIntentBits.GuildExpressions]: [
+    Events.GuildEmojiCreate,
+    Events.GuildEmojiDelete,
+    Events.GuildEmojiUpdate,
+    Events.GuildStickerCreate,
+    Events.GuildStickerDelete,
+    Events.GuildStickerUpdate,
+    Events.GuildSoundboardSoundCreate,
+    Events.GuildSoundboardSoundUpdate,
+    Events.GuildSoundboardSoundDelete,
+    Events.GuildSoundboardSoundsUpdate
+  ],
+  [GatewayIntentBits.GuildIntegrations]: [Events.GuildIntegrationsUpdate],
+  [GatewayIntentBits.GuildWebhooks]: [Events.WebhooksUpdate],
+  [GatewayIntentBits.GuildInvites]: [Events.InviteCreate, Events.InviteDelete],
+  [GatewayIntentBits.GuildVoiceStates]: [Events.VoiceStateUpdate],
+  [GatewayIntentBits.GuildPresences]: [Events.PresenceUpdate],
+  [GatewayIntentBits.GuildMessages]: [
+    Events.MessageCreate,
+    Events.MessageUpdate,
+    Events.MessageDelete,
+    Events.MessageBulkDelete
+  ],
+  [GatewayIntentBits.GuildMessageReactions]: [
+    Events.MessageReactionAdd,
+    Events.MessageReactionRemove,
+    Events.MessageReactionRemoveAll,
+    Events.MessageReactionRemoveEmoji
+  ],
+  [GatewayIntentBits.GuildMessageTyping]: [Events.TypingStart],
+  [GatewayIntentBits.DirectMessages]: [
+    Events.MessageCreate,
+    Events.MessageUpdate,
+    Events.MessageDelete,
+    Events.ChannelPinsUpdate
+  ],
+  [GatewayIntentBits.DirectMessageReactions]: [
+    Events.MessageReactionAdd,
+    Events.MessageReactionRemove,
+    Events.MessageReactionRemoveAll,
+    Events.MessageReactionRemoveEmoji
+  ],
+  [GatewayIntentBits.DirectMessageTyping]: [Events.TypingStart],
+  [GatewayIntentBits.MessageContent]: [Events.MessageCreate, Events.MessageUpdate],
+  [GatewayIntentBits.GuildScheduledEvents]: [
+    Events.GuildScheduledEventCreate,
+    Events.GuildScheduledEventDelete,
+    Events.GuildScheduledEventUpdate,
+    Events.GuildScheduledEventUserAdd,
+    Events.GuildScheduledEventUserRemove
+  ],
+  [GatewayIntentBits.AutoModerationConfiguration]: [
+    Events.AutoModerationRuleCreate,
+    Events.AutoModerationRuleDelete,
+    Events.AutoModerationRuleUpdate
+  ],
+  [GatewayIntentBits.AutoModerationExecution]: [Events.AutoModerationActionExecution],
+  [GatewayIntentBits.GuildMessagePolls]: [Events.MessagePollVoteAdd, Events.MessagePollVoteRemove],
+  [GatewayIntentBits.DirectMessagePolls]: [Events.MessagePollVoteAdd, Events.MessagePollVoteRemove]
+}, EVENT_INTENT_MAPPING = {};
+for (let [intentStr, events] of Object.entries(INTENT_GROUPS)) {
+  let intent = Number(intentStr);
+  for (let event of events)
+    EVENT_INTENT_MAPPING[event] ??= [], EVENT_INTENT_MAPPING[event].includes(intent) || EVENT_INTENT_MAPPING[event].push(intent);
+}
 
 // src/listener/ListenerManager.ts
 var ListenerManager = class extends BaseClientManager {
@@ -396,6 +559,17 @@ var ListenerManager = class extends BaseClientManager {
       return execute && (this.client.removeListener(listener.options.name, execute), this.executors.delete(listener)), false;
     }), removed;
   }
+  getBaseIntents() {
+    return new IntentsBitField([GatewayIntentBits.Guilds]);
+  }
+  getNeededIntents() {
+    let result = this.getBaseIntents();
+    for (let listener of this.listeners) {
+      let eventName = listener.options.name, requiredIntents = EVENT_INTENT_MAPPING[eventName];
+      requiredIntents && result.add(requiredIntents);
+    }
+    return result;
+  }
 };
 
 // src/BakitClient.ts
@@ -407,10 +581,6 @@ var BakitClient3 = class extends Client {
       listeners: new ListenerManager(this)
     };
   }
-  async start(token) {
-    let { commands, listeners } = this.managers;
-    return await Promise.all([commands.loadModules(), listeners.loadModules()]), await this.login(token);
-  }
   /**
    * Check if the client is connected to gateway successfully and finished initialization.
    */
@@ -443,6 +613,47 @@ var BakitClient3 = class extends Client {
     return `${this.constructor.name} {}`;
   }
 };
+var Instance = class {
+  client;
+  async start() {
+    await loadConfig();
+    let config = getConfig();
+    this.client = new BakitClient3({
+      intents: []
+    }), await this.loadModules(), this.initIntents(), await this.client.login(config.token);
+  }
+  loadModules() {
+    let { managers } = this.client, { commands, listeners } = managers;
+    return Promise.all([commands.loadModules(), listeners.loadModules()]);
+  }
+  initIntents() {
+    let config = getConfig(), { options, managers } = this.client, { listeners } = managers, intents;
+    config.intents === "auto" ? intents = listeners.getNeededIntents() : (intents = listeners.getBaseIntents(), typeof config.intents == "bigint" ? intents.bitfield = Number(config.intents) : intents.add(...config.intents)), options.intents = intents;
+  }
+};
+function useApp() {
+  return new Instance();
+}
+
+// src/utils/string.ts
+function tokenize(content) {
+  let args = [], current = "", quoteChar = null, isEscaped = false;
+  for (let i = 0; i < content.length; i++) {
+    let char = content[i];
+    if (char === void 0)
+      break;
+    if (isEscaped) {
+      current += char, isEscaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      isEscaped = true;
+      continue;
+    }
+    quoteChar ? char === quoteChar ? quoteChar = null : current += char : char === '"' ? quoteChar = char : /\s/.test(char) ? current.length > 0 && (args.push(current), current = "") : current += char;
+  }
+  return current.length > 0 && args.push(current), args;
+}
 var ParamUserType = /* @__PURE__ */ ((ParamUserType2) => (ParamUserType2.Bot = "bot", ParamUserType2.Normal = "normal", ParamUserType2.Any = "any", ParamUserType2))(ParamUserType || {}), BaseParamSchema = z.object({
   name: z.string(),
   description: z.string().optional(),
@@ -464,4 +675,4 @@ var Params = {
   number: createFactory(NumberParam)
 };
 
-export { BakitClient3 as BakitClient, BaseCommandContext, BaseParam, BaseParamSchema, ChatInputContext, Command, CommandManager, CommandOptionsSchema, Listener, ListenerManager, ListenerOptionsSchema, MessageContext, NumberParam, NumberParamSchema, ParamUserType, Params, ProjectConfigSchema, StringParam, StringParamSchema, defineCommand, defineConfig, defineListener, getConfig, loadConfig };
+export { ArgumentError, BakitClient3 as BakitClient, BakitError, BaseClientManager, BaseCommandContext, BaseParam, BaseParamSchema, ChatInputContext, Command, CommandManager, CommandOptionsSchema, Context, EVENT_INTENT_MAPPING, HookOrder, HookState, Instance, LifecycleManager, Listener, ListenerManager, ListenerOptionsSchema, MessageContext, NumberParam, NumberParamSchema, ParamUserType, Params, ProjectConfigSchema, StringParam, StringParamSchema, defineCommand, defineConfig, defineListener, getConfig, loadConfig, tokenize, useApp };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bakit",
-	"version": "2.0.0-alpha.2",
+	"version": "2.0.0-alpha.4",
 	"description": "A framework for discord.js",
 	"type": "module",
 	"types": "./dist/index.d.ts",