@rg-dev/electron-helpers 1.0.1

package/dist/TypedIpc.d.cjs

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/TypedIpc.d.ts
+var TypedIpc_d_exports = {};
+module.exports = __toCommonJS(TypedIpc_d_exports);

package/dist/TypedIpc.d.d.cts

@@ -0,0 +1,103 @@
+import { IpcMain, IpcMainEvent, IpcMainInvokeEvent, IpcRenderer, IpcRendererEvent, WebContents } from 'electron';
+
+type OptionalPromise<T> = T | Promise<T>;
+
+type InputMap = {
+[key: string]: (...args: any) => any;
+};
+
+interface TypedIpcMain<IpcEvents extends InputMap, IpcCommands extends InputMap
+> extends IpcMain {
+	on<K extends keyof IpcEvents>(
+	channel: K,
+	listener: (event: IpcMainEvent, ...args: Parameters<IpcEvents[K]>) => void
+	): this;
+	once<K extends keyof IpcEvents>(
+	channel: K,
+	listener: (event: IpcMainEvent, ...args: Parameters<IpcEvents[K]>) => void
+	): this;
+	removeListener<K extends keyof IpcEvents>(
+	channel: K,
+	listener: (event: IpcMainEvent, ...args: Parameters<IpcEvents[K]>) => void
+	): this;
+	removeAllListeners<K extends keyof IpcEvents>(channel?: K): this;
+	handle<K extends keyof IpcCommands>(
+	channel: K,
+	listener: (
+	event: IpcMainInvokeEvent,
+	...args: Parameters<IpcCommands[K]>
+	) => OptionalPromise<ReturnType<IpcCommands[K]>>
+	): void;
+	handleOnce<K extends keyof IpcCommands>(
+	channel: K,
+	listener: (
+	event: IpcMainInvokeEvent,
+	...args: Parameters<IpcCommands[K]>
+	) => OptionalPromise<ReturnType<IpcCommands[K]>>
+	): void;
+	removeHandler<K extends keyof IpcCommands>(channel: K): void;
+}
+
+
+
+
+interface TypedIpcRenderer<IpcEvents extends InputMap, IpcCommands extends InputMap
+> extends IpcRenderer {
+	on<K extends keyof IpcEvents>(
+	channel: K,
+	listener: (
+	event: IpcRendererEvent,
+	...args: Parameters<IpcEvents[K]>
+	) => void
+	): this;
+	once<K extends keyof IpcEvents>(
+	channel: K,
+	listener: (
+	event: IpcRendererEvent,
+	...args: Parameters<IpcEvents[K]>
+	) => void
+	): this;
+	removeListener<K extends keyof IpcEvents>(
+	channel: K,
+	listener: (
+	event: IpcRendererEvent,
+	...args: Parameters<IpcEvents[K]>
+	) => void
+	): this;
+	removeAllListeners<K extends keyof IpcEvents>(channel: K): this;
+	off<K extends keyof IpcEvents>(channel: K): this;
+	send<K extends keyof IpcEvents>(
+	channel: K,
+	...args: Parameters<IpcEvents[K]>
+	): void;
+	sendSync<K extends keyof IpcEvents>(
+	channel: K,
+	...args: Parameters<IpcEvents[K]>
+	): ReturnType<IpcEvents[K]>;
+	sendTo<K extends keyof IpcEvents>(
+	webContentsId: number,
+	channel: K,
+	...args: Parameters<IpcEvents[K]>
+	): void;
+	sendToHost<K extends keyof IpcEvents>(
+	channel: K,
+	...args: Parameters<IpcEvents[K]>
+	): void;
+	invoke<K extends keyof IpcCommands>(
+	channel: K,
+	...args: Parameters<IpcCommands[K]>
+	): Promise<ReturnType<IpcCommands[K]>>;
+}
+
+
+
+
+
+interface TypedWebContents<IpcEvents extends InputMap> extends WebContents {
+	send<K extends keyof IpcEvents>(
+	channel: K,
+	...args: Parameters<IpcEvents[K]>
+	): void;
+ }
+
+export type { TypedIpcMain, TypedIpcRenderer, TypedWebContents };

package/dist/TypedIpc.d.d.ts

