@sv443-network/coreutils 0.0.1

package/dist/lib/Translate.d.ts

@@ -0,0 +1,65 @@
+/**
+ * @module Translate  
+ * This module contains a sophisticated but still lightweight, JSON-based translation system - [see the documentation for more info](https://github.com/Sv443-Network/CoreUtils/blob/main/docs.md#class-translate)  
+ */
+import type { Stringifiable } from "./types.js";
+/**
+ * Translation object to pass to {@linkcode tr.addTranslations()}  
+ * Can be a flat object of identifier keys and the translation text as the value, or an infinitely nestable object containing the same.  
+ *  
+ * @example  
+ * // Flat object:  
+ * const tr_en: TrObject = {  
+ *   hello: "Hello, %1!",  
+ *   foo: "Foo",  
+ * };  
+ *  
+ * // Nested object:  
+ * const tr_de: TrObject = {  
+ *   hello: "Hallo, %1!",  
+ *   foo: {  
+ *     bar: "Foo bar",  
+ *   },  
+ * };  
+ */
+export interface TrObject {
+    [key: string]: string | TrObject;
+}
+/** Properties for the transform function that transforms a matched translation string into something else */
+export type TransformFnProps<TTrKey extends string = string> = {
+    /** The currently set language - empty string if not set yet */
+    language: string;
+    /** The matches as returned by `RegExp.exec()` */
+    matches: RegExpExecArray[];
+    /** The translation key */
+    trKey: TTrKey;
+    /** Translation value before any transformations */
+    trValue: string;
+    /** Current value, possibly in-between transformations */
+    currentValue: string;
+    /** Arguments passed to the translation function */
+    trArgs: (Stringifiable | Record<string, Stringifiable>)[];
+};
+/** Function that transforms a matched translation string into another string */
+export type TransformFn<TTrKey extends string = string> = (props: TransformFnProps<TTrKey>) => Stringifiable;
+/**
+ * Pass a nested or flat translation object to this generic type to recursively get all keys in the object.  
+ * @example ```ts  
+ * type Keys = TrKeys<{ a: { b: { c: "bar" }, d: "foo" }, e: "baz" }>;  
+ * //    ^? type Keys = "a.b.c" | "a.d" | "e"  
+ * ```  
+ */
+export type TrKeys<TTrObj, P extends string = ""> = {
+    [K in keyof TTrObj]: K extends string | number | boolean | null | undefined ? TTrObj[K] extends object ? TrKeys<TTrObj[K], `${P}${K}.`> : `${P}${K}` : never;
+}[keyof TTrObj];
+/** Options for the {@linkcode Translate} class */
+export type TranslateOptions = {};
+/**
+ * Class that manages translations, provides many utility functions, handles fallbacks and allows you to specify custom transforms to insert values or modify the translation string in pretty much any way imaginable.  
+ */
+export declare class Translate {
+    readonly options: TranslateOptions;
+    /** All translations loaded into memory */
+    protected translations: Record<string, TrObject>;
+    constructor(options: TranslateOptions);
+}

