nalloc 0.0.1 → 0.0.2

package/build/safe.cjs

@@ -9,6 +9,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    get Iter () {
+        return _itercjs;
+    },
     get Option () {
         return _optioncjs;
     },
@@ -18,19 +21,47 @@ _export(exports, {
     get err () {
         return _typescjs.err;
     },
+    get isErr () {
+        return _typescjs.isErr;
+    },
+    get isNone () {
+        return _typescjs.isNone;
+    },
+    get isOk () {
+        return _typescjs.isOk;
+    },
+    get isSome () {
+        return _typescjs.isSome;
+    },
+    get isSync () {
+        return _typescjs.isSync;
+    },
+    get isThenable () {
+        return _typescjs.isThenable;
+    },
     get none () {
         return _typescjs.none;
     },
     get ok () {
-        return ok;
+        return _typescjs.ok;
+    },
+    get safeTry () {
+        return _resultcjs.safeTry;
+    },
+    get safeTryAsync () {
+        return _resultcjs.safeTryAsync;
     },
     get some () {
-        return some;
+        return _typescjs.some;
+    },
+    get unwrap () {
+        return _resultcjs.unwrap;
     }
 });
 const _typescjs = require("./types.cjs");
-const _optioncjs = /*#__PURE__*/ _interop_require_wildcard(require("./option.cjs"));
 const _resultcjs = /*#__PURE__*/ _interop_require_wildcard(require("./result.cjs"));
+const _optioncjs = /*#__PURE__*/ _interop_require_wildcard(require("./option.cjs"));
+const _itercjs = /*#__PURE__*/ _interop_require_wildcard(require("./iter.cjs"));
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -72,17 +103,5 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-function some(value) {
-    if (value === null || value === undefined) {
-        throw new TypeError('some() requires a non-nullable value');
-    }
-    return (0, _typescjs.some)(value);
-}
-function ok(value) {
-    if ((0, _typescjs.isErr)(value)) {
-        throw new TypeError('ok() cannot wrap an Err value');
-    }
-    return (0, _typescjs.ok)(value);
-}
 
 //# sourceMappingURL=safe.cjs.map

package/build/safe.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/safe.ts"],"sourcesContent":["import { some as someUnsafe, ok as okUnsafe, err, none, isErr } from './types.js';\nimport 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  ValueType,\n} from './types.js';\n\nexport type { Some, None, Ok, Err, OptionType, OptionValue, IsOption, InferSome, ResultType, ResultValue, ResultErrorType, IsResult, InferErr };\n\nexport { none, err };\nexport * as Option from './option.js';\nexport * as Result from './result.js';\n\n/**\n * Creates a Some value with runtime validation.\n * Throws if the value is null or undefined.\n * @param value - The value to wrap (must be non-nullable)\n * @returns The value typed as Some\n * @throws {TypeError} If value is null or undefined\n * @example\n * some(42)        // Some(42)\n * some(null)      // throws TypeError\n * some(undefined) // throws TypeError\n */\nexport function some<T>(value: T): Some<ValueType<T>> {\n  if (value === null || value === undefined) {\n    throw new TypeError('some() requires a non-nullable value');\n  }\n  return someUnsafe(value as ValueType<T>);\n}\n\n/**\n * Creates an Ok value with runtime validation.\n * Throws if the value is an Err (prevents accidental double-wrapping).\n * @param value - The success value\n * @returns The value typed as Ok\n * @throws {TypeError} If value is an Err\n * @example\n * ok(42)           // Ok(42)\n * ok(err('fail'))  // throws TypeError\n */\nexport function ok<T>(value: T): Ok<T> {\n  if (isErr(value)) {\n    throw new TypeError('ok() cannot wrap an Err value');\n  }\n  return okUnsafe(value);\n}\n"],"names":["Option","Result","err","none","ok","some","value","undefined","TypeError","someUnsafe","isErr","okUnsafe"],"mappings":";;;;;;;;;;;QAqBYA;;;QACAC;;;QAFGC;eAAAA,aAAG;;QAATC;eAAAA,cAAI;;QAgCGC;eAAAA;;QAjBAC;eAAAA;;;0BAnCqD;mEAqB7C;mEACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAajB,SAASA,KAAQC,KAAQ;IAC9B,IAAIA,UAAU,QAAQA,UAAUC,WAAW;QACzC,MAAM,IAAIC,UAAU;IACtB;IACA,OAAOC,IAAAA,cAAU,EAACH;AACpB;AAYO,SAASF,GAAME,KAAQ;IAC5B,IAAII,IAAAA,eAAK,EAACJ,QAAQ;QAChB,MAAM,IAAIE,UAAU;IACtB;IACA,OAAOG,IAAAA,YAAQ,EAACL;AAClB"}
+{"version":3,"sources":["../src/safe.ts"],"sourcesContent":["export { some, none, ok, err, isOk, isErr, isSome, isNone, isThenable, isSync } 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  MaybePromise,\n} from './types.js';\nexport { safeTry, safeTryAsync, unwrap } from './result.js';\nexport * as Option from './option.js';\nexport * as Result from './result.js';\nexport * as Iter from './iter.js';\n"],"names":["Iter","Option","Result","err","isErr","isNone","isOk","isSome","isSync","isThenable","none","ok","safeTry","safeTryAsync","some","unwrap"],"mappings":";;;;;;;;;;;QAoBYA;;;QAFAC;;;QACAC;;;QAnBaC;eAAAA,aAAG;;QAAQC;eAAAA,eAAK;;QAAUC;eAAAA,gBAAM;;QAA3BC;eAAAA,cAAI;;QAASC;eAAAA,gBAAM;;QAAsBC;eAAAA,gBAAM;;QAAlBC;eAAAA,oBAAU;;QAAtDC;eAAAA,cAAI;;QAAEC;eAAAA,YAAE;;QAiBdC;eAAAA,kBAAO;;QAAEC;eAAAA,uBAAY;;QAjBrBC;eAAAA,cAAI;;QAiBmBC;eAAAA,iBAAM;;;0BAjB+C;mEAiBvC;mEACtB;iEAEF"}