@@ -0,0 +1,103 @@
+import { IpcMain, IpcMainEvent, IpcMainInvokeEvent, IpcRenderer, IpcRendererEvent, WebContents } from 'electron';
+
+type OptionalPromise<T> = T | Promise<T>;
+
+type InputMap = {
+[key: string]: (...args: any) => any;
+};
+
+interface TypedIpcMain<IpcEvents extends InputMap, IpcCommands extends InputMap
+> extends IpcMain {
+	on<K extends keyof IpcEvents>(
+	channel: K,
+	listener: (event: IpcMainEvent, ...args: Parameters<IpcEvents[K]>) => void
+	): this;
+	once<K extends keyof IpcEvents>(
+	channel: K,
+	listener: (event: IpcMainEvent, ...args: Parameters<IpcEvents[K]>) => void
+	): this;
+	removeListener<K extends keyof IpcEvents>(
+	channel: K,
+	listener: (event: IpcMainEvent, ...args: Parameters<IpcEvents[K]>) => void
+	): this;
+	removeAllListeners<K extends keyof IpcEvents>(channel?: K): this;
+	handle<K extends keyof IpcCommands>(
+	channel: K,
+	listener: (
+	event: IpcMainInvokeEvent,
+	...args: Parameters<IpcCommands[K]>
+	) => OptionalPromise<ReturnType<IpcCommands[K]>>
+	): void;
+	handleOnce<K extends keyof IpcCommands>(
+	channel: K,
+	listener: (
+	event: IpcMainInvokeEvent,
+	...args: Parameters<IpcCommands[K]>
+	) => OptionalPromise<ReturnType<IpcCommands[K]>>
+	): void;
+	removeHandler<K extends keyof IpcCommands>(channel: K): void;
+}
+
+
+
+
+interface TypedIpcRenderer<IpcEvents extends InputMap, IpcCommands extends InputMap
+> extends IpcRenderer {
+	on<K extends keyof IpcEvents>(
+	channel: K,
+	listener: (
+	event: IpcRendererEvent,
+	...args: Parameters<IpcEvents[K]>
+	) => void
+	): this;
+	once<K extends keyof IpcEvents>(
+	channel: K,
+	listener: (
+	event: IpcRendererEvent,
+	...args: Parameters<IpcEvents[K]>
+	) => void
+	): this;
+	removeListener<K extends keyof IpcEvents>(
+	channel: K,
+	listener: (
+	event: IpcRendererEvent,
+	...args: Parameters<IpcEvents[K]>
+	) => void
+	): this;
+	removeAllListeners<K extends keyof IpcEvents>(channel: K): this;
+	off<K extends keyof IpcEvents>(channel: K): this;
+	send<K extends keyof IpcEvents>(
+	channel: K,
+	...args: Parameters<IpcEvents[K]>
+	): void;
+	sendSync<K extends keyof IpcEvents>(
+	channel: K,
+	...args: Parameters<IpcEvents[K]>
+	): ReturnType<IpcEvents[K]>;
+	sendTo<K extends keyof IpcEvents>(
+	webContentsId: number,
+	channel: K,
+	...args: Parameters<IpcEvents[K]>
+	): void;
+	sendToHost<K extends keyof IpcEvents>(
+	channel: K,
+	...args: Parameters<IpcEvents[K]>
+	): void;
+	invoke<K extends keyof IpcCommands>(
+	channel: K,
+	...args: Parameters<IpcCommands[K]>
+	): Promise<ReturnType<IpcCommands[K]>>;
+}
+
+
+
+
+
+interface TypedWebContents<IpcEvents extends InputMap> extends WebContents {
+	send<K extends keyof IpcEvents>(
+	channel: K,
+	...args: Parameters<IpcEvents[K]>
+	): void;
+ }
+
+export type { TypedIpcMain, TypedIpcRenderer, TypedWebContents };

package/dist/backend.cjs

