resultfier 1.0.0 → 3.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Vitor Koch
+
+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,48 @@
+# resultfier
+
+A TypeScript/JavaScript library that brings Rust's `Result<T, E>` type to your projects. Provides robust error handling with type safety and functional programming patterns.
+
+## Features
+
+- 🦀 Rust-inspired `Result<T, E>` type
+- 🛡️ Type-safe error handling
+- ⚡ Zero dependencies
+- 🔄 Functional programming methods (map, andThen, etc.)
+- 📦 TypeScript-first with full type support
+- 🎯 Simple and intuitive API
+
+## Installation
+
+```bash
+npm install @vikoch/resultfier
+# or
+yarn add @vikoch/resultfier
+# or
+bun add @vikoch/resultfier
+```
+
+## Quick Start
+
+```typescript
+import type { Result } from '@vikoch/resultfier'
+import { err, ok } from '@vikoch/resultfier'
+
+function divide(a: number, b: number): Result<number, string> {
+	if (b === 0) {
+		return err('Cannot divide by zero')
+	}
+	return ok(a / b)
+}
+
+const result = divide(10, 2)
+
+// Type Narrowing
+if (result.isOk) {
+	console.log('Result:', result.value) // 5
+	// ^? Ok<number>
+}
+else {
+	console.log('Error:', result.error) // Cannot divide by zero
+	// ^? Err<string>
+}
+```

package/dist/action/index.d.mts

@@ -0,0 +1,6 @@
+import { t as AsyncResult } from "../result-DIdNM9rp.mjs";
+
+//#region src/action/action.d.ts
+type AsyncAction<TData, TError, TParams = null> = (params: TParams extends null ? void : TParams) => AsyncResult<TData, TError>;
+//#endregion
+export { type AsyncAction };

package/dist/action/index.mjs

@@ -0,0 +1 @@
+export {};

package/dist/core/index.mjs

@@ -0,0 +1,2 @@
+import { a as err, i as Err, n as Ok, r as ok, t as toAsyncResult } from "../core-BdRFoSfb.mjs";
+export { Err, Ok, err, ok, toAsyncResult };

package/dist/core-BdRFoSfb.mjs

@@ -0,0 +1,101 @@
+var ResultBase = class {};
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
+}
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+var Err = class Err extends ResultBase {
+	constructor(error) {
+		super();
+		this.error = error;
+		_defineProperty(this, "_tag", "err");
+		_defineProperty(this, "isOk", false);
+		_defineProperty(this, "isErr", true);
+	}
+	map(_fn) {
+		return this;
+	}
+	mapErr(fn) {
+		return new Err(fn(this.error));
+	}
+	valueOr(defaultValue) {
+		return defaultValue;
+	}
+	valueOrElse(fn) {
+		return fn(this.error);
+	}
+	andThen(_fn) {
+		return this;
+	}
+	contains(_value) {
+		return false;
+	}
+	containsErr(error) {
+		return this.error === error;
+	}
+};
+function err(error) {
+	return new Err(error);
+}
+var Ok = class Ok extends ResultBase {
+	constructor(value) {
+		super();
+		this.value = value;
+		_defineProperty(this, "_tag", "ok");
+		_defineProperty(this, "isOk", true);
+		_defineProperty(this, "isErr", false);
+	}
+	map(fn) {
+		return new Ok(fn(this.value));
+	}
+	mapErr(_fn) {
+		return this;
+	}
+	valueOr(_defaultValue) {
+		return this.value;
+	}
+	valueOrElse(_fn) {
+		return this.value;
+	}
+	andThen(fn) {
+		return fn(this.value);
+	}
+	contains(value) {
+		return this.value === value;
+	}
+	containsErr(_error) {
+		return false;
+	}
+};
+function ok(value) {
+	return new Ok(value);
+}
+async function toAsyncResult(callback) {
+	return Promise.resolve(callback()).then((value) => ok(value)).catch((error) => err(error));
+}
+export { err as a, Err as i, Ok as n, ok as r, toAsyncResult as t };

package/dist/index.d.mts

@@ -0,0 +1,6 @@
+import { a as ok, i as Ok, n as Result, o as Err, r as ResultBase, s as err, t as AsyncResult } from "./result-DIdNM9rp.mjs";
+
+//#region src/core/utils.d.ts
+declare function toAsyncResult<T, E>(callback: () => Promise<T> | T): AsyncResult<T, E>;
+//#endregion
+export { AsyncResult, Err, Ok, Result, ResultBase, err, ok, toAsyncResult };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { a as err, i as Err, n as Ok, r as ok, t as toAsyncResult } from "./core-BdRFoSfb.mjs";
+export { Err, Ok, err, ok, toAsyncResult };

