nalloc 0.0.1

package/build/types.d.ts

@@ -0,0 +1,137 @@
+/** Values that represent None (absence of a value). */
+export type NoneValueType = null | undefined | void;
+/** Widens literal types to their base types for better type inference. */
+export type Widen<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends bigint ? bigint : T extends symbol ? symbol : T;
+/** Widens never to unknown, otherwise preserves the type. */
+export type WidenNever<T> = [T] extends [never] ? unknown : T;
+/** Excludes None values from a type, leaving only valid Some values. */
+export type ValueType<T> = Exclude<T, NoneValueType>;
+export declare const SOME_BRAND: unique symbol;
+/** Represents a value that is present. The value itself is the Some - no wrapper object. */
+export type Some<T> = ValueType<T> & {
+    readonly [SOME_BRAND]: true;
+};
+/** Represents the absence of a value (null or undefined). */
+export type None = NoneValueType & {
+    readonly [SOME_BRAND]: false;
+};
+/** Constant representing None. Use this instead of null/undefined for clarity. */
+export declare const NONE: None;
+/** A value that may or may not be present. Some(T) is the value itself; None is null/undefined. */
+export type Option<T> = Some<ValueType<T>> | None;
+/** Extracts the value type from an Option type. */
+export type OptionValue<TOption> = TOption extends Option<infer TValue> ? TValue : never;
+/** Type predicate: true if T is an Option type. */
+export type IsOption<T> = T extends Option<any> ? true : false;
+/** Infers the Some type from a value, preserving the inner type. */
+export type InferSome<T> = T extends Some<infer TValue> ? Some<ValueType<TValue>> : never;
+/**
+ * Checks if an Option contains a value (is Some).
+ * @param opt - The Option to check
+ * @returns true if the Option is Some, false if None
+ * @example
+ * isSome(42)        // true
+ * isSome(null)      // false
+ * isSome(undefined) // false
+ */
+export declare function isSome<T>(opt: Some<T>): true;
+export declare function isSome(opt: None): false;
+export declare function isSome<T>(opt: unknown): opt is Some<T>;
+/**
+ * Checks if an Option is None (absent).
+ * @param opt - The Option to check
+ * @returns true if the Option is None, false if Some
+ * @example
+ * isNone(null)      // true
+ * isNone(undefined) // true
+ * isNone(42)        // false
+ */
+export declare function isNone<T>(opt: Some<T>): false;
+export declare function isNone(opt: None): true;
+export declare function isNone(opt: unknown): opt is None;
+/**
+ * Creates an Option from a nullable value. Returns None for null/undefined, Some otherwise.
+ * @param value - The value to wrap
+ * @returns Some(value) if value is non-null, None otherwise
+ * @example
+ * optionOf(42)        // Some(42)
+ * optionOf(null)      // None
+ * optionOf(undefined) // None
+ */
+export declare function optionOf(value: null): None;
+export declare function optionOf(value: undefined): None;
+export declare function optionOf<T>(value: T): T extends NoneValueType ? None : Some<T>;
+/**
+ * Creates a Some value. Does not validate - use safe.some() for validation.
+ * @param value - The value to wrap (must be non-null)
+ * @returns The value typed as Some
+ * @example
+ * some(42) // Some(42)
+ */
+export declare function some<T>(value: ValueType<T>): Some<ValueType<T>>;
+/** Constant representing None. Alias for NONE. */
+export declare const none: None;
+declare const OK_BRAND: unique symbol;
+/** Represents a successful Result value. The value itself is the Ok - no wrapper object. */
+export type Ok<T> = T & {
+    readonly [OK_BRAND]: true;
+};
+declare const ERR_BRAND: unique symbol;
+interface ResultErrorShape<E> {
+    readonly error: E;
+    readonly [ERR_BRAND]: true;
+}
+/** The error wrapper type used internally. */
+export type ResultError<E> = ResultErrorShape<E>;
+/** Represents a failed Result containing an error. */
+export type Err<E> = ResultError<E>;
+/** A value that is either successful (Ok) or failed (Err). Ok is the value itself; Err wraps the error. */
+export type Result<T, E> = Ok<T> | Err<E>;
+/** Extracts the success value type from a Result type. */
+export type ResultValue<TResult> = TResult extends Result<infer TValue, any> ? TValue : never;
+/** Extracts the error type from a Result type. */
+export type ResultErrorType<TResult> = TResult extends Result<any, infer TError> ? TError : never;
+/** Type predicate: true if T is a Result type. */
+export type IsResult<T> = T extends Result<any, any> ? true : false;
+/** Infers the Err type from a value, preserving the error type. */
+export type InferErr<T> = T extends Err<infer TError> ? Err<TError> : never;
+/**
+ * Checks if a Result is Ok (successful).
+ * @param result - The Result to check
+ * @returns true if the Result is Ok, false if Err
+ * @example
+ * isOk(42)           // true (Ok value)
+ * isOk(err('fail'))  // false
+ */
+export declare function isOk<T>(result: Ok<T>): true;
+export declare function isOk<E>(result: Err<E>): false;
+export declare function isOk<T, E>(result: Result<T, E>): result is Ok<T>;
+/**
+ * Checks if a Result is Err (failed).
+ * @param result - The Result to check
+ * @returns true if the Result is Err, false if Ok
+ * @example
+ * isErr(err('fail')) // true
+ * isErr(42)          // false (Ok value)
+ */
+export declare function isErr<E>(result: Err<E>): true;
+export declare function isErr(result: Ok<any>): false;
+export declare function isErr<T, E>(result: Result<T, E>): result is Err<E>;
+/**
+ * Creates an Ok value. Does not validate - use safe.ok() for validation.
+ * @param value - The success value
+ * @returns The value typed as Ok
+ * @example
+ * ok(42) // Ok(42)
+ */
+export declare function ok<T>(value: T): Ok<T>;
+/**
+ * Creates an Err value wrapping an error.
+ * @param error - The error value
+ * @returns An Err containing the error
+ * @example
+ * err('something went wrong') // Err('something went wrong')
+ * err(new Error('failed'))    // Err(Error)
+ */
+export declare function err<E>(error: E): Err<E>;
+export {};

