inferred-types 0.52.14 → 0.53.0

package/dist/runtime/dictionary/withKeys.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"withKeys.d.ts","sourceRoot":"","sources":["../../../src/runtime/dictionary/withKeys.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAI9E;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,GACnB,IAAI,SAAS,UAAU,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC,EAC3C,CAAC,SAAS,UAAU,EACpB,KAAK,SAAS,SAAS,CAAC,SAAS,GAAG,MAAM,IAAI,CAAC,EAAE,QAE3C,IAAI,WACD,KAAK;;;;;;;grBACU,CAAC"}

package/dist/runtime/dictionary/withKeys.js

@@ -1,10 +0,0 @@
-import { retain } from "./retain";
-/**
- * **withKeys**(obj,keys)
- *
- * Reduces the key/value pairs in an object to those keys
- * explicitly stated.
- *
- * - note: this function is an alias for `retain()`
- */
-export const withKeys = (dict, ...keys) => retain(dict, ...keys);

package/dist/runtime/dictionary/withoutKeys.d.ts

@@ -1,13 +0,0 @@
-import type { NarrowObject, Narrowable } from "inferred-types/types";
-/**
- * **withoutKeys**(obj,...keys)
- *
- * Reduces the key/value pairs in an object with the expressed
- * keys excluded.
- *
- * - this is an alias to the `omit()` utility
- *
- * **Related**: `omit`, `createOmission`
- */
-export declare const withoutKeys: <TObj extends NarrowObject<N>, N extends Narrowable, TKeys extends readonly (string & keyof TObj)[]>(dict: TObj, ...exclude: TKeys) => import("inferred-types/types").WithoutKeys<TObj, [...TKeys]>;
-//# sourceMappingURL=withoutKeys.d.ts.map

package/dist/runtime/dictionary/withoutKeys.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"withoutKeys.d.ts","sourceRoot":"","sources":["../../../src/runtime/dictionary/withoutKeys.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAIrE;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,GACtB,IAAI,SAAS,YAAY,CAAC,CAAC,CAAC,EAC5B,CAAC,SAAS,UAAU,EACpB,KAAK,SAAS,SAAS,CAAC,MAAM,GAAG,MAAM,IAAI,CAAC,EAAE,QAExC,IAAI,cACE,KAAK,iEACQ,CAAC"}

package/dist/runtime/dictionary/withoutKeys.js

@@ -1,12 +0,0 @@
-import { omit } from "inferred-types/runtime";
-/**
- * **withoutKeys**(obj,...keys)
- *
- * Reduces the key/value pairs in an object with the expressed
- * keys excluded.
- *
- * - this is an alias to the `omit()` utility
- *
- * **Related**: `omit`, `createOmission`
- */
-export const withoutKeys = (dict, ...exclude) => omit(dict, ...exclude);

package/dist/runtime/dictionary/withoutValue.d.ts

@@ -1,17 +0,0 @@
-import { AnyObject, Narrowable, WithoutValue } from "inferred-types/types";
-/**
- * **withoutValue**
- *
- * Reduces a dictionary object -- in both _type_ and _run-time_ structure -- to only those
- * key/value pairs which _do not have_ a specified value. For instance:
- *
- * ```ts
- * const obj = { foo: 1, bar: 2, message: "hi there" };
- * // { message: "hi there" }
- * const onlyStrings = withoutValue(t => kind.string())(obj);
- * // { foo: 1 }
- * const justOne = withoutValue(t => kind.literal(1))(obj);
- * ```
- */
-export declare function withoutValue<TVal extends Narrowable>(val: TVal): <TObj extends AnyObject>(obj: TObj) => WithoutValue<TObj, TVal>;
-//# sourceMappingURL=withoutValue.d.ts.map

package/dist/runtime/dictionary/withoutValue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"withoutValue.d.ts","sourceRoot":"","sources":["../../../src/runtime/dictionary/withoutValue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAE3E;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,IAAI,SAAS,UAAU,EAAE,GAAG,EAAE,IAAI,IACrD,IAAI,SAAS,SAAS,OAAO,IAAI,KAAG,YAAY,CAAC,IAAI,EAAC,IAAI,CAAC,CAQpE"}