package/dist/lib/array.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @module array  
+ * This module contains various functions for working with arrays - [see the documentation for more info](https://github.com/Sv443-Network/CoreUtils/blob/main/docs.md#arrays)  
+ */
+/** Describes an array with at least one item */
+export type NonEmptyArray<TArray = unknown> = [TArray, ...TArray[]];
+/** Returns a random item from the passed array */
+export declare function randomItem<TItem = unknown>(array: TItem[]): TItem | undefined;
+/**
+ * Returns a tuple of a random item and its index from the passed array  
+ * Returns `[undefined, undefined]` if the passed array is empty  
+ */
+export declare function randomItemIndex<TItem = unknown>(array: TItem[]): [item?: TItem, index?: number];
+/** Returns a copy of the array with its items in a random order */
+export declare function randomizeArray<TItem = unknown>(array: TItem[]): TItem[];
+/** Returns a random item from the passed array and mutates the array to remove the item */
+export declare function takeRandomItem<TItem = unknown>(arr: TItem[]): TItem | undefined;
+/** Returns a random item and its index as a tuple from the passed array and mutates the array to remove the item */
+export declare function takeRandomItemIndex<TItem = unknown>(arr: TItem[]): [item?: TItem, index?: number];

package/dist/lib/colors.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @module colors  
+ * This module contains various functions for working with colors - [see the documentation for more info](https://github.com/Sv443-Network/CoreUtils/blob/main/docs.md#colors)  
+ */
+/**
+ * Darkens a CSS color value (in `#HEX`, `HEX`, `rgb()` or `rgba()` format) by a given percentage.  
+ * Will not exceed the maximum range (`00-FF` / `0-255`).  
+ * The alpha value is not changed.  
+ * @returns Returns the new color value in the same format as the input  
+ * @throws Throws if the color format is invalid or not supported  
+ */
+export declare function darkenColor(color: string, percent: number, upperCase?: boolean): string;
+/**
+ * Converts a hex color string in the format `#RRGGBB`, `#RRGGBBAA` (or even `RRGGBB` and `RGB`) to a tuple.  
+ * @returns Returns a tuple array where R, G and B are an integer in the range `0-255` and alpha is a float in the range `0-1`, or `undefined` if no alpha channel exists.  
+ */
+export declare function hexToRgb(hex: string): [red: number, green: number, blue: number, alpha?: number];
+/**
+ * Lightens a CSS color value (in `#HEX`, `HEX`, `rgb()` or `rgba()` format) by a given percentage.  
+ * Will not exceed the maximum range (`00-FF` / `0-255`).  
+ * The alpha value is not changed.  
+ * @returns Returns the new color value in the same format as the input  
+ * @throws Throws if the color format is invalid or not supported  
+ */
+export declare function lightenColor(color: string, percent: number, upperCase?: boolean): string;
+/** Converts RGB or RGBA number values to a hex color string in the format `#RRGGBB` or `#RRGGBBAA` */
+export declare function rgbToHex(red: number, green: number, blue: number, alpha?: number, withHash?: boolean, upperCase?: boolean): string;

package/dist/lib/crypto.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @module crypto  
+ * This module contains various cryptographic functions, like compression and ArrayBuffer encoding - [see the documentation for more info](https://github.com/Sv443-Network/CoreUtils/blob/main/docs.md#crypto)  
+ */
+import type { Stringifiable } from "./types.js";
+/** Converts an ArrayBuffer to a base64-encoded (ASCII) string */
+export declare function abtoa(buf: ArrayBuffer): string;
+/** Converts a base64-encoded (ASCII) string to an ArrayBuffer representation of its bytes */
+export declare function atoab(str: string): ArrayBuffer;
+/** Compresses a string or an ArrayBuffer using the provided {@linkcode compressionFormat} and returns it as a base64 string */
+export declare function compress(input: Stringifiable | ArrayBuffer, compressionFormat: CompressionFormat, outputType?: "string"): Promise<string>;
+/** Compresses a string or an ArrayBuffer using the provided {@linkcode compressionFormat} and returns it as an ArrayBuffer */
+export declare function compress(input: Stringifiable | ArrayBuffer, compressionFormat: CompressionFormat, outputType: "arrayBuffer"): Promise<ArrayBuffer>;
+/** Decompresses a previously compressed base64 string or ArrayBuffer, with the format passed by {@linkcode compressionFormat}, converted to a string */
+export declare function decompress(input: Stringifiable | ArrayBuffer, compressionFormat: CompressionFormat, outputType?: "string"): Promise<string>;
+/** Decompresses a previously compressed base64 string or ArrayBuffer, with the format passed by {@linkcode compressionFormat}, converted to an ArrayBuffer */
+export declare function decompress(input: Stringifiable | ArrayBuffer, compressionFormat: CompressionFormat, outputType: "arrayBuffer"): Promise<ArrayBuffer>;
+/**
+ * Creates a hash / checksum of the given {@linkcode input} string or ArrayBuffer using the specified {@linkcode algorithm} ("SHA-256" by default).  
+ *  
+ * - ⚠️ Uses the SubtleCrypto API so it needs to run in a secure context (HTTPS).  
+ * - ⚠️ If you use this for cryptography, make sure to use a secure algorithm (under no circumstances use SHA-1) and to [salt](https://en.wikipedia.org/wiki/Salt_(cryptography)) your input data.  
+ */
+export declare function computeHash(input: string | ArrayBuffer, algorithm?: string): Promise<string>;
+/**
+ * Generates a random ID with the specified length and radix (16 characters and hexadecimal by default)  
+ *  
+ * - ⚠️ Not suitable for generating anything related to cryptography! Use [SubtleCrypto's `generateKey()`](https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/generateKey) for that instead.  
+ * @param length The length of the ID to generate (defaults to 16)  
+ * @param radix The [radix](https://en.wikipedia.org/wiki/Radix) of each digit (defaults to 16 which is hexadecimal. Use 2 for binary, 10 for decimal, 36 for alphanumeric, etc.)  
+ * @param enhancedEntropy If set to true, uses [`crypto.getRandomValues()`](https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues) for better cryptographic randomness (this also makes it take longer to generate)  
+ * @param randomCase If set to false, the generated ID will be lowercase only - also makes use of the `enhancedEntropy` parameter unless the output doesn't contain letters  
+ */
+export declare function randomId(length?: number, radix?: number, enhancedEntropy?: boolean, randomCase?: boolean): string;

package/dist/lib/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @module @sv443-network/coreutils  
+ * @description Cross-platform, general-purpose, JavaScript core library for Node, Deno and the browser. Intended to be used in conjunction with [`@sv443-network/userutils`](https://github.com/Sv443-Network/UserUtils) and [`@sv443-network/djsutils`](https://github.com/Sv443-Network/DJSUtils), but can be used independently as well.  
+ */
+export * from "./array.js";
+export * from "./colors.js";
+export * from "./crypto.js";
+export * from "./math.js";
+export * from "./misc.js";
+export * from "./text.js";
+export * from "./types.js";
+export * from "./DataStore.js";
+export * from "./DataStoreEngine.js";
+export * from "./DataStoreSerializer.js";
+export * from "./Debouncer.js";
+export * from "./Errors.js";
+export * from "./NanoEmitter.js";

package/dist/lib/math.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @module math  
+ * This module contains general-purpose math functions like clamping, mapping and random number generation - [see the documentation for more info](https://github.com/Sv443-Network/CoreUtils/blob/main/docs.md#math)  
+ */
+import type { NumberFormat, Stringifiable } from "./types.js";
+/** Checks if the given {@linkcode bitSet} contains the given {@linkcode checkVal} */
+export declare function bitSetHas<TType extends number | bigint>(bitSet: TType, checkVal: TType): boolean;
+/** Ensures the passed {@linkcode value} always stays between {@linkcode min} and {@linkcode max} */
+export declare function clamp(value: number, min: number, max: number): number;
+/** Ensures the passed {@linkcode value} always stays between 0 and {@linkcode max} */
+export declare function clamp(value: number, max: number): number;
+/**
+ * Calculates the amount of digits in the given number - the given number or string will be passed to the `Number()` constructor.  
+ * Returns NaN if the number is invalid.  
+ * @param num The number to count the digits of  
+ * @param withDecimals Whether to count the decimal places as well (defaults to true)  
+ * @example ```ts  
+* digitCount();            // NaN  
+* digitCount(123);         // 3  
+* digitCount(1.23);        // 3  
+* digitCount(1.23, false); // 1  
+* digitCount(Infinity);    // Infinity  
+* ```  
+*/
+export declare function digitCount(num: number | Stringifiable, withDecimals?: boolean): number;
+/** Formats a number with the given locale and format */
+export declare function formatNumber(number: number, locale: string, format: NumberFormat): string;
+/**
+ * Transforms the value parameter from the numerical range `range1min` to `range1max` to the numerical range `range2min` to `range2max`  
+ * For example, you can map the value 2 in the range of 0-5 to the range of 0-10 and you'd get a 4 as a result.  
+ */
+export declare function mapRange(value: number, range1min: number, range1max: number, range2min: number, range2max: number): number;
+/**
+ * Transforms the value parameter from the numerical range `0` to `range1max` to the numerical range `0` to `range2max`  
+ * For example, you can map the value 2 in the range of 0-5 to the range of 0-10 and you'd get a 4 as a result.  
+ */
+export declare function mapRange(value: number, range1max: number, range2max: number): number;
+/**
+ * Returns a random number between {@linkcode min} and {@linkcode max} (inclusive)  
+ * Set {@linkcode enhancedEntropy} to true to use `crypto.getRandomValues()` for better cryptographic randomness (this also makes it take longer to generate)  
+ */
+export declare function randRange(min: number, max: number, enhancedEntropy?: boolean): number;
+/**
+ * Returns a random number between 0 and {@linkcode max} (inclusive)  
+ * Set {@linkcode enhancedEntropy} to true to use `crypto.getRandomValues()` for better cryptographic randomness (this also makes it take longer to generate)  
+ */
+export declare function randRange(max: number, enhancedEntropy?: boolean): number;
+/**
+ * Rounds {@linkcode num} to a fixed amount of decimal places, specified by {@linkcode fractionDigits} (supports negative values to round to the nearest power of 10).  
+ * @example ```ts  
+ * roundFixed(234.567, -2); // 200  
+ * roundFixed(234.567, -1); // 230  
+ * roundFixed(234.567, 0);  // 235  
+ * roundFixed(234.567, 1);  // 234.6  
+ * roundFixed(234.567, 2);  // 234.57  
+ * roundFixed(234.567, 3);  // 234.567  
+ * ```  
+ */
+export declare function roundFixed(num: number, fractionDigits: number): number;
+/** Rounds the given values at the given decimal place (same as in {@linkcode roundFixed()}) and checks if they are within the given range (0.5 by default) */
+export declare function valsWithin(a: number, b: number, dec?: number, withinRange?: number): boolean;

package/dist/lib/misc.d.ts

@@ -0,0 +1,65 @@
+/**
+ * @module misc  
+ * This module contains miscellaneous functions that don't fit in another category - [see the documentation for more info](https://github.com/Sv443-Network/UserUtils/blob/main/docs.md#misc)  
+ */
+import type { ListLike, Prettify, Stringifiable } from "./types.js";
+/**
+ * A ValueGen value is either its type, a promise that resolves to its type, or a function that returns its type, either synchronous or asynchronous.  
+ * ValueGen allows for the utmost flexibility when applied to any type, as long as {@linkcode consumeGen()} is used to get the final value.  
+ * @template TValueType The type of the value that the ValueGen should yield  
+ */
+export type ValueGen<TValueType> = TValueType | Promise<TValueType> | (() => TValueType | Promise<TValueType>);
+/**
+ * Turns a {@linkcode ValueGen} into its final value.  
+ * @template TValueType The type of the value that the ValueGen should yield  
+ */
+export declare function consumeGen<TValueType>(valGen: ValueGen<TValueType>): Promise<TValueType>;
+/**
+ * A StringGen value is either a string, anything that can be converted to a string, or a function that returns one of the previous two, either synchronous or asynchronous, or a promise that returns a string.  
+ * StringGen allows for the utmost flexibility when dealing with strings, as long as {@linkcode consumeStringGen()} is used to get the final string.  
+ */
+export type StringGen = ValueGen<Stringifiable>;
+/**
+ * Turns a {@linkcode StringGen} into its final string value.  
+ * @template TStrUnion The union of strings that the StringGen should yield - this allows for finer type control compared to {@linkcode consumeGen()}  
+ */
+export declare function consumeStringGen<TStrUnion extends string>(strGen: StringGen): Promise<TStrUnion>;
+/** Options for the `fetchAdvanced()` function */
+export type FetchAdvancedOpts = Prettify<Partial<{
+    /** Timeout in milliseconds after which the fetch call will be canceled with an AbortController signal */
+    timeout: number;
+}> & RequestInit>;
+/** Calls the fetch API with special options like a timeout */
+export declare function fetchAdvanced(input: string | RequestInfo | URL, options?: FetchAdvancedOpts): Promise<Response>;
+/**
+ * Returns the length of the given list-like object (anything with a numeric `length`, `size` or `count` property, like an array, Map or NodeList).  
+ * If the object doesn't have any of these properties, it will return 0 by default.  
+ * Set {@linkcode zeroOnInvalid} to false to return NaN instead of 0 if the object doesn't have any of the properties.  
+ */
+export declare function getListLength(listLike: ListLike, zeroOnInvalid?: boolean): number;
+/**
+ * Pauses async execution for the specified time in ms.  
+ * If an `AbortSignal` is passed, the pause will be aborted when the signal is triggered.  
+ * By default, this will resolve the promise, but you can set {@linkcode rejectOnAbort} to true to reject it instead.  
+ */
+export declare function pauseFor(time: number, signal?: AbortSignal, rejectOnAbort?: boolean): Promise<void>;
+/**
+ * Turns the passed object into a "pure" object without a prototype chain, meaning it won't have any default properties like `toString`, `__proto__`, `__defineGetter__`, etc.  
+ * This makes the object immune to prototype pollution attacks and allows for cleaner object literals, at the cost of being harder to work with in some cases.  
+ * It also effectively transforms a `Stringifiable` value into one that will throw a TypeError when stringified instead of defaulting to `[object Object]`  
+ * If no object is passed, it will return an empty object without prototype chain.  
+ */
+export declare function pureObj<TObj extends object>(obj?: TObj): TObj;
+/**
+ * Works similarly to `setInterval()`, but the callback is also called immediately and can be aborted with an `AbortSignal`.  
+ * Uses `setInterval()` internally, which might cause overlapping calls if the callback's synchronous execution takes longer than the given interval time.  
+ * This function will prevent skewing the interval time, contrary to {@linkcode setImmediateTimeoutLoop()}.  
+ * Returns a cleanup function that will stop the interval if called.  
+ */
+export declare function setImmediateInterval(callback: () => void | unknown, interval: number, signal?: AbortSignal): void;
+/**
+ * Works similarly to `setInterval()`, but the callback is also called immediately and can be aborted with an `AbortSignal`.  
+ * Uses `setTimeout()` internally to avoid overlapping calls, though this will skew the given interval time by however long the callback takes to execute synchronously.  
+ * Returns a cleanup function that will stop the interval if called.  
+ */
+export declare function setImmediateTimeoutLoop(callback: () => void | unknown | Promise<void | unknown>, interval: number, signal?: AbortSignal): void;

package/dist/lib/text.d.ts

@@ -0,0 +1,41 @@
+import type { ListLike, Prettify, Stringifiable } from "./types.js";
+/**
+ * Automatically pluralizes the given string an `-s` or `-ies` to the passed {@linkcode term}, if {@linkcode num} is not equal to 1.  
+ * By default, words ending in `-y` will have it replaced with `-ies`, and all other words will simply have `-s` appended.  
+ * If {@linkcode num} resolves to NaN or the {@linkcode pluralType} is wrong, it defaults to the {@linkcode pluralType} `auto` and sets {@linkcode num} to 2.  
+ * @param term The term, written in singular form, to auto-convert to plural form  
+ * @param num A number, or list-like value that has either a `length`, `count` or `size` property, like an array, Map or discord.js Collection - does not support iterables, they need to be converted to an array first  
+ * @param pluralType Which plural form to use when auto-pluralizing. Defaults to `"auto"`, which removes the last char and uses `-ies` for words ending in `y` and simply appends `-s` for all other words  
+ */
+export declare function autoPlural(term: Stringifiable, num: number | ListLike, pluralType?: "auto" | "-s" | "-ies"): string;
+/** Capitalizes the first letter of a string */
+export declare function capitalize(text: string): string;
+/** The default progress bar characters used by {@linkcode createProgressBar()} */
+export declare const defaultPbChars: {
+    readonly 100: "█";
+    readonly 75: "▓";
+    readonly 50: "▒";
+    readonly 25: "░";
+    readonly 0: "─";
+};
+/** Progress bar characters used by {@linkcode createProgressBar()} */
+export type ProgressBarChars = Prettify<Record<keyof typeof defaultPbChars, string>>;
+/**
+ * Generates a progress bar with the given percentage and max length.  
+ * Uses opaque, dithered unicode block characters by default for extra detail.  
+ * Use {@linkcode chars} to override the default characters (for example, use emojis via `<:emoji:ID>` or `😃`)  
+ */
+export declare function createProgressBar(percentage: number, barLength: number, chars?: ProgressBarChars): string;
+/**
+ * Inserts the passed values into a string at the respective placeholders.  
+ * The placeholder format is `%n`, where `n` is the 1-indexed argument number.  
+ * @param input The string to insert the values into  
+ * @param values The values to insert, in order, starting at `%1`  
+ */
+export declare function insertValues(input: string, ...values: Stringifiable[]): string;
+/** Joins an array of strings with a separator and a last separator - defaults to `,` & `and` */
+export declare function joinArrayReadable(array: unknown[], separators?: string, lastSeparator?: string): string;
+/** Converts seconds into the timestamp format `(hh:)mm:ss`, with intelligent zero-padding */
+export declare function secsToTimeStr(seconds: number): string;
+/** Truncates a string if it exceeds `length` and inserts `endStr` at the end (empty string to disable), so that the final string doesn't exceed the given length */
+export declare function truncStr(input: Stringifiable, length: number, endStr?: string): string;

package/dist/lib/types.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @module types  
+ * This module contains various utility types - [see the documentation for more info](https://github.com/Sv443-Network/CoreUtils/blob/main/docs.md#types)  
+ */
+/** Any value that is list-like, i.e. has a quantifiable length, count or size property */
+export type ListLike = unknown[] | {
+    length: number;
+} | {
+    count: number;
+} | {
+    size: number;
+};
+/**
+ * A type that offers autocomplete for the passed union but also allows any arbitrary value of the same type to be passed.  
+ * Supports unions of strings, numbers and objects.  
+ */
+export type LooseUnion<TUnion extends string | number | object> = (TUnion) | (TUnion extends string ? (string & {}) : (TUnion extends number ? (number & {}) : (TUnion extends Record<keyof any, unknown> ? (object & {}) : never)));
+/** Any class reference that can be instantiated with `new` */
+export type Newable<T> = new (...args: any[]) => T;
+/**
+ * A type that allows all strings except for empty ones  
+ * @example  
+ * function foo<T extends string>(bar: NonEmptyString<T>) {  
+ *   console.log(bar);  
+ * }  
+ */
+export type NonEmptyString<TString extends string> = TString extends "" ? never : TString;
+/** String constant that decides which set of number formatting options to use */
+export type NumberFormat = "short" | "long";
+/**
+ * Makes the structure of a type more readable by expanding it.  
+ * This can be useful for debugging or for improving the readability of complex types.  
+ */
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/** Any value that can be serialized to JSON */
+export type SerializableVal = string | number | boolean | null | SerializableVal[] | {
+    [key: string]: SerializableVal;
+};
+/** Any value that can be implicitly converted to a string with `String(val)`, `val.toString()` or \``${val}`\` */
+export type Stringifiable = string | number | boolean | null | undefined | {
+    toString(): string;
+} | Stringifiable[];

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@sv443-network/coreutils",
+  "libName": "@sv443-network/coreutils",
+  "version": "0.0.1",
+  "description": "",
+  "main": "dist/CoreUtils.cjs",
+  "module": "dist/CoreUtils.mjs",
+  "types": "dist/lib/index.d.ts",
+  "exports": {
+    ".": {
+      "browser": "./dist/CoreUtils.min.umd.js",
+      "types": "./dist/lib/index.d.ts",
+      "require": "./dist/CoreUtils.cjs",
+      "import": "./dist/CoreUtils.mjs"
+    }
+  },
+  "type": "module",
+  "scripts": {
+    "lint": "eslint . && tsc --noEmit",
+    "format": "eslint . --fix",
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "update-jsr-version": "node --import tsx ./tools/update-jsr-version.mts",
+    "publish-package": "changeset publish",
+    "publish-package-jsr": "pnpm update-jsr-version && npx jsr publish --allow-dirty",
+    "check-jsr": "pnpm update-jsr-version && npx jsr publish --allow-dirty --dry-run",
+    "change": "changeset",
+    "test": "vitest",
+    "test-coverage": "vitest --coverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Sv443-Network/CoreUtils.git"
+  },
+  "keywords": [
+    "userscript",
+    "utilities"
+  ],
+  "author": {
+    "name": "Sv443",
+    "url": "https://github.com/Sv443"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Sv443-Network/CoreUtils/issues"
+  },
+  "homepage": "https://github.com/Sv443-Network/CoreUtils",
+  "dependencies": {
+    "nanoevents": "^9.1.0"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.29.4",
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.26.0",
+    "@swc/core": "^1.11.29",
+    "@testing-library/dom": "^10.4.0",
+    "@types/node": "^22.15.18",
+    "@types/tx2": "^1.0.3",
+    "@typescript-eslint/eslint-plugin": "^8.32.1",
+    "@typescript-eslint/parser": "^8.32.1",
+    "@typescript-eslint/utils": "^8.32.1",
+    "@vitest/coverage-v8": "^3.1.3",
+    "esbuild-plugin-umd-wrapper": "^3.0.0",
+    "eslint": "^9.26.0",
+    "globals": "^16.1.0",
+    "jsdom": "^26.1.0",
+    "tslib": "^2.8.1",
+    "tsup": "^8.4.0",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.3"
+  },
+  "files": [
+    "/dist/CoreUtils.cjs",
+    "/dist/CoreUtils.min.cjs",
+    "/dist/CoreUtils.mjs",
+    "/dist/CoreUtils.min.mjs",
+    "/dist/CoreUtils.umd.js",
+    "/dist/CoreUtils.min.umd.js",
+    "/dist/lib/**/*.d.ts",
+    "/package.json",
+    "/README.md",
+    "/CHANGELOG.md",
+    "/LICENSE.txt"
+  ]
+}