package/build/safe.d.ts

@@ -1,29 +1,6 @@
-import { err, none } from './types.js';
-import type { Some, None, Ok, Err, Option as OptionType, OptionValue, IsOption, InferSome, Result as ResultType, ResultValue, ResultErrorType, IsResult, InferErr, ValueType } from './types.js';
-export type { Some, None, Ok, Err, OptionType, OptionValue, IsOption, InferSome, ResultType, ResultValue, ResultErrorType, IsResult, InferErr };
-export { none, err };
+export { some, none, ok, err, isOk, isErr, isSome, isNone, isThenable, isSync } from './types.js';
+export type { Some, None, Ok, Err, Option as OptionType, OptionValue, IsOption, InferSome, Result as ResultType, ResultValue, ResultErrorType, IsResult, InferErr, MaybePromise, } from './types.js';
+export { safeTry, safeTryAsync, unwrap } from './result.js';
 export * as Option from './option.js';
 export * as Result from './result.js';
-/**
- * Creates a Some value with runtime validation.
- * Throws if the value is null or undefined.
- * @param value - The value to wrap (must be non-nullable)
- * @returns The value typed as Some
- * @throws {TypeError} If value is null or undefined
- * @example
- * some(42)        // Some(42)
- * some(null)      // throws TypeError
- * some(undefined) // throws TypeError
- */
-export declare function some<T>(value: T): Some<ValueType<T>>;
-/**
- * Creates an Ok value with runtime validation.
- * Throws if the value is an Err (prevents accidental double-wrapping).
- * @param value - The success value
- * @returns The value typed as Ok
- * @throws {TypeError} If value is an Err
- * @example
- * ok(42)           // Ok(42)
- * ok(err('fail'))  // throws TypeError
- */
-export declare function ok<T>(value: T): Ok<T>;
+export * as Iter from './iter.js';

package/build/safe.js

@@ -1,18 +1,7 @@
-import { some as someUnsafe, ok as okUnsafe, err, none, isErr } from "./types.js";
-export { none, err };
+export { some, none, ok, err, isOk, isErr, isSome, isNone, isThenable, isSync } from "./types.js";
+export { safeTry, safeTryAsync, unwrap } from "./result.js";
 export * as Option from "./option.js";
 export * as Result from "./result.js";
-export function some(value) {
-    if (value === null || value === undefined) {
-        throw new TypeError('some() requires a non-nullable value');
-    }
-    return someUnsafe(value);
-}
-export function ok(value) {
-    if (isErr(value)) {
-        throw new TypeError('ok() cannot wrap an Err value');
-    }
-    return okUnsafe(value);
-}
+export * as Iter from "./iter.js";
 
 //# sourceMappingURL=safe.js.map