package/dist/runtime/dictionary/withoutValue.js

@@ -1,21 +0,0 @@
-/**
- * **withoutValue**
- *
- * Reduces a dictionary object -- in both _type_ and _run-time_ structure -- to only those
- * key/value pairs which _do not have_ a specified value. For instance:
- *
- * ```ts
- * const obj = { foo: 1, bar: 2, message: "hi there" };
- * // { message: "hi there" }
- * const onlyStrings = withoutValue(t => kind.string())(obj);
- * // { foo: 1 }
- * const justOne = withoutValue(t => kind.literal(1))(obj);
- * ```
- */
-export function withoutValue(val) {
-    return (obj) => {
-        return Object.keys(obj).reduce((acc, key) => val === obj[key]
-            ? acc
-            : ({ ...acc, [key]: obj[key] }), {});
-    };
-}

package/dist/runtime/errors/KindError.d.ts

@@ -1,30 +0,0 @@
-import { KindErrorDefn, Narrowable } from "inferred-types/types";
-/**
- * **KindError**
- *
- * A higher order function who's utility is to create a type and context aware
- * error message. The first call defines:
- *
- * - the "kind" used to categorize the error
- * - key/value pairs which represent will eventually be represented
- * in the Error's `context` property.
- *
- * The second call fully applies this function into an Error and takes at
- * minimum a `message` parameter but can also add a second parameter to
- * add to the "context" which the error conveys.
- *
- * ```ts
- * // Defines the Error
- * const BadJuju = kindError("bad-juju", { flavor?: "" });
- * // BadJuju {
- * //     name: BadJuju;
- * //     kind: "bad-juju";
- * //     msg: "oh my god!";
- * //     context: { flavor?: string}
- * // }
- * BadJuju("oh my god!");
- * BadJuju("oh my god!", { flavor: "strawberry"})
- * ```
- */
-export declare function kindError<TKind extends string, TBaseContext extends Record<string, BC>, BC extends Narrowable = Narrowable>(kind: TKind, baseContext?: TBaseContext): KindErrorDefn<TKind, TBaseContext>;
-//# sourceMappingURL=KindError.d.ts.map

package/dist/runtime/errors/KindError.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"KindError.d.ts","sourceRoot":"","sources":["../../../src/runtime/errors/KindError.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,aAAa,EAEb,UAAU,EACX,MAAM,sBAAsB,CAAC;AAa9B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,SAAS,CACvB,KAAK,SAAS,MAAM,EACpB,YAAY,SAAS,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,EACvC,EAAE,SAAS,UAAU,GAAG,UAAU,EAElC,IAAI,EAAE,KAAK,EACX,WAAW,GAAE,YAAgD,GAC5D,aAAa,CACd,KAAK,EACL,YAAY,CACb,CA0CA"}

package/dist/runtime/errors/KindError.js

@@ -1,59 +0,0 @@
-import { stripChars, toKebabCase, toPascalCase } from "../literals";
-import { parse } from "error-stack-parser-es/lite";
-import { relative } from "pathe";
-const IGNORABLES = [
-    "@vitest/runner",
-    "node:"
-];
-/**
- * **KindError**
- *
- * A higher order function who's utility is to create a type and context aware
- * error message. The first call defines:
- *
- * - the "kind" used to categorize the error
- * - key/value pairs which represent will eventually be represented
- * in the Error's `context` property.
- *
- * The second call fully applies this function into an Error and takes at
- * minimum a `message` parameter but can also add a second parameter to
- * add to the "context" which the error conveys.
- *
- * ```ts
- * // Defines the Error
- * const BadJuju = kindError("bad-juju", { flavor?: "" });
- * // BadJuju {
- * //     name: BadJuju;
- * //     kind: "bad-juju";
- * //     msg: "oh my god!";
- * //     context: { flavor?: string}
- * // }
- * BadJuju("oh my god!");
- * BadJuju("oh my god!", { flavor: "strawberry"})
- * ```
- */
-export function kindError(kind, baseContext = {}) {
-    return (msg, context = {}) => {
-        const err = new Error(msg);
-        const stackTrace = parse(err)
-            .filter(i => !IGNORABLES.some(has => i.file && i.file.includes(has)))
-            .map(i => ({
-            ...i,
-            file: i.file
-                ? relative(process.cwd(), i.file)
-                : undefined
-        }));
-        err.name = toPascalCase(kind);
-        err.kind = toKebabCase(stripChars(kind, "<", ">", "[", "]", "(", ")"));
-        err.file = stackTrace[0].file;
-        err.line = stackTrace[0].line;
-        err.col = stackTrace[0].col;
-        err.stackTrace = stackTrace;
-        err.__kind = "KindError";
-        err.context = {
-            ...baseContext,
-            ...context
-        };
-        return err;
-    };
-}