@@ -0,0 +1,67 @@
+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/backend.ts
+var backend_exports = {};
+__export(backend_exports, {
+  __electron_helpers: () => __electron_helpers,
+  electronHelpers: () => electronHelpers
+});
+module.exports = __toCommonJS(backend_exports);
+var import_electron = require("electron");
+
+// src/index.ts
+var __electron_helpers = "1";
+
+// src/backend.ts
+var electronHelpers = class {
+  static isRunningInElectron() {
+    return process.versions["electron"] != void 0;
+  }
+  static async electronSaveFileDialog(type) {
+    const result = await import_electron.dialog.showSaveDialog(
+      {
+        title: "Select a file path",
+        defaultPath: ".",
+        buttonLabel: "Save",
+        filters: [
+          {
+            name: `${type} File`,
+            extensions: [type]
+          }
+        ]
+      }
+    );
+    if (!(result == null ? void 0 : result.canceled)) {
+      return result.filePath;
+    } else {
+      throw new Error("no path");
+    }
+  }
+  static async electronFilePicker() {
+    if (!this.isRunningInElectron()) {
+      throw new Error("only work in electron");
+    }
+    const res = await import_electron.dialog.showOpenDialog({ properties: ["openFile"] });
+    if (!res.canceled) {
+      return res.filePaths[0];
+    } else {
+      throw new Error("no file selected");
+    }
+  }
+};

package/dist/backend.d.cts

@@ -0,0 +1,9 @@
+export { __electron_helpers } from './index.cjs';
+
+declare class electronHelpers {
+    static isRunningInElectron(): boolean;
+    static electronSaveFileDialog(type: string): Promise<string>;
+    static electronFilePicker(): Promise<string>;
+}
+
+export { electronHelpers };

package/dist/backend.d.ts

@@ -0,0 +1,9 @@
+export { __electron_helpers } from './index.js';
+
+declare class electronHelpers {
+    static isRunningInElectron(): boolean;
+    static electronSaveFileDialog(type: string): Promise<string>;
+    static electronFilePicker(): Promise<string>;
+}
+
+export { electronHelpers };

package/dist/backend.js

@@ -0,0 +1,47 @@
+// src/backend.ts
+import { dialog } from "electron";
+
+// src/index.ts
+var __electron_helpers = "1";
+
+// src/backend.ts
+var electronHelpers = class {
+  static isRunningInElectron() {
+    return process.versions["electron"] != void 0;
+  }
+  static async electronSaveFileDialog(type) {
+    const result = await dialog.showSaveDialog(
+      {
+        title: "Select a file path",
+        defaultPath: ".",
+        buttonLabel: "Save",
+        filters: [
+          {
+            name: `${type} File`,
+            extensions: [type]
+          }
+        ]
+      }
+    );
+    if (!(result == null ? void 0 : result.canceled)) {
+      return result.filePath;
+    } else {
+      throw new Error("no path");
+    }
+  }
+  static async electronFilePicker() {
+    if (!this.isRunningInElectron()) {
+      throw new Error("only work in electron");
+    }
+    const res = await dialog.showOpenDialog({ properties: ["openFile"] });
+    if (!res.canceled) {
+      return res.filePaths[0];
+    } else {
+      throw new Error("no file selected");
+    }
+  }
+};
+export {
+  __electron_helpers,
+  electronHelpers
+};

package/dist/client.cjs

@@ -0,0 +1,84 @@
+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/client.ts
+var client_exports = {};
+__export(client_exports, {
+  IpcClient: () => IpcClient,
+  __electron_helpers: () => __electron_helpers,
+  defineIpcCommands: () => defineIpcCommands,
+  defineIpcEvents: () => defineIpcEvents
+});
+module.exports = __toCommonJS(client_exports);
+
+// src/index.ts
+var __electron_helpers = "1";
+
+// src/client.ts
+var defineIpcCommands = () => null;
+var defineIpcEvents = () => null;
+var IpcClient = class _IpcClient {
+  ipc;
+  /**
+   *   const client = IpcClient.create(globalThis.ipc, {
+   *     commands: defineIpcCommands<{ wow: () => string }>(),
+   *     events: defineIpcEvents<{ message: (content: string) => void }>(),
+   *   })
+   */
+  static create(electronIpc, _shape) {
+    const client = new _IpcClient();
+    client.ipc = electronIpc;
+    return client;
+  }
+  sendIpc(route, ...args) {
+    return new Promise(
+      async (resolve, reject) => {
+        try {
+          const res = await this.ipc.invoke(route, ...args);
+          if (!res) {
+            resolve(void 0);
+            return;
+          }
+          if (res == null ? void 0 : res._error) {
+            const err = typeof res._error !== "string" ? safeJsonStringify(res._error) : res._error;
+            reject(err);
+            return;
+          }
+          resolve(res._content ?? res);
+        } catch (e) {
+          reject((e == null ? void 0 : e.message) ?? String(e || "Unknown error"));
+        }
+      }
+    );
+  }
+  on(channel, listener) {
+    this.ipc.on(channel, (_event, ...args) => listener(...args));
+    return this;
+  }
+  off(channel, listener) {
+    this.ipc.removeListener(channel, (_event, ...args) => listener(...args));
+    return this;
+  }
+};
+function safeJsonStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}