package/build/types.js

@@ -0,0 +1,36 @@
+export const NONE = undefined;
+export function isSome(opt) {
+    return opt !== null && opt !== undefined;
+}
+export function isNone(opt) {
+    return opt === null || opt === undefined;
+}
+export function optionOf(value) {
+    return isNone(value) ? NONE : value;
+}
+export function some(value) {
+    return value;
+}
+export const none = NONE;
+const ERR_BRAND = Symbol.for('nalloc.ResultError');
+function ResultErrorCtor(error) {
+    this.error = error;
+}
+ResultErrorCtor.prototype[ERR_BRAND] = true;
+function hasErrBrand(value) {
+    return value?.[ERR_BRAND] === true;
+}
+export function isOk(result) {
+    return !hasErrBrand(result);
+}
+export function isErr(result) {
+    return hasErrBrand(result);
+}
+export function ok(value) {
+    return value;
+}
+export function err(error) {
+    return new ResultErrorCtor(error);
+}
+
+//# sourceMappingURL=types.js.map

package/build/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["/** Values that represent None (absence of a value). */\nexport type NoneValueType = null | undefined | void;\n\n/** Widens literal types to their base types for better type inference. */\nexport type Widen<T> = T extends string\n  ? string\n  : T extends number\n    ? number\n    : T extends boolean\n      ? boolean\n      : T extends bigint\n        ? bigint\n        : T extends symbol\n          ? symbol\n          : T;\n\n/** Widens never to unknown, otherwise preserves the type. */\nexport type WidenNever<T> = [T] extends [never] ? unknown : T;\n\n/** Excludes None values from a type, leaving only valid Some values. */\nexport type ValueType<T> = Exclude<T, NoneValueType>;\n\nexport declare const SOME_BRAND: unique symbol;\n\n/** Represents a value that is present. The value itself is the Some - no wrapper object. */\nexport type Some<T> = ValueType<T> & { readonly [SOME_BRAND]: true };\n\n/** Represents the absence of a value (null or undefined). */\nexport type None = NoneValueType & { readonly [SOME_BRAND]: false };\n\n/** Constant representing None. Use this instead of null/undefined for clarity. */\nexport const NONE = undefined as None;\n\n/** A value that may or may not be present. Some(T) is the value itself; None is null/undefined. */\nexport type Option<T> = Some<ValueType<T>> | None;\n\n/** Extracts the value type from an Option type. */\nexport type OptionValue<TOption> = TOption extends Option<infer TValue> ? TValue : never;\n\n/** Type predicate: true if T is an Option type. */\nexport type IsOption<T> = T extends Option<any> ? true : false;\n\n/** Infers the Some type from a value, preserving the inner type. */\nexport type InferSome<T> = T extends Some<infer TValue> ? Some<ValueType<TValue>> : never;\n\n/**\n * Checks if an Option contains a value (is Some).\n * @param opt - The Option to check\n * @returns true if the Option is Some, false if None\n * @example\n * isSome(42)        // true\n * isSome(null)      // false\n * isSome(undefined) // false\n */\nexport function isSome<T>(opt: Some<T>): true;\nexport function isSome(opt: None): false;\nexport function isSome<T>(opt: unknown): opt is Some<T>;\nexport function isSome(opt: unknown): boolean {\n  return opt !== null && opt !== undefined;\n}\n\n/**\n * Checks if an Option is None (absent).\n * @param opt - The Option to check\n * @returns true if the Option is None, false if Some\n * @example\n * isNone(null)      // true\n * isNone(undefined) // true\n * isNone(42)        // false\n */\nexport function isNone<T>(opt: Some<T>): false;\nexport function isNone(opt: None): true;\nexport function isNone(opt: unknown): opt is None;\nexport function isNone(opt: unknown): boolean {\n  return opt === null || opt === undefined;\n}\n\n/**\n * Creates an Option from a nullable value. Returns None for null/undefined, Some otherwise.\n * @param value - The value to wrap\n * @returns Some(value) if value is non-null, None otherwise\n * @example\n * optionOf(42)        // Some(42)\n * optionOf(null)      // None\n * optionOf(undefined) // None\n */\nexport function optionOf(value: null): None;\nexport function optionOf(value: undefined): None;\nexport function optionOf<T>(value: T): T extends NoneValueType ? None : Some<T>;\nexport function optionOf<T>(value: T): Option<T> {\n  return isNone(value as Option<T>) ? NONE : (value as Some<T>);\n}\n\n/**\n * Creates a Some value. Does not validate - use safe.some() for validation.\n * @param value - The value to wrap (must be non-null)\n * @returns The value typed as Some\n * @example\n * some(42) // Some(42)\n */\nexport function some<T>(value: ValueType<T>): Some<ValueType<T>> {\n  return value as Some<ValueType<T>>;\n}\n\n/** Constant representing None. Alias for NONE. */\nexport const none: None = NONE;\n\ndeclare const OK_BRAND: unique symbol;\n\n/** Represents a successful Result value. The value itself is the Ok - no wrapper object. */\nexport type Ok<T> = T & { readonly [OK_BRAND]: true };\n\nconst ERR_BRAND = Symbol.for('nalloc.ResultError');\n\ninterface ResultErrorShape<E> {\n  readonly error: E;\n  readonly [ERR_BRAND]: true;\n}\n\nfunction ResultErrorCtor<E>(this: ResultErrorShape<E>, error: E): void {\n  (this as { error: E }).error = error;\n}\n(ResultErrorCtor.prototype as { [ERR_BRAND]: true })[ERR_BRAND] = true;\n\n/** The error wrapper type used internally. */\nexport type ResultError<E> = ResultErrorShape<E>;\n\nfunction hasErrBrand(value: unknown): value is ResultError<unknown> {\n  return (value as Record<symbol, unknown>)?.[ERR_BRAND] === true;\n}\n\n/** Represents a failed Result containing an error. */\nexport type Err<E> = ResultError<E>;\n\n/** A value that is either successful (Ok) or failed (Err). Ok is the value itself; Err wraps the error. */\nexport type Result<T, E> = Ok<T> | Err<E>;\n\n/** Extracts the success value type from a Result type. */\nexport type ResultValue<TResult> = TResult extends Result<infer TValue, any> ? TValue : never;\n\n/** Extracts the error type from a Result type. */\nexport type ResultErrorType<TResult> = TResult extends Result<any, infer TError> ? TError : never;\n\n/** Type predicate: true if T is a Result type. */\nexport type IsResult<T> = T extends Result<any, any> ? true : false;\n\n/** Infers the Err type from a value, preserving the error type. */\nexport type InferErr<T> = T extends Err<infer TError> ? Err<TError> : never;\n\n/**\n * Checks if a Result is Ok (successful).\n * @param result - The Result to check\n * @returns true if the Result is Ok, false if Err\n * @example\n * isOk(42)           // true (Ok value)\n * isOk(err('fail'))  // false\n */\nexport function isOk<T>(result: Ok<T>): true;\nexport function isOk<E>(result: Err<E>): false;\nexport function isOk<T, E>(result: Result<T, E>): result is Ok<T>;\nexport function isOk<T, E>(result: Result<T, E>): boolean {\n  return !hasErrBrand(result);\n}\n\n/**\n * Checks if a Result is Err (failed).\n * @param result - The Result to check\n * @returns true if the Result is Err, false if Ok\n * @example\n * isErr(err('fail')) // true\n * isErr(42)          // false (Ok value)\n */\nexport function isErr<E>(result: Err<E>): true;\nexport function isErr(result: Ok<any>): false;\nexport function isErr<T, E>(result: Result<T, E>): result is Err<E>;\nexport function isErr<T, E>(result: Result<T, E>): boolean {\n  return hasErrBrand(result);\n}\n\n/**\n * Creates an Ok value. Does not validate - use safe.ok() for validation.\n * @param value - The success value\n * @returns The value typed as Ok\n * @example\n * ok(42) // Ok(42)\n */\nexport function ok<T>(value: T): Ok<T> {\n  return value as Ok<T>;\n}\n\n/**\n * Creates an Err value wrapping an error.\n * @param error - The error value\n * @returns An Err containing the error\n * @example\n * err('something went wrong') // Err('something went wrong')\n * err(new Error('failed'))    // Err(Error)\n */\nexport function err<E>(error: E): Err<E> {\n  return new (ResultErrorCtor as unknown as new (error: E) => Err<E>)(error);\n}\n"],"names":["NONE","undefined","isSome","opt","isNone","optionOf","value","some","none","ERR_BRAND","Symbol","for","ResultErrorCtor","error","prototype","hasErrBrand","isOk","result","isErr","ok","err"],"mappings":"AA+BA,OAAO,MAAMA,OAAOC,UAAkB;AA0BtC,OAAO,SAASC,OAAOC,GAAY;IACjC,OAAOA,QAAQ,QAAQA,QAAQF;AACjC;AAcA,OAAO,SAASG,OAAOD,GAAY;IACjC,OAAOA,QAAQ,QAAQA,QAAQF;AACjC;AAcA,OAAO,SAASI,SAAYC,KAAQ;IAClC,OAAOF,OAAOE,SAAsBN,OAAQM;AAC9C;AASA,OAAO,SAASC,KAAQD,KAAmB;IACzC,OAAOA;AACT;AAGA,OAAO,MAAME,OAAaR,KAAK;AAO/B,MAAMS,YAAYC,OAAOC,GAAG,CAAC;AAO7B,SAASC,gBAA8CC,KAAQ;IAC7D,AAAC,IAAI,CAAkBA,KAAK,GAAGA;AACjC;AACCD,gBAAgBE,SAAS,AAA0B,CAACL,UAAU,GAAG;AAKlE,SAASM,YAAYT,KAAc;IACjC,OAAO,AAACA,OAAmC,CAACG,UAAU,KAAK;AAC7D;AA+BA,OAAO,SAASO,KAAWC,MAAoB;IAC7C,OAAO,CAACF,YAAYE;AACtB;AAaA,OAAO,SAASC,MAAYD,MAAoB;IAC9C,OAAOF,YAAYE;AACrB;AASA,OAAO,SAASE,GAAMb,KAAQ;IAC5B,OAAOA;AACT;AAUA,OAAO,SAASc,IAAOP,KAAQ;IAC7B,OAAO,IAAKD,gBAAwDC;AACtE"}