package/dist/runtime/errors/TypedError.d.ts

@@ -1,31 +0,0 @@
-import { AnyObject, Narrowable } from "inferred-types/types";
-export interface TypedError<TKind extends string = string, TMsg extends string = string, TContext extends AnyObject = AnyObject> extends Error {
-    kind: TKind;
-    msg: TMsg;
-    context: TContext;
-    stack?: string;
-}
-/**
- * **KindedApi**
- *
- * An error builder where the `kind` property has already been set.
- */
-export type KindedApi<TKind extends string> = <TMsg extends string, K extends PropertyKey, V extends Narrowable, TContext extends Record<K, V>>(msg: TMsg, context?: TContext) => TypedError<TKind, TMsg, TContext>;
-export type ErrorApi = {
-    /**
-     * A simple API surface to create an error with a `kind` and `msg` type.
-     */
-    kinded<TKind extends string, TMsg extends string>(kind: TKind, msg: TMsg): TypedError<TMsg, TKind>;
-    /**
-     * Allows expressing the `kind` of error initially
-     * and then provides a function to supply specific
-     * errors.
-     */
-    asKind<TKind extends string>(kind: TKind): KindedApi<TKind>;
-};
-export declare const TypedError: (<TMsg extends string>(msg: TMsg) => {
-    kind: "unknown";
-    msg: TMsg;
-    context: {};
-}) & ErrorApi;
-//# sourceMappingURL=TypedError.d.ts.map

package/dist/runtime/errors/TypedError.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TypedError.d.ts","sourceRoot":"","sources":["../../../src/runtime/errors/TypedError.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAe,UAAU,EAAG,MAAM,sBAAsB,CAAC;AAG3E,MAAM,WAAW,UAAU,CACzB,KAAK,SAAS,MAAM,GAAG,MAAM,EAC7B,IAAI,SAAS,MAAM,GAAG,MAAM,EAC5B,QAAQ,SAAS,SAAS,GAAG,SAAS,CACtC,SAAQ,KAAK;IACb,IAAI,EAAE,KAAK,CAAC;IACZ,GAAG,EAAE,IAAI,CAAC;IACV,OAAO,EAAE,QAAQ,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,MAAM,MAAM,SAAS,CAAC,KAAK,SAAS,MAAM,IAAI,CAC5C,IAAI,SAAS,MAAM,EACnB,CAAC,SAAS,WAAW,EACrB,CAAC,SAAS,UAAU,EACpB,QAAQ,SAAS,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EAC7B,GAAG,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,QAAQ,KAAK,UAAU,CAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;AAEtE,MAAM,MAAM,QAAQ,GAAG;IACrB;;OAEG;IACH,MAAM,CAAC,KAAK,SAAS,MAAM,EAAE,IAAI,SAAS,MAAM,EAC9C,IAAI,EAAE,KAAK,EACX,GAAG,EAAE,IAAI,GAAG,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAEtC;;;;OAIG;IACH,MAAM,CAAC,KAAK,SAAS,MAAM,EAAE,IAAI,EAAE,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;CAC7D,CAAC;AAyBF,eAAO,MAAM,UAAU,IAPR,IAAI,SAAS,MAAM,OAAO,IAAI;;;;aAOK,CAAC"}

package/dist/runtime/errors/TypedError.js