package/build/safe.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/safe.ts"],"sourcesContent":["import { some as someUnsafe, ok as okUnsafe, err, none, isErr } from './types.js';\nimport 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  ValueType,\n} from './types.js';\n\nexport type { Some, None, Ok, Err, OptionType, OptionValue, IsOption, InferSome, ResultType, ResultValue, ResultErrorType, IsResult, InferErr };\n\nexport { none, err };\nexport * as Option from './option.js';\nexport * as Result from './result.js';\n\n/**\n * Creates a Some value with runtime validation.\n * Throws if the value is null or undefined.\n * @param value - The value to wrap (must be non-nullable)\n * @returns The value typed as Some\n * @throws {TypeError} If value is null or undefined\n * @example\n * some(42)        // Some(42)\n * some(null)      // throws TypeError\n * some(undefined) // throws TypeError\n */\nexport function some<T>(value: T): Some<ValueType<T>> {\n  if (value === null || value === undefined) {\n    throw new TypeError('some() requires a non-nullable value');\n  }\n  return someUnsafe(value as ValueType<T>);\n}\n\n/**\n * Creates an Ok value with runtime validation.\n * Throws if the value is an Err (prevents accidental double-wrapping).\n * @param value - The success value\n * @returns The value typed as Ok\n * @throws {TypeError} If value is an Err\n * @example\n * ok(42)           // Ok(42)\n * ok(err('fail'))  // throws TypeError\n */\nexport function ok<T>(value: T): Ok<T> {\n  if (isErr(value)) {\n    throw new TypeError('ok() cannot wrap an Err value');\n  }\n  return okUnsafe(value);\n}\n"],"names":["some","someUnsafe","ok","okUnsafe","err","none","isErr","Option","Result","value","undefined","TypeError"],"mappings":"AAAA,SAASA,QAAQC,UAAU,EAAEC,MAAMC,QAAQ,EAAEC,GAAG,EAAEC,IAAI,EAAEC,KAAK,QAAQ,aAAa;AAoBlF,SAASD,IAAI,EAAED,GAAG,GAAG;AACrB,OAAO,KAAKG,MAAM,MAAM,cAAc;AACtC,OAAO,KAAKC,MAAM,MAAM,cAAc;AAatC,OAAO,SAASR,KAAQS,KAAQ;IAC9B,IAAIA,UAAU,QAAQA,UAAUC,WAAW;QACzC,MAAM,IAAIC,UAAU;IACtB;IACA,OAAOV,WAAWQ;AACpB;AAYA,OAAO,SAASP,GAAMO,KAAQ;IAC5B,IAAIH,MAAMG,QAAQ;QAChB,MAAM,IAAIE,UAAU;IACtB;IACA,OAAOR,SAASM;AAClB"}
+{"version":3,"sources":["../src/safe.ts"],"sourcesContent":["export { some, none, ok, err, isOk, isErr, isSome, isNone, isThenable, isSync } 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  MaybePromise,\n} from './types.js';\nexport { safeTry, safeTryAsync, unwrap } from './result.js';\nexport * as Option from './option.js';\nexport * as Result from './result.js';\nexport * as Iter from './iter.js';\n"],"names":["some","none","ok","err","isOk","isErr","isSome","isNone","isThenable","isSync","safeTry","safeTryAsync","unwrap","Option","Result","Iter"],"mappings":"AAAA,SAASA,IAAI,EAAEC,IAAI,EAAEC,EAAE,EAAEC,GAAG,EAAEC,IAAI,EAAEC,KAAK,EAAEC,MAAM,EAAEC,MAAM,EAAEC,UAAU,EAAEC,MAAM,QAAQ,aAAa;AAiBlG,SAASC,OAAO,EAAEC,YAAY,EAAEC,MAAM,QAAQ,cAAc;AAC5D,OAAO,KAAKC,MAAM,MAAM,cAAc;AACtC,OAAO,KAAKC,MAAM,MAAM,cAAc;AACtC,OAAO,KAAKC,IAAI,MAAM,YAAY"}

package/build/types.cjs