package/build/unsafe.cjs

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get Option () {
+        return _optioncjs;
+    },
+    get Result () {
+        return _resultcjs;
+    },
+    get err () {
+        return _typescjs.err;
+    },
+    get none () {
+        return _typescjs.none;
+    },
+    get ok () {
+        return ok;
+    },
+    get some () {
+        return some;
+    }
+});
+const _typescjs = require("./types.cjs");
+const _optioncjs = /*#__PURE__*/ _interop_require_wildcard(require("./option.cjs"));
+const _resultcjs = /*#__PURE__*/ _interop_require_wildcard(require("./result.cjs"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function some(value) {
+    return value;
+}
+function ok(value) {
+    return value;
+}
+
+//# sourceMappingURL=unsafe.cjs.map

package/build/unsafe.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/unsafe.ts"],"sourcesContent":["import type { Some, Ok } from './types.js';\nexport { none, err } from './types.js';\nexport type {\n  Some,\n  None,\n  Ok,\n  Err,\n  Option as OptionType,\n  OptionValue,\n  IsOption,\n  InferSome,\n  Result as ResultType,\n  ResultValue,\n  ResultErrorType,\n  IsResult,\n  InferErr,\n} from './types.js';\nexport * as Option from './option.js';\nexport * as Result from './result.js';\n\n/**\n * Creates a Some value without runtime validation.\n * Use when you are certain the value is non-nullable.\n * For validated creation, use safe.some() instead.\n * @param value - The value to wrap (assumed non-nullable)\n * @returns The value typed as Some\n * @example\n * some(42)   // Some(42)\n * some(null) // Some(null) - no validation, may cause issues\n */\nexport function some<T>(value: T): Some<T> {\n  return value as unknown as Some<T>;\n}\n\n/**\n * Creates an Ok value without runtime validation.\n * Use when you are certain the value is not an Err.\n * For validated creation, use safe.ok() instead.\n * @param value - The success value (assumed not an Err)\n * @returns The value typed as Ok\n * @example\n * ok(42)          // Ok(42)\n * ok(err('fail')) // Ok(Err) - no validation, may cause issues\n */\nexport function ok<T>(value: T): Ok<T> {\n  return value as Ok<T>;\n}\n"],"names":["Option","Result","err","none","ok","some","value"],"mappings":";;;;;;;;;;;QAiBYA;;;QACAC;;;QAjBGC;eAAAA,aAAG;;QAATC;eAAAA,cAAI;;QA2CGC;eAAAA;;QAdAC;eAAAA;;;0BA7BU;mEAgBF;mEACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYjB,SAASA,KAAQC,KAAQ;IAC9B,OAAOA;AACT;AAYO,SAASF,GAAME,KAAQ;IAC5B,OAAOA;AACT"}

package/build/unsafe.d.ts

@@ -0,0 +1,27 @@
+import type { Some, Ok } from './types.js';
+export { none, err } from './types.js';
+export type { Some, None, Ok, Err, Option as OptionType, OptionValue, IsOption, InferSome, Result as ResultType, ResultValue, ResultErrorType, IsResult, InferErr, } from './types.js';
+export * as Option from './option.js';
+export * as Result from './result.js';
+/**
+ * Creates a Some value without runtime validation.
+ * Use when you are certain the value is non-nullable.
+ * For validated creation, use safe.some() instead.
+ * @param value - The value to wrap (assumed non-nullable)
+ * @returns The value typed as Some
+ * @example
+ * some(42)   // Some(42)
+ * some(null) // Some(null) - no validation, may cause issues
+ */
+export declare function some<T>(value: T): Some<T>;
+/**
+ * Creates an Ok value without runtime validation.
+ * Use when you are certain the value is not an Err.
+ * For validated creation, use safe.ok() instead.
+ * @param value - The success value (assumed not an Err)
+ * @returns The value typed as Ok
+ * @example
+ * ok(42)          // Ok(42)
+ * ok(err('fail')) // Ok(Err) - no validation, may cause issues
+ */
+export declare function ok<T>(value: T): Ok<T>;

package/build/unsafe.js

@@ -0,0 +1,11 @@
+export { none, err } from "./types.js";
+export * as Option from "./option.js";
+export * as Result from "./result.js";
+export function some(value) {
+    return value;
+}
+export function ok(value) {
+    return value;
+}
+
+//# sourceMappingURL=unsafe.js.map

package/build/unsafe.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/unsafe.ts"],"sourcesContent":["import type { Some, Ok } from './types.js';\nexport { none, err } from './types.js';\nexport type {\n  Some,\n  None,\n  Ok,\n  Err,\n  Option as OptionType,\n  OptionValue,\n  IsOption,\n  InferSome,\n  Result as ResultType,\n  ResultValue,\n  ResultErrorType,\n  IsResult,\n  InferErr,\n} from './types.js';\nexport * as Option from './option.js';\nexport * as Result from './result.js';\n\n/**\n * Creates a Some value without runtime validation.\n * Use when you are certain the value is non-nullable.\n * For validated creation, use safe.some() instead.\n * @param value - The value to wrap (assumed non-nullable)\n * @returns The value typed as Some\n * @example\n * some(42)   // Some(42)\n * some(null) // Some(null) - no validation, may cause issues\n */\nexport function some<T>(value: T): Some<T> {\n  return value as unknown as Some<T>;\n}\n\n/**\n * Creates an Ok value without runtime validation.\n * Use when you are certain the value is not an Err.\n * For validated creation, use safe.ok() instead.\n * @param value - The success value (assumed not an Err)\n * @returns The value typed as Ok\n * @example\n * ok(42)          // Ok(42)\n * ok(err('fail')) // Ok(Err) - no validation, may cause issues\n */\nexport function ok<T>(value: T): Ok<T> {\n  return value as Ok<T>;\n}\n"],"names":["none","err","Option","Result","some","value","ok"],"mappings":"AACA,SAASA,IAAI,EAAEC,GAAG,QAAQ,aAAa;AAgBvC,OAAO,KAAKC,MAAM,MAAM,cAAc;AACtC,OAAO,KAAKC,MAAM,MAAM,cAAc;AAYtC,OAAO,SAASC,KAAQC,KAAQ;IAC9B,OAAOA;AACT;AAYA,OAAO,SAASC,GAAMD,KAAQ;IAC5B,OAAOA;AACT"}

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "nalloc",
+  "description": "Rust-like Option and Result for TypeScript with near-zero allocations for extreme performance",
+  "version": "0.0.1",
+  "type": "module",
+  "types": "build/index.d.ts",
+  "main": "build/index.cjs",
+  "module": "build/index.js",
+  "exports": {
+    ".": {
+      "require": "./build/index.cjs",
+      "import": "./build/index.js"
+    },
+    "./types": {
+      "require": "./build/types.cjs",
+      "import": "./build/types.js"
+    },
+    "./option": {
+      "require": "./build/option.cjs",
+      "import": "./build/option.js"
+    },
+    "./result": {
+      "require": "./build/result.cjs",
+      "import": "./build/result.js"
+    },
+    "./safe": {
+      "require": "./build/safe.cjs",
+      "import": "./build/safe.js"
+    },
+    "./unsafe": {
+      "require": "./build/unsafe.cjs",
+      "import": "./build/unsafe.js"
+    },
+    "./testing": {
+      "require": "./build/testing.cjs",
+      "import": "./build/testing.js"
+    },
+    "./devtools": {
+      "require": "./build/devtools.cjs",
+      "import": "./build/devtools.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "build",
+    "src"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/3axap4eHko/nalloc.git"
+  },
+  "keywords": [
+    "option",
+    "result",
+    "maybe",
+    "either",
+    "rust",
+    "typescript",
+    "type-safe",
+    "monad",
+    "functional",
+    "error-handling",
+    "pattern-matching",
+    "zero-allocation",
+    "performance"
+  ],
+  "author": "Ivan Zakharchanka",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/3axap4eHko/nalloc/issues"
+  },
+  "homepage": "https://github.com/3axap4eHko/nalloc#readme",
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@vitest/coverage-v8": "^4.0.16",
+    "eslint": "^9.39.2",
+    "eslint-plugin-prettier": "^5.5.4",
+    "inop": "^0.8.10",
+    "prettier": "^3.7.4",
+    "tsafe": "^1.8.12",
+    "tslib": "^2.8.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.52.0",
+    "vitest": "^4.0.16"
+  },
+  "scripts": {
+    "check": "tsc src/__tests__/option.types.ts src/__tests__/result.types.ts --noEmit --lib esnext,dom --target esnext --module nodenext --moduleResolution nodenext",
+    "build": "rm -rf build && inop src build -i __tests__ -i *.tmp.ts && tsc --declaration --emitDeclarationOnly",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "bench": "overtake benchmarks/*"
+  }
+}

package/src/__tests__/index.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import * as index from '../index.js';
+
+describe('index.ts exports', () => {
+  it('exports exist', () => {
+    expect(index.some).toBeDefined();
+    expect('none' in index).toBe(true);
+    expect(index.ok).toBeDefined();
+    expect(index.err).toBeDefined();
+    expect(index.Option).toBeDefined();
+    expect(index.Result).toBeDefined();
+  });
+});