package/dist/client.d.cts

@@ -0,0 +1,46 @@
+import { TypedIpcRenderer } from './TypedIpc.d.cjs';
+export { __electron_helpers } from './index.cjs';
+import 'electron';
+
+type IpcResponse<T> = {
+    _content: T;
+    _error?: undefined;
+} | {
+    _content?: undefined;
+    _error: string | any;
+} | undefined | void;
+type EventMap = Record<string, (...args: any[]) => any>;
+type CommandMap = Record<string, (...args: any[]) => IpcResponse<any>>;
+type IpcResponseType<Commands extends CommandMap, cmd extends keyof Commands> = Promise<NonNullable<ReturnType<Commands[cmd]> extends infer R ? R extends {
+    _content: infer T;
+} ? T : never : never>>;
+/**
+ * Define commands with plain return types:
+ *
+ *   defineIpcCommands<{ wow: () => string }>()
+ */
+declare const defineIpcCommands: <T extends Record<string, (...args: any[]) => any>>() => { [K in keyof T]: (...args: Parameters<T[K]>) => IpcResponse<ReturnType<T[K]>>; };
+/**
+ * Define events (renderer <-> main, fire-and-forget):
+ *
+ *   defineIpcEvents<{ message: (content: string) => void }>()
+ */
+declare const defineIpcEvents: <T extends EventMap>() => T;
+declare class IpcClient<Commands extends CommandMap, Events extends EventMap = {}> {
+    private ipc;
+    /**
+     *   const client = IpcClient.create(globalThis.ipc, {
+     *     commands: defineIpcCommands<{ wow: () => string }>(),
+     *     events: defineIpcEvents<{ message: (content: string) => void }>(),
+     *   })
+     */
+    static create<Commands extends CommandMap, Events extends EventMap = {}>(electronIpc: TypedIpcRenderer<Events, Commands>, _shape: {
+        commands: Commands;
+        events?: Events;
+    }): IpcClient<Commands, Events>;
+    sendIpc<cmd extends keyof Commands>(route: cmd, ...args: Parameters<Commands[cmd]>): IpcResponseType<Commands, cmd>;
+    on<K extends keyof Events>(channel: K, listener: (...args: Parameters<Events[K]>) => void): this;
+    off<K extends keyof Events>(channel: K, listener: (...args: Parameters<Events[K]>) => void): this;
+}
+
+export { IpcClient, type IpcResponse, defineIpcCommands, defineIpcEvents };

package/dist/client.d.ts

@@ -0,0 +1,46 @@
+import { TypedIpcRenderer } from './TypedIpc.d.js';
+export { __electron_helpers } from './index.js';
+import 'electron';
+
+type IpcResponse<T> = {
+    _content: T;
+    _error?: undefined;
+} | {
+    _content?: undefined;
+    _error: string | any;
+} | undefined | void;
+type EventMap = Record<string, (...args: any[]) => any>;
+type CommandMap = Record<string, (...args: any[]) => IpcResponse<any>>;
+type IpcResponseType<Commands extends CommandMap, cmd extends keyof Commands> = Promise<NonNullable<ReturnType<Commands[cmd]> extends infer R ? R extends {
+    _content: infer T;
+} ? T : never : never>>;
+/**
+ * Define commands with plain return types:
+ *
+ *   defineIpcCommands<{ wow: () => string }>()
+ */
+declare const defineIpcCommands: <T extends Record<string, (...args: any[]) => any>>() => { [K in keyof T]: (...args: Parameters<T[K]>) => IpcResponse<ReturnType<T[K]>>; };
+/**
+ * Define events (renderer <-> main, fire-and-forget):
+ *
+ *   defineIpcEvents<{ message: (content: string) => void }>()
+ */
+declare const defineIpcEvents: <T extends EventMap>() => T;
+declare class IpcClient<Commands extends CommandMap, Events extends EventMap = {}> {
+    private ipc;
+    /**
+     *   const client = IpcClient.create(globalThis.ipc, {
+     *     commands: defineIpcCommands<{ wow: () => string }>(),
+     *     events: defineIpcEvents<{ message: (content: string) => void }>(),
+     *   })
+     */
+    static create<Commands extends CommandMap, Events extends EventMap = {}>(electronIpc: TypedIpcRenderer<Events, Commands>, _shape: {
+        commands: Commands;
+        events?: Events;
+    }): IpcClient<Commands, Events>;
+    sendIpc<cmd extends keyof Commands>(route: cmd, ...args: Parameters<Commands[cmd]>): IpcResponseType<Commands, cmd>;
+    on<K extends keyof Events>(channel: K, listener: (...args: Parameters<Events[K]>) => void): this;
+    off<K extends keyof Events>(channel: K, listener: (...args: Parameters<Events[K]>) => void): this;
+}
+
+export { IpcClient, type IpcResponse, defineIpcCommands, defineIpcEvents };