@@ -9,6 +9,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    get EMPTY () {
+        return EMPTY;
+    },
     get NONE () {
         return NONE;
     },
@@ -27,20 +30,33 @@ _export(exports, {
     get isSome () {
         return isSome;
     },
+    get isSync () {
+        return isSync;
+    },
+    get isThenable () {
+        return isThenable;
+    },
     get none () {
         return none;
     },
     get ok () {
         return ok;
     },
+    get okUnchecked () {
+        return okUnchecked;
+    },
     get optionOf () {
         return optionOf;
     },
     get some () {
         return some;
+    },
+    get someUnchecked () {
+        return someUnchecked;
     }
 });
 const NONE = undefined;
+const EMPTY = Object.freeze([]);
 function isSome(opt) {
     return opt !== null && opt !== undefined;
 }
@@ -50,29 +66,44 @@ function isNone(opt) {
 function optionOf(value) {
     return isNone(value) ? NONE : value;
 }
-function some(value) {
+function someUnchecked(value) {
     return value;
 }
+function some(value) {
+    if (value === null || value === undefined) {
+        throw new TypeError('some() requires a non-nullable value');
+    }
+    return someUnchecked(value);
+}
 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;
-}
 function isOk(result) {
-    return !hasErrBrand(result);
+    return !result?.[ERR_BRAND];
 }
 function isErr(result) {
-    return hasErrBrand(result);
+    return result?.[ERR_BRAND] === true;
 }
-function ok(value) {
+function okUnchecked(value) {
     return value;
 }
+function ok(value) {
+    if (isErr(value)) {
+        throw new TypeError('ok() cannot wrap an Err value');
+    }
+    return okUnchecked(value);
+}
 function err(error) {
     return new ResultErrorCtor(error);
 }
+function isThenable(value) {
+    return typeof value?.then === 'function';
+}
+function isSync(value) {
+    return typeof value?.then !== 'function';
+}
 
 //# sourceMappingURL=types.cjs.map

package/build/types.cjs.map

@@ -1 +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","err","isErr","isNone","isOk","isSome","none","ok","optionOf","some","undefined","opt","value","ERR_BRAND","Symbol","for","ResultErrorCtor","error","prototype","hasErrBrand","result"],"mappings":";;;;;;;;;;;QA+BaA;eAAAA;;QAuKGC;eAAAA;;QAvBAC;eAAAA;;QAtGAC;eAAAA;;QAuFAC;eAAAA;;QAvGAC;eAAAA;;QAgDHC;eAAAA;;QAiFGC;eAAAA;;QAjGAC;eAAAA;;QAWAC;eAAAA;;;AArET,MAAMT,OAAOU;AA0Bb,SAASL,OAAOM,GAAY;IACjC,OAAOA,QAAQ,QAAQA,QAAQD;AACjC;AAcO,SAASP,OAAOQ,GAAY;IACjC,OAAOA,QAAQ,QAAQA,QAAQD;AACjC;AAcO,SAASF,SAAYI,KAAQ;IAClC,OAAOT,OAAOS,SAAsBZ,OAAQY;AAC9C;AASO,SAASH,KAAQG,KAAmB;IACzC,OAAOA;AACT;AAGO,MAAMN,OAAaN;AAO1B,MAAMa,YAAYC,OAAOC,GAAG,CAAC;AAO7B,SAASC,gBAA8CC,KAAQ;IAC7D,AAAC,IAAI,CAAkBA,KAAK,GAAGA;AACjC;AACCD,gBAAgBE,SAAS,AAA0B,CAACL,UAAU,GAAG;AAKlE,SAASM,YAAYP,KAAc;IACjC,OAAO,AAACA,OAAmC,CAACC,UAAU,KAAK;AAC7D;AA+BO,SAAST,KAAWgB,MAAoB;IAC7C,OAAO,CAACD,YAAYC;AACtB;AAaO,SAASlB,MAAYkB,MAAoB;IAC9C,OAAOD,YAAYC;AACrB;AASO,SAASb,GAAMK,KAAQ;IAC5B,OAAOA;AACT;AAUO,SAASX,IAAOgB,KAAQ;IAC7B,OAAO,IAAKD,gBAAwDC;AACtE"}
+{"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/** Shared frozen empty array to avoid allocations. */\nexport const EMPTY: readonly unknown[] = Object.freeze([]);\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\nexport function someUnchecked<T>(value: T): Some<ValueType<T>> {\n  return value as Some<ValueType<T>>;\n}\n\n/**\n * Creates a Some value with runtime validation.\n * @param value - The value to wrap\n * @returns The value typed as Some\n * @throws TypeError if value is null or undefined\n * @example\n * some(42) // Some(42)\n */\nexport function some<T>(value: ValueType<T>): Some<ValueType<T>> {\n  if (value === null || value === undefined) {\n    throw new TypeError('some() requires a non-nullable value');\n  }\n  return someUnchecked(value);\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\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(result: unknown): boolean;\nexport function isOk(result: unknown): boolean {\n  return !(result as Record<symbol, unknown>)?.[ERR_BRAND];\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<unknown>): false;\nexport function isErr<T, E>(result: Result<T, E>): result is Err<E>;\nexport function isErr(result: unknown): result is Err<unknown>;\nexport function isErr(result: unknown): boolean {\n  return (result as Record<symbol, unknown>)?.[ERR_BRAND] === true;\n}\n\nexport function okUnchecked<T>(value: T): Ok<T> {\n  return value as Ok<T>;\n}\n\n/**\n * Creates an Ok value with runtime validation.\n * @param value - The success value\n * @returns The value typed as Ok\n * @throws TypeError if value is an Err\n * @example\n * ok(42) // Ok(42)\n */\nexport function ok<T>(value: T): Ok<T> {\n  if (isErr(value)) {\n    throw new TypeError('ok() cannot wrap an Err value');\n  }\n  return okUnchecked(value);\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\n/** A value that may or may not be a Promise. */\nexport type MaybePromise<T> = T | Promise<T> | PromiseLike<T>;\n\n/**\n * Checks if a value is a thenable (has a .then method).\n * @param value - The value to check\n * @returns true if value is a PromiseLike\n */\nexport function isThenable<T>(value: MaybePromise<T>): value is PromiseLike<T> {\n  return typeof (value as PromiseLike<T>)?.then === 'function';\n}\n\n/**\n * Checks if a value is synchronous (not a thenable).\n * @param value - The value to check\n * @returns true if value is not a PromiseLike\n */\nexport function isSync<T>(value: MaybePromise<T>): value is T {\n  return typeof (value as PromiseLike<T>)?.then !== 'function';\n}\n"],"names":["EMPTY","NONE","err","isErr","isNone","isOk","isSome","isSync","isThenable","none","ok","okUnchecked","optionOf","some","someUnchecked","undefined","Object","freeze","opt","value","TypeError","ERR_BRAND","Symbol","for","ResultErrorCtor","error","prototype","result","then"],"mappings":";;;;;;;;;;;QAkCaA;eAAAA;;QAHAC;eAAAA;;QAwLGC;eAAAA;;QA/BAC;eAAAA;;QA5GAC;eAAAA;;QA4FAC;eAAAA;;QA5GAC;eAAAA;;QAgLAC;eAAAA;;QATAC;eAAAA;;QA/GHC;eAAAA;;QAoFGC;eAAAA;;QAZAC;eAAAA;;QAhGAC;eAAAA;;QAgBAC;eAAAA;;QAZAC;eAAAA;;;AAjET,MAAMb,OAAOc;AAGb,MAAMf,QAA4BgB,OAAOC,MAAM,CAAC,EAAE;AA0BlD,SAASX,OAAOY,GAAY;IACjC,OAAOA,QAAQ,QAAQA,QAAQH;AACjC;AAcO,SAASX,OAAOc,GAAY;IACjC,OAAOA,QAAQ,QAAQA,QAAQH;AACjC;AAcO,SAASH,SAAYO,KAAQ;IAClC,OAAOf,OAAOe,SAAsBlB,OAAQkB;AAC9C;AAEO,SAASL,cAAiBK,KAAQ;IACvC,OAAOA;AACT;AAUO,SAASN,KAAQM,KAAmB;IACzC,IAAIA,UAAU,QAAQA,UAAUJ,WAAW;QACzC,MAAM,IAAIK,UAAU;IACtB;IACA,OAAON,cAAcK;AACvB;AAGO,MAAMV,OAAaR;AAO1B,MAAMoB,YAAYC,OAAOC,GAAG,CAAC;AAO7B,SAASC,gBAA8CC,KAAQ;IAC7D,AAAC,IAAI,CAAkBA,KAAK,GAAGA;AACjC;AACCD,gBAAgBE,SAAS,AAA0B,CAACL,UAAU,GAAG;AAmC3D,SAAShB,KAAKsB,MAAe;IAClC,OAAO,CAAEA,QAAoC,CAACN,UAAU;AAC1D;AAcO,SAASlB,MAAMwB,MAAe;IACnC,OAAO,AAACA,QAAoC,CAACN,UAAU,KAAK;AAC9D;AAEO,SAASV,YAAeQ,KAAQ;IACrC,OAAOA;AACT;AAUO,SAAST,GAAMS,KAAQ;IAC5B,IAAIhB,MAAMgB,QAAQ;QAChB,MAAM,IAAIC,UAAU;IACtB;IACA,OAAOT,YAAYQ;AACrB;AAUO,SAASjB,IAAOuB,KAAQ;IAC7B,OAAO,IAAKD,gBAAwDC;AACtE;AAUO,SAASjB,WAAcW,KAAsB;IAClD,OAAO,OAAQA,OAA0BS,SAAS;AACpD;AAOO,SAASrB,OAAUY,KAAsB;IAC9C,OAAO,OAAQA,OAA0BS,SAAS;AACpD"}

package/build/types.d.ts

@@ -17,6 +17,8 @@ export type None = NoneValueType & {
 };
 /** Constant representing None. Use this instead of null/undefined for clarity. */
 export declare const NONE: None;
+/** Shared frozen empty array to avoid allocations. */
+export declare const EMPTY: readonly unknown[];
 /** 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. */
@@ -61,10 +63,12 @@ export declare function isNone(opt: unknown): opt is 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>;
+export declare function someUnchecked<T>(value: T): Some<ValueType<T>>;
 /**
- * Creates a Some value. Does not validate - use safe.some() for validation.
- * @param value - The value to wrap (must be non-null)
+ * Creates a Some value with runtime validation.
+ * @param value - The value to wrap
  * @returns The value typed as Some
+ * @throws TypeError if value is null or undefined
  * @example
  * some(42) // Some(42)
  */
@@ -106,6 +110,7 @@ export type InferErr<T> = T extends Err<infer TError> ? Err<TError> : never;
 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>;
+export declare function isOk(result: unknown): boolean;
 /**
  * Checks if a Result is Err (failed).
  * @param result - The Result to check
@@ -115,12 +120,15 @@ export declare function isOk<T, E>(result: Result<T, E>): result is Ok<T>;
  * 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(result: Ok<unknown>): false;
 export declare function isErr<T, E>(result: Result<T, E>): result is Err<E>;
+export declare function isErr(result: unknown): result is Err<unknown>;
+export declare function okUnchecked<T>(value: T): Ok<T>;
 /**
- * Creates an Ok value. Does not validate - use safe.ok() for validation.
+ * Creates an Ok value with runtime validation.
  * @param value - The success value
  * @returns The value typed as Ok
+ * @throws TypeError if value is an Err
  * @example
  * ok(42) // Ok(42)
  */
@@ -134,4 +142,18 @@ export declare function ok<T>(value: T): Ok<T>;
  * err(new Error('failed'))    // Err(Error)
  */
 export declare function err<E>(error: E): Err<E>;
+/** A value that may or may not be a Promise. */
+export type MaybePromise<T> = T | Promise<T> | PromiseLike<T>;
+/**
+ * Checks if a value is a thenable (has a .then method).
+ * @param value - The value to check
+ * @returns true if value is a PromiseLike
+ */
+export declare function isThenable<T>(value: MaybePromise<T>): value is PromiseLike<T>;
+/**
+ * Checks if a value is synchronous (not a thenable).
+ * @param value - The value to check
+ * @returns true if value is not a PromiseLike
+ */
+export declare function isSync<T>(value: MaybePromise<T>): value is T;
 export {};

package/build/types.js

@@ -1,4 +1,5 @@
 export const NONE = undefined;
+export const EMPTY = Object.freeze([]);
 export function isSome(opt) {
     return opt !== null && opt !== undefined;
 }
@@ -8,29 +9,44 @@ export function isNone(opt) {
 export function optionOf(value) {
     return isNone(value) ? NONE : value;
 }
-export function some(value) {
+export function someUnchecked(value) {
     return value;
 }
+export function some(value) {
+    if (value === null || value === undefined) {
+        throw new TypeError('some() requires a non-nullable value');
+    }
+    return someUnchecked(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);
+    return !result?.[ERR_BRAND];
 }
 export function isErr(result) {
-    return hasErrBrand(result);
+    return result?.[ERR_BRAND] === true;
 }
-export function ok(value) {
+export function okUnchecked(value) {
     return value;
 }
+export function ok(value) {
+    if (isErr(value)) {
+        throw new TypeError('ok() cannot wrap an Err value');
+    }
+    return okUnchecked(value);
+}
 export function err(error) {
     return new ResultErrorCtor(error);
 }
+export function isThenable(value) {
+    return typeof value?.then === 'function';
+}
+export function isSync(value) {
+    return typeof value?.then !== 'function';
+}
 
 //# sourceMappingURL=types.js.map

package/build/types.js.map

@@ -1 +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"}
+{"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/** Shared frozen empty array to avoid allocations. */\nexport const EMPTY: readonly unknown[] = Object.freeze([]);\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\nexport function someUnchecked<T>(value: T): Some<ValueType<T>> {\n  return value as Some<ValueType<T>>;\n}\n\n/**\n * Creates a Some value with runtime validation.\n * @param value - The value to wrap\n * @returns The value typed as Some\n * @throws TypeError if value is null or undefined\n * @example\n * some(42) // Some(42)\n */\nexport function some<T>(value: ValueType<T>): Some<ValueType<T>> {\n  if (value === null || value === undefined) {\n    throw new TypeError('some() requires a non-nullable value');\n  }\n  return someUnchecked(value);\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\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(result: unknown): boolean;\nexport function isOk(result: unknown): boolean {\n  return !(result as Record<symbol, unknown>)?.[ERR_BRAND];\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<unknown>): false;\nexport function isErr<T, E>(result: Result<T, E>): result is Err<E>;\nexport function isErr(result: unknown): result is Err<unknown>;\nexport function isErr(result: unknown): boolean {\n  return (result as Record<symbol, unknown>)?.[ERR_BRAND] === true;\n}\n\nexport function okUnchecked<T>(value: T): Ok<T> {\n  return value as Ok<T>;\n}\n\n/**\n * Creates an Ok value with runtime validation.\n * @param value - The success value\n * @returns The value typed as Ok\n * @throws TypeError if value is an Err\n * @example\n * ok(42) // Ok(42)\n */\nexport function ok<T>(value: T): Ok<T> {\n  if (isErr(value)) {\n    throw new TypeError('ok() cannot wrap an Err value');\n  }\n  return okUnchecked(value);\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\n/** A value that may or may not be a Promise. */\nexport type MaybePromise<T> = T | Promise<T> | PromiseLike<T>;\n\n/**\n * Checks if a value is a thenable (has a .then method).\n * @param value - The value to check\n * @returns true if value is a PromiseLike\n */\nexport function isThenable<T>(value: MaybePromise<T>): value is PromiseLike<T> {\n  return typeof (value as PromiseLike<T>)?.then === 'function';\n}\n\n/**\n * Checks if a value is synchronous (not a thenable).\n * @param value - The value to check\n * @returns true if value is not a PromiseLike\n */\nexport function isSync<T>(value: MaybePromise<T>): value is T {\n  return typeof (value as PromiseLike<T>)?.then !== 'function';\n}\n"],"names":["NONE","undefined","EMPTY","Object","freeze","isSome","opt","isNone","optionOf","value","someUnchecked","some","TypeError","none","ERR_BRAND","Symbol","for","ResultErrorCtor","error","prototype","isOk","result","isErr","okUnchecked","ok","err","isThenable","then","isSync"],"mappings":"AA+BA,OAAO,MAAMA,OAAOC,UAAkB;AAGtC,OAAO,MAAMC,QAA4BC,OAAOC,MAAM,CAAC,EAAE,EAAE;AA0B3D,OAAO,SAASC,OAAOC,GAAY;IACjC,OAAOA,QAAQ,QAAQA,QAAQL;AACjC;AAcA,OAAO,SAASM,OAAOD,GAAY;IACjC,OAAOA,QAAQ,QAAQA,QAAQL;AACjC;AAcA,OAAO,SAASO,SAAYC,KAAQ;IAClC,OAAOF,OAAOE,SAAsBT,OAAQS;AAC9C;AAEA,OAAO,SAASC,cAAiBD,KAAQ;IACvC,OAAOA;AACT;AAUA,OAAO,SAASE,KAAQF,KAAmB;IACzC,IAAIA,UAAU,QAAQA,UAAUR,WAAW;QACzC,MAAM,IAAIW,UAAU;IACtB;IACA,OAAOF,cAAcD;AACvB;AAGA,OAAO,MAAMI,OAAab,KAAK;AAO/B,MAAMc,YAAYC,OAAOC,GAAG,CAAC;AAO7B,SAASC,gBAA8CC,KAAQ;IAC7D,AAAC,IAAI,CAAkBA,KAAK,GAAGA;AACjC;AACCD,gBAAgBE,SAAS,AAA0B,CAACL,UAAU,GAAG;AAmClE,OAAO,SAASM,KAAKC,MAAe;IAClC,OAAO,CAAEA,QAAoC,CAACP,UAAU;AAC1D;AAcA,OAAO,SAASQ,MAAMD,MAAe;IACnC,OAAO,AAACA,QAAoC,CAACP,UAAU,KAAK;AAC9D;AAEA,OAAO,SAASS,YAAed,KAAQ;IACrC,OAAOA;AACT;AAUA,OAAO,SAASe,GAAMf,KAAQ;IAC5B,IAAIa,MAAMb,QAAQ;QAChB,MAAM,IAAIG,UAAU;IACtB;IACA,OAAOW,YAAYd;AACrB;AAUA,OAAO,SAASgB,IAAOP,KAAQ;IAC7B,OAAO,IAAKD,gBAAwDC;AACtE;AAUA,OAAO,SAASQ,WAAcjB,KAAsB;IAClD,OAAO,OAAQA,OAA0BkB,SAAS;AACpD;AAOA,OAAO,SAASC,OAAUnB,KAAsB;IAC9C,OAAO,OAAQA,OAA0BkB,SAAS;AACpD"}

package/build/unsafe.cjs

@@ -9,74 +9,27 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    get Option () {
-        return _optioncjs;
-    },
-    get Result () {
-        return _resultcjs;
-    },
-    get err () {
-        return _typescjs.err;
-    },
-    get none () {
-        return _typescjs.none;
-    },
     get ok () {
-        return ok;
+        return _typescjs.okUnchecked;
     },
     get some () {
-        return some;
+        return _typescjs.someUnchecked;
     }
 });
+_export_star(require("./safe.cjs"), exports);
 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];