@@ -1,16 +0,0 @@
-import { addFnToProps } from "inferred-types/runtime";
-const fn = (kind) => (msg) => ({
-    kind,
-    msg,
-    context: {}
-});
-const api = {
-    kinded: (kind, msg) => fn(kind)(msg),
-    asKind: (kind) => (msg, context) => ({ kind, msg, context: context || {} })
-};
-const basic = (msg) => ({
-    kind: "unknown",
-    msg,
-    context: {}
-});
-export const TypedError = addFnToProps(api)(basic);

package/dist/runtime/errors/createErrorCondition.d.ts

@@ -1,14 +0,0 @@
-import { Throw } from "inferred-types/types";
-/**
- * **createErrorConditionTemplate**`(kind,[msg],[utility]) => ErrorCondition`
- *
- * A higher order runtime utility for generating reusable `ErrorCondition`'s at
- * runtime.
- */
-export declare const createErrorCondition: <TKind extends string, TMsg extends string = never, TUtility extends string = never>(kind: TKind, msg?: TMsg, utility?: TUtility) => Throw<TKind, TMsg, TUtility>;
-export declare const errCondition: (kind: string, msg?: string) => {
-    __kind: string;
-    kind: string;
-    msg: string | undefined;
-};
-//# sourceMappingURL=createErrorCondition.d.ts.map

package/dist/runtime/errors/createErrorCondition.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createErrorCondition.d.ts","sourceRoot":"","sources":["../../../src/runtime/errors/createErrorCondition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAG7C;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAC/B,KAAK,SAAS,MAAM,EACpB,IAAI,SAAS,MAAM,UACnB,QAAQ,SAAS,MAAM,gBAEjB,KAAK,QACN,IAAI,YACA,QAAQ,KAOD,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,CAC5C,CAAC;AAGF,eAAO,MAAM,YAAY,SACjB,MAAM,QACN,MAAM;;;;CAKZ,CAAA"}

package/dist/runtime/errors/createErrorCondition.js

@@ -1,19 +0,0 @@
-/**
- * **createErrorConditionTemplate**`(kind,[msg],[utility]) => ErrorCondition`
- *
- * A higher order runtime utility for generating reusable `ErrorCondition`'s at
- * runtime.
- */
-export const createErrorCondition = (kind, msg = "", utility = "") => {
-    return {
-        __kind: "ErrorCondition",
-        kind,
-        msg,
-        utility,
-    };
-};
-export const errCondition = (kind, msg) => ({
-    __kind: "ErrorCondition",
-    kind,
-    msg
-});

package/dist/runtime/errors/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./createErrorCondition";
-export * from "./KindError";
-//# sourceMappingURL=index.d.ts.map

package/dist/runtime/errors/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/errors/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,aAAa,CAAC"}

package/dist/runtime/errors/index.js

@@ -1,2 +0,0 @@
-export * from "./createErrorCondition";
-export * from "./KindError";

package/dist/runtime/functional/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./result";
-//# sourceMappingURL=index.d.ts.map

package/dist/runtime/functional/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/functional/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC"}

package/dist/runtime/functional/index.js

@@ -1 +0,0 @@
-export * from "./result";

package/dist/runtime/functional/result.d.ts

@@ -1,2 +0,0 @@
-export declare const result = "NOT READY";
-//# sourceMappingURL=result.d.ts.map

package/dist/runtime/functional/result.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../../src/runtime/functional/result.ts"],"names":[],"mappings":"AAoTA,eAAO,MAAM,MAAM,cAAc,CAAA"}

package/dist/runtime/functional/result.js