package/dist/client.js

@@ -0,0 +1,62 @@
+// src/index.ts
+var __electron_helpers = "1";
+
+// src/client.ts
+var defineIpcCommands = () => null;
+var defineIpcEvents = () => null;
+var IpcClient = class _IpcClient {
+  ipc;
+  /**
+   *   const client = IpcClient.create(globalThis.ipc, {
+   *     commands: defineIpcCommands<{ wow: () => string }>(),
+   *     events: defineIpcEvents<{ message: (content: string) => void }>(),
+   *   })
+   */
+  static create(electronIpc, _shape) {
+    const client = new _IpcClient();
+    client.ipc = electronIpc;
+    return client;
+  }
+  sendIpc(route, ...args) {
+    return new Promise(
+      async (resolve, reject) => {
+        try {
+          const res = await this.ipc.invoke(route, ...args);
+          if (!res) {
+            resolve(void 0);
+            return;
+          }
+          if (res == null ? void 0 : res._error) {
+            const err = typeof res._error !== "string" ? safeJsonStringify(res._error) : res._error;
+            reject(err);
+            return;
+          }
+          resolve(res._content ?? res);
+        } catch (e) {
+          reject((e == null ? void 0 : e.message) ?? String(e || "Unknown error"));
+        }
+      }
+    );
+  }
+  on(channel, listener) {
+    this.ipc.on(channel, (_event, ...args) => listener(...args));
+    return this;
+  }
+  off(channel, listener) {
+    this.ipc.removeListener(channel, (_event, ...args) => listener(...args));
+    return this;
+  }
+};
+function safeJsonStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+export {
+  IpcClient,
+  __electron_helpers,
+  defineIpcCommands,
+  defineIpcEvents
+};

package/dist/index.cjs

@@ -0,0 +1,25 @@
+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 src_exports = {};
+__export(src_exports, {
+  __electron_helpers: () => __electron_helpers
+});
+module.exports = __toCommonJS(src_exports);
+var __electron_helpers = "1";

package/dist/index.d.cts

@@ -0,0 +1,5 @@
+import './backend'
+import './client'
+export type * from './TypedIpc.d'
+
+export declare const __electron_helpers:string

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import './backend'
+import './client'
+export type * from './TypedIpc.d'
+
+export declare const __electron_helpers:string

package/dist/index.js

@@ -0,0 +1,5 @@
+// src/index.ts
+var __electron_helpers = "1";
+export {
+  __electron_helpers
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@rg-dev/electron-helpers",
+  "version": "1.0.1",
+  "description": "",
+  "scripts": {
+    "test": "tsup && node dist/index.cjs",
+    "build": "tsup && node ./after-build.mjs"
+  },
+  "author": "",
+  "license": "ISC",
+  "main": "./dist/index.cjs",
+  "files": [
+    "dist"
+  ],
+    "publishConfig": {
+    "access": "public"
+  },
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+       "./dist/client": {
+      "import": "./dist/client.js",
+      "require": "./dist/client.cjs"
+    },
+     "./dist/backend": {
+      "import": "./dist/backend.js",
+      "require": "./dist/backend.cjs"
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^14.18.36",
+    "builtin-modules": "^3.3.0",
+    "electron": "^34.0.0",
+    "execa": "^8.0.1",
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.5"
+  }
+}