-            }
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
         }
-    }
-    newObj.default = obj;
-    if (cache) {
-        cache.set(obj, newObj);
-    }
-    return newObj;
-}
-function some(value) {
-    return value;
-}
-function ok(value) {
-    return value;
+    });
+    return from;
 }
 
 //# sourceMappingURL=unsafe.cjs.map

package/build/unsafe.cjs.map

@@ -1 +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"}
+{"version":3,"sources":["../src/unsafe.ts"],"sourcesContent":["export * from './safe.js';\nexport { someUnchecked as some, okUnchecked as ok } from './types.js';\n"],"names":["ok","okUnchecked","some","someUnchecked"],"mappings":";;;;;;;;;;;QAC+CA;eAAfC,qBAAW;;QAAjBC;eAAjBC,uBAAa;;;qBADR;0BAC2C"}

package/build/unsafe.d.ts

@@ -1,27 +1,2 @@
-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>;
+export * from './safe.js';
+export { someUnchecked as some, okUnchecked as ok } from './types.js';

package/build/unsafe.js

@@ -1,11 +1,4 @@
-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;
-}
+export * from "./safe.js";
+export { someUnchecked as some, okUnchecked as ok } from "./types.js";
 
 //# sourceMappingURL=unsafe.js.map

package/build/unsafe.js.map

@@ -1 +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"}
+{"version":3,"sources":["../src/unsafe.ts"],"sourcesContent":["export * from './safe.js';\nexport { someUnchecked as some, okUnchecked as ok } from './types.js';\n"],"names":["someUnchecked","some","okUnchecked","ok"],"mappings":"AAAA,cAAc,YAAY;AAC1B,SAASA,iBAAiBC,IAAI,EAAEC,eAAeC,EAAE,QAAQ,aAAa"}