package/dist/result-DIdNM9rp.d.mts

@@ -0,0 +1,147 @@
+//#region src/core/err.d.ts
+
+/**
+ * Represents an error result containing an error value.
+ */
+declare class Err<E> extends ResultBase<never, E> {
+  readonly error: E;
+  readonly _tag: "err";
+  readonly isOk = false;
+  readonly isErr = true;
+  constructor(error: E);
+  /**
+   * Maps the value type, but since this is `Err`, it's a no-op.
+   */
+  map<U>(_fn: (value: never) => U): Err<E>;
+  /**
+   * Maps the contained error using the provided function.
+   * Since this is `Err`, the function is always applied.
+   */
+  mapErr<F>(fn: (error: E) => F): Err<F>;
+  /**
+   * Returns the provided default value since this is `Err`.
+   */
+  valueOr<T>(defaultValue: T): T;
+  /**
+   * Computes and returns the fallback value using the provided function.
+   */
+  valueOrElse<T>(fn: (error: E) => T): T;
+  /**
+   * Returns this `Err` unchanged since there's no value to chain.
+   */
+  andThen<U>(_fn: (value: never) => Result<U, E>): Err<E>;
+  /**
+   * Always returns false since this is `Err`, not `Ok`.
+   */
+  contains(_value: never): boolean;
+  /**
+   * Checks if the contained error matches the provided error.
+   */
+  containsErr(error: E): boolean;
+}
+/**
+ * Creates a new `Err` result with the given error.
+ */
+declare function err<E>(error: E): Err<E>;
+//#endregion
+//#region src/core/ok.d.ts
+/**
+ * Represents a successful result containing a value.
+ */
+declare class Ok<T> extends ResultBase<T, never> {
+  readonly value: T;
+  readonly _tag: "ok";
+  readonly isOk = true;
+  readonly isErr = false;
+  constructor(value: T);
+  /**
+   * Maps the contained value using the provided function.
+   * Since this is `Ok`, the function is always applied.
+   */
+  map<U>(fn: (value: T) => U): Ok<U>;
+  /**
+   * Maps the error type, but since this is `Ok`, it's a no-op.
+   */
+  mapErr<F>(_fn: (error: never) => F): Ok<T>;
+  /**
+   * Returns the contained value, ignoring the default.
+   */
+  valueOr(_defaultValue: T): T;
+  /**
+   * Returns the contained value, ignoring the fallback function.
+   */
+  valueOrElse(_fn: (error: never) => T): T;
+  /**
+   * Applies the function to the contained value and returns the result.
+   */
+  andThen<U>(fn: (value: T) => Result<U, never>): Result<U, never>;
+  /**
+   * Checks if the contained value matches the provided value.
+   */
+  contains(value: T): boolean;
+  /**
+   * Always returns false since this is `Ok`, not `Err`.
+   */
+  containsErr(_error: never): false;
+}
+/**
+ * Creates a new `Ok` result with the given value.
+ */
+declare function ok<T>(value: T): Ok<T>;
+//#endregion
+//#region src/core/result.d.ts
+/**
+ * Represents a Result type that can either be a success (`Ok`) or an error (`Err`).
+ * This is an abstract base class that provides common functionality for both variants.
+ */
+declare abstract class ResultBase<T, E> {
+  /**
+   * Type guard to check if the result is an `Ok` variant.
+   */
+  abstract readonly isOk: boolean;
+  /**
+   * Type guard to check if the result is an `Err` variant.
+   */
+  abstract readonly isErr: boolean;
+  /**
+   * Maps a `Result<T, E>` to `Result<U, E>` by applying a function to a contained `Ok` value,
+   * leaving an `Err` value untouched.
+   */
+  abstract map<U>(fn: (value: T) => U): Result<U, E>;
+  /**
+   * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a contained `Err` value,
+   * leaving an `Ok` value untouched.
+   */
+  abstract mapErr<F>(fn: (error: E) => F): Result<T, F>;
+  /**
+   * Returns the contained `Ok` value or a provided default.
+   */
+  abstract valueOr(defaultValue: T): T;
+  /**
+   * Returns the contained `Ok` value or computes it from a closure.
+   */
+  abstract valueOrElse(fn: (error: E) => T): T;
+  /**
+   * Calls the provided function with the contained value and returns the result.
+   * If the result is `Err`, the function is not called and the `Err` is returned.
+   */
+  abstract andThen<U>(fn: (value: T) => Result<U, E>): Result<U, E>;
+  /**
+   * Returns true if the result is `Ok` and the value inside of it matches a predicate.
+   */
+  abstract contains(value: T): boolean;
+  /**
+   * Returns true if the result is `Err` and the error inside of it matches a predicate.
+   */
+  abstract containsErr(error: E): boolean;
+}
+/**
+ * Type alias for a `Result` that can be either `Ok<T>` or `Err<E>`.
+ */
+type Result<T, E> = Ok<T> | Err<E>;
+/**
+ * Type alias for an async `Result` (Promise-wrapped `Result`).
+ */
+type AsyncResult<T, E> = Promise<Result<T, E>>;
+//#endregion
+export { ok as a, Ok as i, Result as n, Err as o, ResultBase as r, err as s, AsyncResult as t };

