@luxass/utils 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-PRESENT Lucas Nørgård
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,25 @@
+# utils
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+
+## 📦 Installation
+
+```sh
+npm install @luxass/utils
+```
+
+## 📚 Usage
+
+You can view the documentation [here](https://www.jsdocs.io/package/@luxass/utils).
+
+## 📄 License
+
+Published under [MIT License](./LICENSE).
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/@luxass/utils?style=flat&colorA=18181B&colorB=4169E1
+[npm-version-href]: https://npmjs.com/package/@luxass/utils
+[npm-downloads-src]: https://img.shields.io/npm/dm/@luxass/utils?style=flat&colorA=18181B&colorB=4169E1
+[npm-downloads-href]: https://npmjs.com/package/@luxass/utils

package/dist/chunk-JVIVQFL7.mjs

@@ -0,0 +1,38 @@
+// src/string.ts
+function capitalize(str) {
+  if (typeof str !== "string")
+    throw new TypeError("Expected a string");
+  if (str.trim().length === 0)
+    return "";
+  return str[0].toUpperCase() + str.slice(1).toLowerCase();
+}
+function toCamelCase(str) {
+  if (typeof str !== "string")
+    throw new TypeError("Expected a string");
+  if (str.trim().length === 0)
+    return "";
+  return str.toLowerCase().replace(/[-_](.)/g, (_, c) => c.toUpperCase());
+}
+function toKebabCase(str) {
+  if (typeof str !== "string")
+    throw new TypeError("Expected a string");
+  if (str.trim().length === 0)
+    return "";
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function toPascalCase(str) {
+  if (typeof str !== "string")
+    throw new TypeError("Expected a string");
+  if (str.trim().length === 0)
+    return "";
+  return str.toLowerCase().replace(/[-_](.)/g, (_, c) => c.toUpperCase()).replace(/^[a-z]/, (c) => c.toUpperCase());
+}
+function toSnakeCase(str) {
+  if (typeof str !== "string")
+    throw new TypeError("Expected a string");
+  if (str.trim().length === 0)
+    return "";
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+}
+
+export { capitalize, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/chunk-OKC7RR3A.mjs

@@ -0,0 +1,15 @@
+// src/guards.ts
+function isNotNullish(v) {
+  return v != null;
+}
+function isNotNull(v) {
+  return v !== null;
+}
+function isNotUndefined(v) {
+  return v !== void 0;
+}
+function isTruthy(v) {
+  return Boolean(v);
+}
+
+export { isNotNull, isNotNullish, isNotUndefined, isTruthy };

package/dist/guards.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+// src/guards.ts
+function isNotNullish(v) {
+  return v != null;
+}
+function isNotNull(v) {
+  return v !== null;
+}
+function isNotUndefined(v) {
+  return v !== void 0;
+}
+function isTruthy(v) {
+  return Boolean(v);
+}
+
+exports.isNotNull = isNotNull;
+exports.isNotNullish = isNotNullish;
+exports.isNotUndefined = isNotUndefined;
+exports.isTruthy = isTruthy;

package/dist/guards.d.cts

@@ -0,0 +1,58 @@
+/**
+ * Checks if a value is not null or undefined.
+ *
+ * @template T - The type of the input value.
+ * @param {T | null | undefined} v - The value to check for not being null or undefined.
+ * @returns {v is NonNullable<T>} - True if the value is not null or undefined, false otherwise.
+ *
+ * @example
+ * ```ts
+ * [true, false, 0, 1, "", "hello", null, undefined].filter(isNotNullish)
+ * // [true, false, 0, 1, "", "hello"]
+ * ```
+ */
+declare function isNotNullish<T>(v: T | null | undefined): v is NonNullable<T>;
+/**
+ * Checks if a value is not null.
+ *
+ * @template T - The type of the input value.
+ * @param {T | null} v - The value to check for not being null.
+ * @returns {v is Exclude<T, null>} True if the value is not null, false otherwise.
+ *
+ * @example
+ * ```ts
+ * [true, false, 0, 1, "", "hello", null, undefined].filter(isNotNull)
+ * // [true, false, 0, 1, "", "hello", undefined]
+ * ```
+ */
+declare function isNotNull<T>(v: T | null): v is Exclude<T, null>;
+/**
+ * Checks if a value is defined.
+ *
+ * @template T - The type of the input value.
+ * @param {T} v - The value to check for being defined.
+ * @returns {v is Exclude<T, undefined>} True if the value is defined, false otherwise.
+ *
+ * @example
+ * ```ts
+ * [true, false, 0, 1, "", "hello", null, undefined].filter(isDefined)
+ * // [true, false, 0, 1, "", "hello", null]
+ * ```
+ */
+declare function isNotUndefined<T>(v: T): v is Exclude<T, undefined>;
+/**
+ * Checks if a value is truthy, excluding null and undefined.
+ *
+ * @template T - The type of the input value.
+ * @param {T} v - The value to check for truthiness.
+ * @returns {v is NonNullable<T>} True if the value is truthy, false otherwise.
+ *
+ * @example
+ * ```ts
+ * [true, false, 0, 1, "", "hello", null, undefined].filter(isTruthy)
+ * // [true, 1, "hello"]
+ * ```
+ */
+declare function isTruthy<T>(v: T): v is NonNullable<T>;
+
+export { isNotNull, isNotNullish, isNotUndefined, isTruthy };

package/dist/guards.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Checks if a value is not null or undefined.
+ *
+ * @template T - The type of the input value.
+ * @param {T | null | undefined} v - The value to check for not being null or undefined.
+ * @returns {v is NonNullable<T>} - True if the value is not null or undefined, false otherwise.
+ *
+ * @example
+ * ```ts
+ * [true, false, 0, 1, "", "hello", null, undefined].filter(isNotNullish)
+ * // [true, false, 0, 1, "", "hello"]
+ * ```
+ */
+declare function isNotNullish<T>(v: T | null | undefined): v is NonNullable<T>;
+/**
+ * Checks if a value is not null.
+ *
+ * @template T - The type of the input value.
+ * @param {T | null} v - The value to check for not being null.
+ * @returns {v is Exclude<T, null>} True if the value is not null, false otherwise.
+ *
+ * @example
+ * ```ts
+ * [true, false, 0, 1, "", "hello", null, undefined].filter(isNotNull)
+ * // [true, false, 0, 1, "", "hello", undefined]
+ * ```
+ */
+declare function isNotNull<T>(v: T | null): v is Exclude<T, null>;
+/**
+ * Checks if a value is defined.
+ *
+ * @template T - The type of the input value.
+ * @param {T} v - The value to check for being defined.
+ * @returns {v is Exclude<T, undefined>} True if the value is defined, false otherwise.
+ *
+ * @example
+ * ```ts
+ * [true, false, 0, 1, "", "hello", null, undefined].filter(isDefined)
+ * // [true, false, 0, 1, "", "hello", null]
+ * ```
+ */
+declare function isNotUndefined<T>(v: T): v is Exclude<T, undefined>;
+/**
+ * Checks if a value is truthy, excluding null and undefined.
+ *
+ * @template T - The type of the input value.
+ * @param {T} v - The value to check for truthiness.
+ * @returns {v is NonNullable<T>} True if the value is truthy, false otherwise.
+ *
+ * @example
+ * ```ts
+ * [true, false, 0, 1, "", "hello", null, undefined].filter(isTruthy)
+ * // [true, 1, "hello"]
+ * ```
+ */
+declare function isTruthy<T>(v: T): v is NonNullable<T>;
+
+export { isNotNull, isNotNullish, isNotUndefined, isTruthy };

package/dist/guards.mjs

@@ -0,0 +1 @@
+export { isNotNull, isNotNullish, isNotUndefined, isTruthy } from './chunk-OKC7RR3A.mjs';

package/dist/index.cjs

@@ -0,0 +1,62 @@
+'use strict';
+
+// src/guards.ts
+function isNotNullish(v) {
+  return v != null;
+}
+function isNotNull(v) {
+  return v !== null;
+}
+function isNotUndefined(v) {
+  return v !== void 0;
+}
+function isTruthy(v) {
+  return Boolean(v);
+}
+
+// src/string.ts
+function capitalize(str) {
+  if (typeof str !== "string")
+    throw new TypeError("Expected a string");
+  if (str.trim().length === 0)
+    return "";
+  return str[0].toUpperCase() + str.slice(1).toLowerCase();
+}
+function toCamelCase(str) {
+  if (typeof str !== "string")
+    throw new TypeError("Expected a string");
+  if (str.trim().length === 0)
+    return "";
+  return str.toLowerCase().replace(/[-_](.)/g, (_, c) => c.toUpperCase());
+}
+function toKebabCase(str) {
+  if (typeof str !== "string")
+    throw new TypeError("Expected a string");
+  if (str.trim().length === 0)
+    return "";
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function toPascalCase(str) {
+  if (typeof str !== "string")
+    throw new TypeError("Expected a string");
+  if (str.trim().length === 0)
+    return "";
+  return str.toLowerCase().replace(/[-_](.)/g, (_, c) => c.toUpperCase()).replace(/^[a-z]/, (c) => c.toUpperCase());
+}
+function toSnakeCase(str) {
+  if (typeof str !== "string")
+    throw new TypeError("Expected a string");
+  if (str.trim().length === 0)
+    return "";
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+}
+
+exports.capitalize = capitalize;
+exports.isNotNull = isNotNull;
+exports.isNotNullish = isNotNullish;
+exports.isNotUndefined = isNotUndefined;
+exports.isTruthy = isTruthy;
+exports.toCamelCase = toCamelCase;
+exports.toKebabCase = toKebabCase;
+exports.toPascalCase = toPascalCase;
+exports.toSnakeCase = toSnakeCase;

package/dist/index.d.cts

@@ -0,0 +1,3 @@
+export { Arrayable, Awaitable, ElementOf, InferArguments, Nullable, Nullish } from './types.cjs';
+export { isNotNull, isNotNullish, isNotUndefined, isTruthy } from './guards.cjs';
+export { capitalize, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from './string.cjs';

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { Arrayable, Awaitable, ElementOf, InferArguments, Nullable, Nullish } from './types.js';
+export { isNotNull, isNotNullish, isNotUndefined, isTruthy } from './guards.js';
+export { capitalize, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from './string.js';

package/dist/index.mjs

@@ -0,0 +1,2 @@
+export { capitalize, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from './chunk-JVIVQFL7.mjs';
+export { isNotNull, isNotNullish, isNotUndefined, isTruthy } from './chunk-OKC7RR3A.mjs';

package/dist/string.cjs

@@ -0,0 +1,44 @@
+'use strict';
+
+// src/string.ts
+function capitalize(str) {
+  if (typeof str !== "string")
+    throw new TypeError("Expected a string");
+  if (str.trim().length === 0)
+    return "";
+  return str[0].toUpperCase() + str.slice(1).toLowerCase();
+}
+function toCamelCase(str) {
+  if (typeof str !== "string")
+    throw new TypeError("Expected a string");
+  if (str.trim().length === 0)
+    return "";
+  return str.toLowerCase().replace(/[-_](.)/g, (_, c) => c.toUpperCase());
+}
+function toKebabCase(str) {
+  if (typeof str !== "string")
+    throw new TypeError("Expected a string");
+  if (str.trim().length === 0)
+    return "";
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function toPascalCase(str) {
+  if (typeof str !== "string")
+    throw new TypeError("Expected a string");
+  if (str.trim().length === 0)
+    return "";
+  return str.toLowerCase().replace(/[-_](.)/g, (_, c) => c.toUpperCase()).replace(/^[a-z]/, (c) => c.toUpperCase());
+}
+function toSnakeCase(str) {
+  if (typeof str !== "string")
+    throw new TypeError("Expected a string");
+  if (str.trim().length === 0)
+    return "";
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+}
+
+exports.capitalize = capitalize;
+exports.toCamelCase = toCamelCase;
+exports.toKebabCase = toKebabCase;
+exports.toPascalCase = toPascalCase;
+exports.toSnakeCase = toSnakeCase;

package/dist/string.d.cts

@@ -0,0 +1,79 @@
+/**
+ * First letter uppercase, other lowercase
+ * @param {string} str - The string to capitalize
+ * @returns {string} The capitalized string
+ * @throws {TypeError} If `str` is not string
+ *
+ * @example
+ * ```ts
+ * capitalize("hello")
+ * // "Hello"
+ * ```
+ */
+declare function capitalize(str: string): string;
+/**
+ * Converts a string to camel case.
+ * @param {string} str - The input string to be converted.
+ * @returns {string} The camel cased string.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * ```ts
+ * toCamelCase("some_text_here")
+ * // "someTextHere"
+ *
+ * toCamelCase("another-Example")
+ * // "anotherExample"
+ * ```
+ */
+declare function toCamelCase(str: string): string;
+/**
+ * Converts a string to kebab case.
+ * @param {string} str - The input string to be converted.
+ * @returns {string} The kebab cased string.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * ```ts
+ * toKebabCase("someTextHere")
+ * // "some-text-here"
+ *
+ * toKebabCase("anotherExample")
+ * // "another-example"
+ * ```
+ */
+declare function toKebabCase(str: string): string;
+/**
+ * Converts a string to pascal case.
+ * @param {string} str - The input string to be converted.
+ * @returns {string} The pascal cased string.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * ```ts
+ * toPascalCase("some_text_here")
+ * // "SomeTextHere"
+ *
+ * toPascalCase("another-Example")
+ * // "AnotherExample"
+ * ```
+ */
+declare function toPascalCase(str: string): string;
+/**
+ * Converts a string to snake case.
+ * @param {string} str - The input string to be converted.
+ * @returns {string} The snake cased string.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * ```ts
+ * toSnakeCase("someTextHere")
+ * // "some_text_here"
+ *
+ * toSnakeCase("anotherExample")
+ * // "another_example"
+ * ```
+ */
+declare function toSnakeCase(str: string): string;
+
+export { capitalize, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/string.d.ts

@@ -0,0 +1,79 @@
+/**
+ * First letter uppercase, other lowercase
+ * @param {string} str - The string to capitalize
+ * @returns {string} The capitalized string
+ * @throws {TypeError} If `str` is not string
+ *
+ * @example
+ * ```ts
+ * capitalize("hello")
+ * // "Hello"
+ * ```
+ */
+declare function capitalize(str: string): string;
+/**
+ * Converts a string to camel case.
+ * @param {string} str - The input string to be converted.
+ * @returns {string} The camel cased string.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * ```ts
+ * toCamelCase("some_text_here")
+ * // "someTextHere"
+ *
+ * toCamelCase("another-Example")
+ * // "anotherExample"
+ * ```
+ */
+declare function toCamelCase(str: string): string;
+/**
+ * Converts a string to kebab case.
+ * @param {string} str - The input string to be converted.
+ * @returns {string} The kebab cased string.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * ```ts
+ * toKebabCase("someTextHere")
+ * // "some-text-here"
+ *
+ * toKebabCase("anotherExample")
+ * // "another-example"
+ * ```
+ */
+declare function toKebabCase(str: string): string;
+/**
+ * Converts a string to pascal case.
+ * @param {string} str - The input string to be converted.
+ * @returns {string} The pascal cased string.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * ```ts
+ * toPascalCase("some_text_here")
+ * // "SomeTextHere"
+ *
+ * toPascalCase("another-Example")
+ * // "AnotherExample"
+ * ```
+ */
+declare function toPascalCase(str: string): string;
+/**
+ * Converts a string to snake case.
+ * @param {string} str - The input string to be converted.
+ * @returns {string} The snake cased string.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * ```ts
+ * toSnakeCase("someTextHere")
+ * // "some_text_here"
+ *
+ * toSnakeCase("anotherExample")
+ * // "another_example"
+ * ```
+ */
+declare function toSnakeCase(str: string): string;
+
+export { capitalize, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/string.mjs

@@ -0,0 +1 @@
+export { capitalize, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from './chunk-JVIVQFL7.mjs';

package/dist/types.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/types.d.cts

@@ -0,0 +1,66 @@
+/**
+ * Whatever type, or Promise of that type
+ * @param T - Type
+ * @returns T or Promise<T>
+ *
+ * @example
+ * ```ts
+ * type A = Awaitable<string>
+ * // string | Promise<string>
+ * ```
+ */
+type Awaitable<T> = T | PromiseLike<T>;
+/**
+ * Whatever type, or null
+ * @param T - Type
+ * @returns T or null
+ *
+ * @example
+ * ```ts
+ * type A = Nullable<string>
+ * // string | null
+ * ```
+ */
+type Nullable<T> = T | null;
+/**
+ * Whatever type, null or undefined
+ * @param T - Type
+ * @returns T, undefined or null
+ *
+ * @example
+ * ```ts
+ * type A = Nullish<string>
+ * // string | null | undefined
+ * ```
+ */
+type Nullish<T> = T | null | undefined;
+/**
+ * Array, or not yet
+ */
+type Arrayable<T> = T | Array<T>;
+/**
+ * Infers the element type of an array
+ * @param T - Array type
+ * @returns The inferred element type
+ *
+ * @example
+ * ```ts
+ * type A = ElementOf<string[]>
+ * // string
+ * ```
+ */
+type ElementOf<T> = T extends (infer E)[] ? E : never;
+/**
+ * Infers the arguments type of a function
+ * @param T - Function type
+ * @returns The inferred arguments type
+ *
+ * @example
+ * ```ts
+ * type A = InferArguments<(a: string, b: number) => void>
+ * // [string, number]
+ * ```
+ */
+type InferArguments<T> = T extends ((...args: infer A) => any) ? A : never;
+
+export type { Arrayable, Awaitable, ElementOf, InferArguments, Nullable, Nullish };

package/dist/types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Whatever type, or Promise of that type
+ * @param T - Type
+ * @returns T or Promise<T>
+ *
+ * @example
+ * ```ts
+ * type A = Awaitable<string>
+ * // string | Promise<string>
+ * ```
+ */
+type Awaitable<T> = T | PromiseLike<T>;
+/**
+ * Whatever type, or null
+ * @param T - Type
+ * @returns T or null
+ *
+ * @example
+ * ```ts
+ * type A = Nullable<string>
+ * // string | null
+ * ```
+ */
+type Nullable<T> = T | null;
+/**
+ * Whatever type, null or undefined
+ * @param T - Type
+ * @returns T, undefined or null
+ *
+ * @example
+ * ```ts
+ * type A = Nullish<string>
+ * // string | null | undefined
+ * ```
+ */
+type Nullish<T> = T | null | undefined;
+/**
+ * Array, or not yet
+ */
+type Arrayable<T> = T | Array<T>;
+/**
+ * Infers the element type of an array
+ * @param T - Array type
+ * @returns The inferred element type
+ *
+ * @example
+ * ```ts
+ * type A = ElementOf<string[]>
+ * // string
+ * ```
+ */
+type ElementOf<T> = T extends (infer E)[] ? E : never;
+/**
+ * Infers the arguments type of a function
+ * @param T - Function type
+ * @returns The inferred arguments type
+ *
+ * @example
+ * ```ts
+ * type A = InferArguments<(a: string, b: number) => void>
+ * // [string, number]
+ * ```
+ */
+type InferArguments<T> = T extends ((...args: infer A) => any) ? A : never;
+
+export type { Arrayable, Awaitable, ElementOf, InferArguments, Nullable, Nullish };

package/dist/types.mjs

@@ -0,0 +1 @@
+

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@luxass/utils",
+  "version": "1.0.0",
+  "description": "A collection of utilities for JavaScript/TypeScript",
+  "type": "module",
+  "author": {
+    "name": "Lucas Nørgård",
+    "email": "lucasnrgaard@gmail.com",
+    "url": "https://luxass.dev"
+  },
+  "packageManager": "pnpm@8.12.0",
+  "license": "MIT",
+  "homepage": "https://github.com/luxass/utils",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/luxass/utils"
+  },
+  "bugs": {
+    "url": "https://github.com/luxass/utils/issues"
+  },
+  "keywords": [
+    "utils"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./guards": {
+      "import": {
+        "types": "./dist/guards.d.ts",
+        "default": "./dist/guards.mjs"
+      },
+      "require": {
+        "types": "./dist/guards.d.cts",
+        "default": "./dist/guards.cjs"
+      }
+    },
+    "./types": {
+      "import": {
+        "types": "./dist/types.d.ts",
+        "default": "./dist/types.mjs"
+      },
+      "require": {
+        "types": "./dist/types.d.cts",
+        "default": "./dist/types.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest --run",
+    "test:watch": "vitest",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@luxass/eslint-config": "^4.0.0-beta.16",
+    "@types/node": "^20.10.4",
+    "eslint": "^8.55.0",
+    "eslint-plugin-format": "^0.1.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vitest": "^1.0.4"
+  }
+}