@@ -1,286 +0,0 @@
-// /* eslint-disable @typescript-eslint/no-explicit-any */
-// /* eslint-disable no-use-before-define */
-// import { RESULT } from "inferred-types/constants"
-// import {
-//   Ok,
-//   Result,
-//   AsFunction,
-//   Narrowable,
-//   Err,
-//   ResultErr,
-//   ObjectKey,
-//   ResultTuple,
-//   TupleToUnion,
-//   ResultApi,
-//   IfEqual,
-//   IsOk,
-//   IsErr,
-//   ErrInput,
-//   IsFunction,
-//   If,
-// } from "inferred-types/types"
-// import { Never } from "inferred-types/constants";
-// import { isFunction, isObject, isString } from "../type-guards/index";
-// import { toKebabCase } from "../literals/toKebabCase";
-// import { asUnion } from "../type-conversion/asUnion";
-// import { isRuntimeUnion } from "../type-guards/isRuntimeUnion";
-// import { takeProp } from "../dictionary";
-// import { kindError } from "../errors";
-// import { toPascalCase } from "../literals";
-// const errInputs: ErrInput = "undefined" as const;
-// export const isResult = (val: unknown): val is Result => {
-//   return typeof val === "object" &&
-//     "__kind" in (val as object) &&
-//     "state" in (val as object) &&
-//     [RESULT.Err, RESULT.Ok].includes((val as any).state)
-// }
-// function resultTuple<
-//   T,
-//   E extends ErrInput
-// >(val: T, err: E) {
-//   return {
-//     __kind: ["Result", val, err]
-//   } as ResultTuple<T,E>;
-// }
-// export const asResult = <
-//   T,
-//   E extends ErrInput
-// >(val: T, err: E): ResultApi<T,E> => ({
-//   kind: "Result API",
-//   result: null as unknown as Result<T,E>,
-//   ok: (v) => {
-//     return {
-//       ...resultTuple(val,err), state: RESULT.Ok, val: v
-//     } as Ok<T>
-//   },
-//   err: (e) => {
-//     return {
-//       ...resultTuple(val,err),
-//       state: RESULT.Err,
-//       err: transformErrInput(e)
-//     } as unknown as Err<E>
-//   },
-//   isErr: (v) => {
-//     return isResult(v) && v.state === RESULT.Err;
-//   },
-//   isOk: (v) => {
-//     return isResult(v) && v.state === RESULT.Ok;
-//   },
-//   okOrElse: (result, otherwise) => {
-//     return result.state === RESULT.Ok
-//       ? result.val
-//       : typeof otherwise === "function"
-//         ? otherwise(result)
-//         : otherwise
-//   },
-//   okOrThrow: (result) => {
-//     if (isErr(result)) {
-//       const { msg, kind, context } = result.err;
-//       throw kindError(kind)(msg, context);
-//     }
-//   }
-// }) as ResultApi<T,E>;
-// /**
-//  * **ok**(val)
-//  *
-//  * Places a value into the `Ok` state of a `Result` structure.
-//  *
-//  * Note: if you need/want the value to be narrowly typed then use `okN()` instead.
-//  */
-// export function ok<
-//   T,
-//   E extends ErrInput
-// >(val: T, _err: E = errInputs as E): IfEqual<E, ErrInput, Ok<T>, Ok<T,E>> {
-//   const tuple = resultTuple(val, _err) as unknown as ResultTuple<T,E>;
-//   return { ...tuple, state: RESULT.Ok, val }
-// }
-// /**
-//  * **ok**(val)
-//  *
-//  * Places a value into the `Ok` state of a `Result` structure.
-//  *
-//  * Note: this can only receive _narrowable_ types in order to provide the
-//  * narrowest type possible for `T` but if you don't need this then use the
-//  * `ok(val)` function instead.
-//  */
-// export function okN<
-//   T extends Narrowable,
-//   E extends ErrInput
-// >(val: T, _err: E = errInputs as E): Ok<T> {
-//   const tuple = resultTuple(val, "unknown") as unknown as ResultTuple<T,E>;
-//   return { ...tuple, state: RESULT.Ok, val }
-// }
-// /**
-//  * Used to convert an `ErrInput` into `ResultErr[]`
-//  */
-// const transformErrInput = <
-//   T extends ErrInput
-// >(input: T): TupleToUnion<Err<T>> => {
-//   const members = (
-//     isRuntimeUnion(input)
-//     ? input.members
-//     : typeof input === "string"
-//     ? [{ msg: input, kind: toKebabCase(input as string), context: {} }]
-//     : typeof input === "object"
-//     ? [{
-//       msg: takeProp((input as Record<ObjectKey, unknown>), "msg", "" as string),
-//       kind: toKebabCase(takeProp((input as Record<ObjectKey, unknown>), "kind", "unspecified-kind") as string),
-//       context: takeProp((input as Record<ObjectKey, unknown>), "context", {} as NonNullable<unknown>),
-//       trace: takeProp((input as Record<ObjectKey, unknown>), "trace", false),
-//     }]
-//     : Array.isArray(input)
-//     ? input
-//     : Never
-//   ) as ResultErr[];
-//   const union =  asUnion(...members);
-//   return union as unknown as TupleToUnion<Err<T>>;
-// }
-// /**
-//  * **createErr**(e) → `<ResultErr>`
-//  *
-//  * Creates a reusable error template which will allow for:
-//  *
-//  * - a strict `kind` definition
-//  * - a _shape_ and default values for the `context` property
-//  * - a strict `stack` definition (default is false)
-//  *
-//  * The `msg` property will be left as `string` allowing each variant of
-//  * this type of error to add their own.
-//  */
-// export const createErr = <
-//   TKind extends string,
-//   TContextDefn extends Record<string, unknown> = NonNullable<unknown>
-// >(kind: TKind, contextDefn?: TContextDefn) => {
-//   return {
-//     msg: "" as string,
-//     kind,
-//     context: (contextDefn || {}) as TContextDefn
-//   } as ResultErr<TKind, TContextDefn>
-// }
-// /**
-//  * **err**(input) -> Err`<E>`
-//  *
-//  * Creates a `Err` error for use inside a `Result<T,E>` block.
-//  */
-// export function err<
-//   TErr extends string | ResultErr<any, any>,
-//   TVal = unknown
-// >(
-//   err: TErr,
-//   _val: TVal = null as unknown as ErrInput as TVal
-// ): IfEqual<TVal, unknown, Err<TErr>, Err<TErr,TVal>> {
-//   return {
-//     ...(resultTuple(_val, err)),
-//     state: RESULT.Err,
-//     err: transformErrInput(err)
-//   } as unknown as IfEqual<TVal, unknown, Err<TErr>, Err<TErr,TVal>>
-// }
-// /**
-//  * **isOk**(result)
-//  *
-//  * Type guard which tests whether the `Result<T,E>` is in the **Ok** state.
-//  */
-// export const isOk = <
-//   T,
-// >(result: Result<T>): result is T & Ok<T> => {
-//   return result.state === RESULT.Ok;
-// }
-// /**
-//  * **okOrThrow**(result)
-//  *
-//  * Returns the Ok _value_ if it's in the Ok status; otherwise throws
-//  * an error.
-//  */
-// export function okOrThrow<
-//   R extends Result<T,E>,
-//   T = undefined,
-//   E extends ErrInput = ErrInput
-// >(result: R): IsOk<R> extends true ? T : never {
-//   if(result.state === RESULT.Err) {
-//     if (typeof result.err === "string") {
-//       throw new Error(result.err);
-//     } else {
-//       let e = new Error(result.err.msg);
-//       for (const key of Object.keys(result.err)) {
-//         if(key !== "msg") {
-//           e = {...e, [key]: result.err[key as keyof typeof result.err]}
-//         }
-//       }
-//       throw e;
-//     }
-//   }
-//   return result.val as IsOk<R> extends true ? T : never;
-// }
-// /**
-//  * **okOrElse**(result, els)
-//  *
-//  * Returns the _value_ of the `Result<T,E>` if in the **Ok** state, otherwise
-//  * returns `els`.
-//  *
-//  * - **Note:** if `els` is a function it will be called while passing the error
-//  * object to the function.
-//  */
-// export function okOrElse<
-//   R extends Result<T,E>,
-//   T,
-//   E extends ResultErr,
-//   Els
-// >(
-//   result: R,
-//   els: Els
-// ): IsOk<R> extends true ? T : If<IsFunction<Els>, ReturnType<AsFunction<Els>>, Els> {
-//   return result.state === RESULT.Err
-//   ? isFunction(els)
-//     ? els(result.err)
-//     : els
-//   : result.val;
-// }
-// export function isErr<
-//   T,
-//   E extends ErrInput
-// >(result: Result<T,E>): result is Err<E,T> {
-//   return (
-//       isString(result)
-//       ? {
-//           state: RESULT.Err,
-//           err:{
-//             msg: result,
-//             kind: toPascalCase(result),
-//             context: {},
-//             stack: false
-//           }
-//         }
-//       : isObject(result)
-//         ? {
-//           state: RESULT.Err,
-//           err: {
-//             msg: result.err.msg || "no message",
-//             kind: takeProp(result, "kind", "no-kind"),
-//             context: takeProp(result, "context", {}),
-//             stack: takeProp(result, "stack", false)
-//           }
-//         }
-//         : false
-//     )
-//     ? true
-//     : false
-// }
-// /**
-//  * **assertErr**(result)
-//  *
-//  * Asserts that a _result_ is of the `Err` type.
-//  */
-// export function assertErr<
-//   T
-// >(result: T): IsErr<T> {
-//   return (
-//     typeof result === "object" &&
-//     (result as any).state === RESULT.Err && "err" in (result as object) && (
-//       typeof (result as any).err === "string" ||
-//       typeof (result as any).err === "object"
-//     )
-//     ? true
-//     : false
-//   ) as IsErr<typeof result>;
-// }
-export const result = "NOT READY";