package/package.json

@@ -1,27 +1,43 @@
 {
-  "name": "resultfier",
-  "version": "1.0.0",
-  "description": "A TypeScript implementation of Rust-like Result type for better error handling",
-  "type": "module",
-  "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "bun run build"
-  },
-  "author": "Vitor Koch <vitorgabrielkoch@gmail.com>",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/vitorkoch/resultfier.git"
-  },
-  "bugs": {
-    "url": "https://github.com/vitorkoch/resultfier/issues"
-  },
-  "homepage": "https://github.com/vitorkoch/resultfier#readme",
-  "devDependencies": {
-    "@types/bun": "latest",
-    "typescript": "^5.9.2"
-  },
-  "peerDependencies": {
-    "typescript": "^5"
-  }
+	"name": "resultfier",
+	"type": "module",
+	"version": "3.0.0",
+	"private": "false",
+	"packageManager": "bun@1.3.5",
+	"description": "A TypeScript/JavaScript library that brings Rust's Result<T, E> type for robust error handling",
+	"author": "Vitor Koch",
+	"license": "MIT",
+	"keywords": ["rust", "error handling", "result", "typescript"],
+	"exports": {
+		".": {
+			"types": "./dist/index.d.mts",
+			"import": "./dist/index.mjs"
+		},
+		"./core": {
+			"types": "./dist/core/index.d.mts",
+			"import": "./dist/core/index.mjs"
+		},
+		"./action": {
+			"types": "./dist/action/index.d.mts",
+			"import": "./dist/action/index.mjs"
+		}
+	},
+	"main": "./dist/index.mjs",
+	"module": "./dist/index.mjs",
+	"types": "./dist/index.d.mts",
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"lint": "eslint",
+		"lint:fix": "eslint --fix",
+		"build": "tsdown",
+		"prepublishOnly": "npm run build"
+	},
+	"devDependencies": {
+		"@antfu/eslint-config": "^6.7.3",
+		"eslint": "^9.39.2",
+		"eslint-plugin-format": "^1.1.0",
+		"tsdown": "^0.18.2"
+	}
 }

package/bun.lock

@@ -1,30 +0,0 @@
-{
-  "lockfileVersion": 1,
-  "workspaces": {
-    "": {
-      "name": "resultfier",
-      "devDependencies": {
-        "@types/bun": "latest",
-        "typescript": "^5.9.2",
-      },
-      "peerDependencies": {
-        "typescript": "^5.9.2",
-      },
-    },
-  },
-  "packages": {
-    "@types/bun": ["@types/bun@1.2.21", "", { "dependencies": { "bun-types": "1.2.21" } }, "sha512-NiDnvEqmbfQ6dmZ3EeUO577s4P5bf4HCTXtI6trMc6f6RzirY5IrF3aIookuSpyslFzrnvv2lmEWv5HyC1X79A=="],
-
-    "@types/node": ["@types/node@24.3.1", "", { "dependencies": { "undici-types": "~7.10.0" } }, "sha512-3vXmQDXy+woz+gnrTvuvNrPzekOi+Ds0ReMxw0LzBiK3a+1k0kQn9f2NWk+lgD4rJehFUmYy2gMhJ2ZI+7YP9g=="],
-
-    "@types/react": ["@types/react@19.1.12", "", { "dependencies": { "csstype": "^3.0.2" } }, "sha512-cMoR+FoAf/Jyq6+Df2/Z41jISvGZZ2eTlnsaJRptmZ76Caldwy1odD4xTr/gNV9VLj0AWgg/nmkevIyUfIIq5w=="],
-
-    "bun-types": ["bun-types@1.2.21", "", { "dependencies": { "@types/node": "*" }, "peerDependencies": { "@types/react": "^19" } }, "sha512-sa2Tj77Ijc/NTLS0/Odjq/qngmEPZfbfnOERi0KRUYhT9R8M4VBioWVmMWE5GrYbKMc+5lVybXygLdibHaqVqw=="],
-
-    "csstype": ["csstype@3.1.3", "", {}, "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw=="],
-
-    "typescript": ["typescript@5.9.2", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A=="],
-
-    "undici-types": ["undici-types@7.10.0", "", {}, "sha512-t5Fy/nfn+14LuOc2KNYg75vZqClpAiqscVvMygNnlsHBFpSXdJaYtXMcdNLpl/Qvc3P2cB3s6lOV51nqsFq4ag=="],
-  }
-}

package/lib/core/err.ts

@@ -1,93 +0,0 @@
-import { type Result, ResultBase } from "./result";
-
-/**
- * Represents an error result containing an error value.
- */
-export class Err<E> extends ResultBase<never, E> {
-  readonly _tag = "err" as const;
-  readonly isOk = false;
-  readonly isErr = true;
-
-  constructor(readonly error: E) {
-    super();
-  }
-
-  /**
-   * Maps the value type, but since this is `Err`, it's a no-op.
-   */
-  map<U>(_fn: (value: never) => U): Err<E> {
-    return this;
-  }
-
-  /**
-   * Maps the contained error using the provided function.
-   * Since this is `Err`, the function is always applied.
-   */
-  mapErr<F>(fn: (error: E) => F): Err<F> {
-    return new Err(fn(this.error));
-  }
-
-  /**
-   * Throws an error since this is `Err`, not `Ok`.
-   */
-  unwrap(): never {
-    throw new Error(`Called unwrap() on an Err value: ${this.error}`);
-  }
-
-  /**
-   * Returns the contained error.
-   */
-  unwrapErr(): E {
-    return this.error;
-  }
-
-  /**
-   * Returns the provided default value since this is `Err`.
-   */
-  unwrapOr<T>(defaultValue: T): T {
-    return defaultValue;
-  }
-
-  /**
-   * Computes and returns the fallback value using the provided function.
-   */
-  unwrapOrElse<T>(fn: (error: E) => T): T {
-    return fn(this.error);
-  }
-
-  /**
-   * Returns this `Err` unchanged since there's no value to chain.
-   */
-  andThen<U>(_fn: (value: never) => Result<U, E>): Err<E> {
-    return this;
-  }
-
-  /**
-   * Always returns false since this is `Err`, not `Ok`.
-   */
-  contains(_value: never): boolean {
-    return false;
-  }
-
-  /**
-   * Checks if the contained error matches the provided error.
-   */
-  containsErr(error: E): boolean {
-    return this.error === error;
-  }
-}
-
-/**
- * Creates a new `Err` result with the given error.
- */
-export function err<E>(error: E): Err<E> {
-  return new Err(error);
-}
-
-/**
- * Type guard to check if a result is `Err`.
- * @deprecated use `.isErr` instead
- */
-export function isErr<T, E>(result: Result<T, E>): result is Err<E> {
-  return result.isErr;
-}

package/lib/core/index.ts

@@ -1,3 +0,0 @@
-export { err, isErr, Err } from "./err";
-export { ok, isOk, Ok } from "./ok";
-export type { Result, AsyncResult } from "./result";

package/lib/core/ok.ts

@@ -1,93 +0,0 @@
-import { type Result, ResultBase } from "./result";
-
-/**
- * Represents a successful result containing a value.
- */
-export class Ok<T> extends ResultBase<T, never> {
-  readonly _tag = "ok" as const;
-  readonly isOk = true;
-  readonly isErr = false;
-
-  constructor(readonly value: T) {
-    super();
-  }
-
-  /**
-   * Maps the contained value using the provided function.
-   * Since this is `Ok`, the function is always applied.
-   */
-  map<U>(fn: (value: T) => U): Ok<U> {
-    return new Ok(fn(this.value));
-  }
-
-  /**
-   * Maps the error type, but since this is `Ok`, it's a no-op.
-   */
-  mapErr<F>(_fn: (error: never) => F): Ok<T> {
-    return this;
-  }
-
-  /**
-   * Returns the contained value.
-   */
-  unwrap(): T {
-    return this.value;
-  }
-
-  /**
-   * Throws an error since this is Ok, not Err.
-   */
-  unwrapErr(): never {
-    throw new Error(`Called unwrapErr() on an Ok value: ${this.value}`);
-  }
-
-  /**
-   * Returns the contained value, ignoring the default.
-   */
-  unwrapOr(_defaultValue: T): T {
-    return this.value;
-  }
-
-  /**
-   * Returns the contained value, ignoring the fallback function.
-   */
-  unwrapOrElse(_fn: (error: never) => T): T {
-    return this.value;
-  }
-
-  /**
-   * Applies the function to the contained value and returns the result.
-   */
-  andThen<U>(fn: (value: T) => Result<U, never>): Result<U, never> {
-    return fn(this.value);
-  }
-
-  /**
-   * Checks if the contained value matches the provided value.
-   */
-  contains(value: T): boolean {
-    return this.value === value;
-  }
-
-  /**
-   * Always returns false since this is `Ok`, not `Err`.
-   */
-   override containsErr(_error: never): false {
-    return false;
-  }
-}
-
-/**
- * Creates a new `Ok` result with the given value.
- */
-export function ok<T>(value: T): Ok<T> {
-  return new Ok(value);
-}
-
-/**
- * Type guard to check if a result is `Ok`.
- * @deprecated use `.isOk` instead
- */
-export function isOk<T, E>(result: Result<T, E>): result is Ok<T> {
-  return result.isOk;
-}

package/lib/core/result.ts

@@ -1,78 +0,0 @@
-import type { Err } from "./err";
-import type { Ok } from "./ok";
-
-/**
- * Represents a Result type that can either be a success (`Ok`) or an error (`Err`).
- * This is an abstract base class that provides common functionality for both variants.
- */
-export abstract class ResultBase<T, E> {
-  /**
-   * Type guard to check if the result is an `Ok` variant.
-   */
-  abstract readonly isOk: boolean;
-
-  /**
-   * Type guard to check if the result is an `Err` variant.
-   */
-  abstract readonly isErr: boolean;
-
-  /**
-   * Maps a `Result<T, E>` to `Result<U, E>` by applying a function to a contained `Ok` value,
-   * leaving an `Err` value untouched.
-   */
-  abstract map<U>(fn: (value: T) => U): Result<U, E>;
-
-  /**
-   * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a contained `Err` value,
-   * leaving an `Ok` value untouched.
-   */
-  abstract mapErr<F>(fn: (error: E) => F): Result<T, F>;
-
-  /**
-   * Returns the contained `Ok` value, consuming the self value.
-   * Throws an error if the result is `Err`.
-   */
-  abstract unwrap(): T;
-
-  /**
-   * Returns the contained `Err` value, consuming the self value.
-   * Throws an error if the result is Ok.
-   */
-  abstract unwrapErr(): E;
-
-  /**
-   * Returns the contained `Ok` value or a provided default.
-   */
-  abstract unwrapOr(defaultValue: T): T;
-
-  /**
-   * Returns the contained `Ok` value or computes it from a closure.
-   */
-  abstract unwrapOrElse(fn: (error: E) => T): T;
-
-  /**
-   * Calls the provided function with the contained value and returns the result.
-   * If the result is `Err`, the function is not called and the `Err` is returned.
-   */
-  abstract andThen<U>(fn: (value: T) => Result<U, E>): Result<U, E>;
-
-  /**
-   * Returns true if the result is `Ok` and the value inside of it matches a predicate.
-   */
-  abstract contains(value: T): boolean;
-
-  /**
-   * Returns true if the result is `Err` and the error inside of it matches a predicate.
-   */
-  abstract containsErr(error: E): boolean;
-}
-
-/**
- * Type alias for a `Result` that can be either `Ok<T>` or `Err<E>`.
- */
-export type Result<T, E> = Ok<T> | Err<E>;
-
-/**
- * Type alias for an async `Result` (Promise-wrapped `Result`).
- */
-export type AsyncResult<T, E> = Promise<Result<T, E>>;

package/tsconfig.json

@@ -1,35 +0,0 @@
-{
-  "compilerOptions": {
-    // Output configuration for npm publishing
-    "outDir": "./out",
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "rootDir": "lib/",
-    
-    // Module system
-    "target": "ES2020",
-    "module": "ESNext",
-    "moduleResolution": "node",
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-
-    // Type checking
-    "strict": true,
-    "noImplicitAny": true,
-    "strictNullChecks": true,
-    "strictFunctionTypes": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": true,
-
-    // Additional checks
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-
-    // Library
-    "lib": ["ES2020"]
-  },
-  "include": ["**/*.ts"],
-  "exclude": ["node_modules", "out"]
-}