package/dist/runtime/functions/fnMeta.d.ts

@@ -1,16 +0,0 @@
-import { AnyFunction, AsFnMeta } from "inferred-types/types";
-type _Props<TFn extends AnyFunction> = AsFnMeta<TFn>["props"];
-/**
- * **fnMeta**(func)
- *
- * Runtime utility which provides a `fn` and `props` property which are
- * decomposed from the input function.
- *
- * - the `fn` is a clone of the underlying function
- */
-export declare const fnMeta: <TFn extends AnyFunction>(func: TFn) => {
-    fn: <A extends AsFnMeta<TFn>["args"]>(...args: A) => any;
-    props: _Props<TFn>;
-};
-export {};
-//# sourceMappingURL=fnMeta.d.ts.map

package/dist/runtime/functions/fnMeta.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fnMeta.d.ts","sourceRoot":"","sources":["../../../src/runtime/functions/fnMeta.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAG,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAE9D,KAAK,MAAM,CAAC,GAAG,SAAS,WAAW,IAAI,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC;AAE9D;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,GAAI,GAAG,SAAS,WAAW,QAAQ,GAAG;SAErD,CAAC,SAAS,QAAQ,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,WACrB,CAAC;;CAWd,CAAC"}

package/dist/runtime/functions/fnMeta.js

@@ -1,16 +0,0 @@
-/**
- * **fnMeta**(func)
- *
- * Runtime utility which provides a `fn` and `props` property which are
- * decomposed from the input function.
- *
- * - the `fn` is a clone of the underlying function
- */
-export const fnMeta = (func) => {
-    const fn = (...args) => func(...args);
-    const props = Object.keys(fn).reduce((acc, key) => ({ ...acc, [key]: fn[key] }), {});
-    return {
-        fn,
-        props
-    };
-};

package/dist/runtime/functions/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./fnMeta";
-export * from "./wrapFn";
-//# sourceMappingURL=index.d.ts.map

package/dist/runtime/functions/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/functions/index.ts"],"names":[],"mappings":"AACA,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}

package/dist/runtime/functions/index.js

@@ -1,2 +0,0 @@
-export * from "./fnMeta";
-export * from "./wrapFn";

package/dist/runtime/functions/wrapFn.d.ts

@@ -1,2 +0,0 @@
-export declare const wrapFn: "NOT IMPLEMENTED";
-//# sourceMappingURL=wrapFn.d.ts.map

package/dist/runtime/functions/wrapFn.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"wrapFn.d.ts","sourceRoot":"","sources":["../../../src/runtime/functions/wrapFn.ts"],"names":[],"mappings":"AA+BA,eAAO,MAAM,MAAM,mBAA6B,CAAC"}