inferred-types 0.51.1 → 0.51.2

package/src/types/literals/Choices.ts

@@ -1,251 +0,0 @@
-/* eslint-disable no-use-before-define */
-import {
-  Dictionary,
-  If,
-  IsTrue,
-  HandleDoneFn,
-  AfterFirst,
-  First,
-  ExpandRecursively,
-  ShapeCallback,
-  AsString,
-  EmptyObject,
-  Scalar,
-  MergeObjects,
-  As,
-} from "inferred-types/dist/types/index";
-
-
-/**
- * **createChoice**(name, [value])
- *
- * Creates a "choice" for a Choice API. Values may be:
- *
- * - any `Scalar` value
- * - a callback of the form `s => s.literal(42)`
- * - or if left _undefined_ the value will be set to the name
- */
-export type CreateChoice = <
-  TName extends string,
-  TValue extends ChoiceValue
->(name: TName, value?: TValue) => Choice;
-
-export type ChoiceCallback = (cb: CreateChoice) => Choice;
-
-
-export type Choice<
-  K extends string = string,
-  V = unknown
-> = { name: K; value: V };
-
-export type ChoiceValue = ShapeCallback | Scalar | Dictionary | undefined;
-
-/**
- * **AsChoice**
- *
- * Converts a name/value pairing from createChoice() into a Choice.
- */
-export type AsChoice<
-  TName extends string = string,
-  TValue extends ChoiceValue = ChoiceValue
-> = [TValue] extends [ShapeCallback]
-? {name: TName; value: HandleDoneFn<ReturnType<TValue>>}
-: [TValue] extends [Scalar | Dictionary]
-  ? {name: TName; value: TValue }
-  : {name: TName; value: TName};
-
-type ProcessChoices<
-  T extends string | [string, Scalar] | Choice | ChoiceCallback
-> = T extends string
-? Choice<T,T>
-: T extends [string, Scalar]
-? Choice<T[0],T[1]>
-: T extends Choice
-? T
-: T extends ChoiceCallback
-? ReturnType<ChoiceCallback>
-: never;
-
-export type ToChoices<
-  T extends readonly (string | [string, Scalar] | Choice | ChoiceCallback)[]
-> = {
-  [K in keyof T]: ProcessChoices<T[K]>
-}
-
-export type ChoiceApiOptions = {
-  /**
-   * A choice may only be chosen once
-   */
-  unique: boolean;
-  max: number | null;
-  /**
-   * the API style as it's presented after configuration
-   */
-  style: "fn" | "object";
-}
-
-export type ChoiceApi<
-  _TChoices extends readonly Choice[],
-  _TOptions extends ChoiceApiOptions
-> = EmptyObject;
-
-
-export type ChoiceApiConfig<
-  TChoices extends readonly Choice[],
-  TOptions extends ChoiceApiOptions
-> = {
-  done: () => ChoiceApi<TChoices, TOptions>;
-  allowChoicesToBeUsedOnlyOnce: () => ChoiceApiConfig<
-    TChoices,
-    As<MergeObjects<TOptions, {unique: true}>, ChoiceApiOptions>
-  >;
-  /**
-   * configured choices can be _reused_ multiple times
-   */
-  allowChoicesToBeUsedMultipleTimes: () => ChoiceApiConfig<
-    TChoices,
-    As<MergeObjects<TOptions, {unique: false}>, ChoiceApiOptions>
-  >;
-  setStyle: <TStyle extends "fn" | "object">(style: TStyle) => ChoiceApiConfig<
-    TChoices,
-    As<MergeObjects<TOptions, {style: TStyle}>, ChoiceApiOptions>
-  >;
-  /**
-   * set a maximum number of choices that should be allowed
-   */
-  maximumChoices: <TMax extends number>(max: TMax) => ChoiceApiConfig<
-    TChoices,
-    As<MergeObjects<TOptions, {max: TMax}>, ChoiceApiOptions>
-  >;
-}
-
-
-
-// /**
-//  * **Choice**`<T>`
-//  *
-//  * Type utility which receives one of many _choice representations_
-//  * (from `ChoiceRepresentation`) and converts it into a simple key/value pair.
-//  */
-// export type Choice<
-//   T extends ChoiceRepresentation = ChoiceRepresentation
-// > = T extends {name: string; type: Fn}
-//   ? ReturnType<T["type"]> extends { done: Fn }
-//       ? Record<
-//           T["name"],
-//           ReturnType<ReturnType<T["type"]>["done"]>
-//         >
-//       : Record<T["name"], ReturnType<T["type"]>>
-
-//   : T extends {name: string; value: unknown}
-//     ? Record<T["name"], T["value"]>
-//   : T extends string
-//     ? Record<T,T>
-//   : T extends [name: string, value: unknown]
-//     ? If<
-//         IsFunction<T[1]>,
-//         Record<T[0], ReturnType<AsFunction<T[1]>>>,
-//         Record<T[0], T[1]>
-//       >
-//     : never;
-
-
-// type ToLookup<
-// TInput extends readonly (ChoiceRepresentation|AsChoice)[],
-// TOutput extends {[key:string]: unknown} = NonNullable<unknown>
-// > = [] extends TInput
-// ? ExpandRecursively<TOutput>
-// : ToLookup<
-//     AfterFirst<TInput>,
-//     First<TInput> extends ChoiceRepresentation
-//       ? AsChoice<First<TInput>> & TOutput
-//       : First<TInput> extends Record<string, unknown>
-//         ? First<TInput> & TOutput
-//         : never
-//   >
-
-// /**
-//  *  **Choices**`<TInput>`
-//  *
-//  * Converts an tuple of `ChoiceRepresentation` elements into a lookup table
-//  * of name/values.
-//  */
-// export type AsChoices<
-//   TInput extends readonly (ChoiceRepresentation|AsChoice)[] = readonly ChoiceRepresentation[],
-// > = ToLookup<TInput>;
-
-export type MultipleChoice<
-  TChoices extends Dictionary<string> = Dictionary<string>,
-  TForceUnique extends boolean = boolean,
-  TState extends readonly unknown[] = [],
-  TExclude extends string = never
-> = {
-  selected: TState;
-  forceUnique: TForceUnique;
-  choices: TChoices;
-  <T extends string & Exclude<keyof TChoices, TExclude>>(s: T ):
-    MultipleChoice<
-      TChoices,
-      TForceUnique,
-      [
-        ...TState,
-        T extends keyof TChoices
-          ? TChoices[T]
-          : never
-      ],
-      AsString<If<
-        IsTrue<TForceUnique>,
-        TExclude | T,
-        TExclude
-      >>
-    >;
-  /** return the selected choices */
-  done: () => TState;
-};
-
-/**
- * **MultiChoiceCallback**`<TApi>`
- *
- * Provides the typing so that you can easily incorporate a "choice"
- * as a parameter to your functions.
- *
- * It is intended to be used with the runtime utility `handleDoneFn()`
- * so that if a user doesn't terminate their callback with a call to
- * `.done()` then this is done for them.
- */
-export type MultiChoiceCallback<TApi extends MultipleChoice> = <
-  CB extends ((c: TApi) => unknown)
->(cb: CB) =>  HandleDoneFn<ReturnType<CB>>;
-
-
-type MergeKVs<
-  TInput extends readonly Dictionary[],
-  TOutput extends Dictionary = EmptyObject
-> = [] extends TInput
-  ? ExpandRecursively<TOutput>
-: MergeKVs<
-    AfterFirst<TInput>,
-    First<TInput> extends keyof TOutput
-    ? TOutput
-    : TOutput & First<TInput>
-  >;
-
-/**
- * **ChoiceBuilder**
- *
- * Builds a Choice API surface:
- */
-export type ChoiceBuilder= <
-  TChoices extends readonly Choice[]
->(...choices: TChoices) => ({
-  chooseMany: <
-    TForce extends boolean
-  >(force: TForce) =>
-  MultipleChoice<
-     MergeKVs<TChoices> extends Dictionary<string>
-     ? MergeKVs<TChoices>
-     : never,
-    TForce
-  >;
-});
-

package/src/types/literals/Color.ts

@@ -1,54 +0,0 @@
-
-// https://www.w3schools.com/colors/colors_groups.asp
-
-import { HexadecimalChar } from "inferred-types/dist/types/index";
-
-export type NamedColor_Pink = "Pink" | "LightPink" | "HotPink" | "DeepPink" | "PaleVioletRed" | "MediumVioletRed";
-export type NamedColor_Purple = "Lavender" | "Thistle" | "Plum" | "Orchid" | "Violet" | "Fuchsia" | "Magenta" | "MediumOrchid" | "DarkOrchid" | "DarkViolet" | "BlueViolet" | "DarkMagenta" | "Purple" | "MediumPurple" | "MediumSlateBlue" | "SlateBlue" | "DarkSlateBlue" | "RebeccaPurple" | "Indigo";
-export type NamedColor_Red = "LightSalmon" | "Salmon" | "DarkSalmon" | "LightCoral" | "IndianRed" | "Crimson" | "Red" | "FireBrick" | "DarkRed" | "Maroon";
-export type NamedColor_Orange = "Orange" | "DarkOrange" | "Coral" | "Tomato" | "OrangeRed";
-export type NamedColor_Yellow = "Gold" | "Yellow" | "LightYellow" | "LemonChiffon" | "LightGoldenRodYellow" | "PapayaWhip" | "Moccasin" | "PeachPuff" | "PaleGoldenRod" | "Khaki" | "DarkKhaki";
-export type NamedColor_Green = "GreenYellow" | "Chartreuse" | "LawnGreen" | "Lime" | "LimeGreen" | "PaleGreen" | "LightGreen" | "MediumSpringGreen" | "SpringGreen" | "MediumSpringGreen" | "SeaGreen" | "ForestGreen" | "Green" | "DarkGreen" | "YellowGreen" | "OliveDrab" | "DarkOliveGreen" | "MediumOliveGreen" | "MediumAquaMarine" | "DarkSeeGreen" | "LightSeaGreen" | "DarkCyan" | "Teal";
-export type NamedColor_Cyan = "Aqua" | "Cyan" | "LightCyan" | "PaleTurquoise" | "Aquamarine" | "Turquoise" | "MediumTurquoise" | "DarkTurquoise";
-export type NamedColor_Blue = "CadetBlue" | "SteelBlue" | "LightSteelBlue" | "LightBlue" | "PowerBlue" | "LightSkyBlue" | "SkyBlue" | "CornflowerBlue" | "DeepSkyBlue" | "DodgerBlue" | "RoyalBlue" | "Blue" | "MediumBlue" | "DarkBlue" | "MidnightBlue";
-export type NamedColor_Brown = "Cornsilk" | "BlanchedAlmond" | "Bisque" | "NavajoWhite" | "White" | "BurlyWood" | "Tan" | "RosyBrown" | "SandyBrown" | "GoldenRod" | "DarkGoldenRod" | "Peru" | "Chocolate" | "Olive" | "SaddleBrown" | "Sienna" | "Brown";
-export type NamedColor_White = "White" | "Snow" | "HoneyDew" | "MintCream" | "Azure" | "AliceBlue" | "GhostWhite" | "WhiteSmoke" | "SeaShell" | "Beige" | "OldLace" | "FloralWhite" | "Ivory" | "AntiqueWhite" | "Linen" | "LavenderBlush" | "MintyRose";
-export type NamedColor_Gray = "Gainsboro" | "LightGray" | "Silver" | "DarkGray" | "DimGray" | "Gray" | `LightSlateGray` | "SlateGray" | "DarkSlateGray" | "Black";
-
-/**
- * **NamedColor**
- *
- * Most if not all CSS/HTML _named_ colors
- */
-export type NamedColor = NamedColor_Gray | NamedColor_White | NamedColor_Brown | NamedColor_Blue | NamedColor_Cyan | NamedColor_Green | NamedColor_Yellow | NamedColor_Orange | NamedColor_Red | NamedColor_Purple | NamedColor_Pink;
-
-/**
- * **NamedColorMinimal**
- *
- * A minimal set of _named_ colors recognized by CSS and HTML.
- */
-export type NamedColorMinimal = "Gray" | "SlateGray" | "DarkSlateGray" | "Black" | "White" | "AliceBlue" | "WhiteSmoke" | "GhostWhite" | "Brown" | "Tan" | "Cornsilk" | "Blue" | "CadetBlue" | "SteelBlue" | "PowerBlue" | "DodgerBlue" | "DarkBlue" | "Cyan" | "Turquoise" | "Aquamarine" | "Teal" | "Gold" | "Yellow" | "LightYellow" | "Moccasin" | "Orange" | "DarkOrange" | "Tomato" | "Salmon" | "Red" | "FireBrick" | "DarkRed" | "Maroon" | "Plum" | "Violet" | "Purple" | "SlateBlue" | "DarkSlateBlue" | "Indigo";
-
-/**
- * **HexColor**
- *
- * A color value based in hexadecimal format
- */
-export type HexColor = `#${HexadecimalChar}${HexadecimalChar}${string}`;
-
-
-/**
- * **RgbColor**
- *
- * Type to enforce an `rgb()` color definition
- */
-export type RgbColor = `rgb(${string},${string},${string})`;
-
-
-/**
- * **RgbaColor**
- *
- * Type to enforce an `rgba()` color definition
- */
-export type RgbaColor = `rgba(${string},${string},${string},${string})`;
-

package/src/types/literals/ContainerBlockKey.ts

@@ -1,22 +0,0 @@
-import { Container,  Tuple } from "inferred-types/dist/types/index";
-
-
-/**
- * **ContainerBlockKey**`<TContainer,TKey>`
- *
- * Returns the `TContainer` value intersected with a guarantee that the
- * `TKey` key value exists.
- * ```ts
- * // { foo: 1; bar: unknown }
- * type TO = ContainerBlockKey<{foo: 1}, "bar">;
- * // number[] & readonly [unknown,unknown,unknown]
- * type TA = ContainerBlockKey<number[], 2>;
- * ```
- */
-export type ContainerBlockKey<
-  TContainer extends Container,
-  TKey extends PropertyKey
-> = TContainer extends Tuple
-  ? TContainer & [...Tuple<unknown, TKey & number>, never]
-  : Exclude<TContainer, TKey>;
-

package/src/types/literals/ContainerKeyGuarantee.ts

@@ -1,26 +0,0 @@
-import { Container, ExpandRecursively,  Tuple } from "inferred-types/dist/types/index";
-
-
-/**
- * **ContainerKeyGuarantee**`<TContainer,TKey,[TType]>`
- *
- * Returns the `TContainer` value intersected with a guarantee that the
- * `TKey` key value exists.
- * ```ts
- * // { foo: 1; bar: unknown }
- * type TO = ContainerKeyGuarantee<{foo: 1}, "bar">;
- * // number[] & readonly [unknown,unknown,unknown]
- * type TA = ContainerKeyGuarantee<number[], 2>;
- * ```
- *
- * - by default the guarantee is provided by assigning the `unknown`
- * type but you can override this by setting `TType`
- */
-export type ContainerKeyGuarantee<
-  TContainer extends Container,
-  TKey extends PropertyKey,
-  TType = unknown
-> = TContainer extends Tuple
-  ? TContainer & Readonly<[...Tuple<unknown, TKey & number>, TType]>
-  : ExpandRecursively<TContainer & Record<TKey, TType>>;
-

package/src/types/literals/DoneFnTuple.ts

@@ -1,31 +0,0 @@
-import { IsTrue, If, FnWithDescription, FnDefn, TupleToUnion, Narrow} from "inferred-types/dist/types/index";
-
-
-/**
- * **DoneFnTuple**`<[TTuple],[TMakeUnion],[TFns]>`
- *
- * This type utility quickly builds the types you'll need for an
- * API surface with the `done()` command returning the stored state
- * as either a **Tuple** or a **Union** of the tuple state.
- *
- * **Related:** `HasDoneFn`, `Narrow`, `DoneFnKv`, `createDoneTupleFn`
- */
-export type DoneFnTuple<
-TFns extends {[key: string]: FnDefn} = {
-  add: [
-    <TAdd extends Narrow>(a: TAdd) => boolean,
-    "add a value to the tuple/union"
-  ];
-},
-TMakeUnion extends boolean = false,
-TState extends readonly Narrow[] = Narrow[],
-> = {
-  [K in keyof TFns]: FnWithDescription<TFns[K]>
-} & {
-  state: TState;
-  type_as_union: TMakeUnion;
-  done: FnWithDescription<[
-    () => If<IsTrue<TMakeUnion>, TupleToUnion<TState>, TState>,
-    "exits the API surface with the state which has been accumulated so far"
-  ]>;
-}

package/src/types/literals/ExpandRecursively.ts

@@ -1,68 +0,0 @@
-/* eslint-disable no-use-before-define */
-import { AfterFirst, AnyFunction, AsLiteralFn, AsNarrowingFn, Decrement, Dictionary, First, FnProps, IsNarrowingFn, IsUnion, Tuple, TupleToUnion, TypedFunction, UnionToTuple } from "inferred-types/dist/types/index";
-
-type _ExpandTuple<
-  TLength extends number,
-  TContent extends Tuple,
-  TTuple extends Tuple = []
-> = TLength extends 0
-  ? Readonly<TTuple>
-  : _ExpandTuple<
-      Decrement<TLength>,
-      AfterFirst<TContent>,
-      [...TTuple, First<TContent>]
-  >;
-
-type ExpandParameters<
-  TFn extends TypedFunction,
-  TParams extends readonly unknown[],
-  TResults extends readonly unknown[] = []
-> = [] extends TParams
-? IsNarrowingFn<TFn> extends true
-  ? AsNarrowingFn<TResults,ReturnType<TFn>,ExpandDictionary<FnProps<TFn>>>
-  : AsLiteralFn<TResults,ReturnType<TFn>,ExpandDictionary<FnProps<TFn>>>
-: ExpandParameters<
-    TFn,
-    AfterFirst<TParams>,
-    [
-      ...TResults,
-      First<TParams> extends Dictionary
-        ? ExpandDictionary<First<TParams>>
-        : First<TParams>
-    ]
-  >;
-
-export type ExpandTuple<T> = T extends Tuple
-? _ExpandTuple<T["length"],T>
-: T;
-
-export type ExpandUnion<T> = IsUnion<T> extends true
-? TupleToUnion<
-    ExpandTuple<UnionToTuple<T>>
-  >
-: T
-;
-
-/**
- * Recursively goes over an object based structure and tries to reduce
- * it down to just a simple key/value type.
- */
-export type ExpandRecursively<T> = T extends Dictionary
-  ? { [K in keyof T]: T[K] extends AnyFunction
-      ? T[K] extends TypedFunction
-        ? ExpandParameters<T[K], Parameters<T[K]>>
-        : T[K]
-      : ExpandRecursively<T[K]>
-    }
-  : T;
-
-/**
- * Recursively goes over an object based structure and tries to reduce
- * it down to just a simple key/value type.
- */
-export type ExpandDictionary<T> = T extends Dictionary
-  ? { [K in keyof T]: T[K] extends AnyFunction
-      ? T[K]
-      : ExpandRecursively<T[K]>
-    }
-  : T;

package/src/types/literals/FromDefn.ts

@@ -1,151 +0,0 @@
-import { Constant } from "inferred-types/dist/constants/index";
-import { EmptyObject,
-  Dictionary,
-  ObjectKey,
-  Tuple,
-  IsEqual,
-  Contains,
-  Keys,
-  Values,
-  HandleDoneFn,
-  AfterFirst,
-  First,
-  AsDictionary,
-  TupleToUnion,
-  ExpandDictionary,
-  NarrowableScalar,
-  ShapeCallback,
-  UnionElDefn,
-  SimpleToken,
-  AsType
- } from "inferred-types/dist/types/index";
-
-type HandleObject<
-  TObj extends Dictionary,
-  TKeys extends readonly unknown[],
-  TResult extends Dictionary = EmptyObject
-> = [] extends TKeys
-? ExpandDictionary<TResult>
-: HandleObject<
-    TObj,
-    AfterFirst<TKeys>,
-    First<TKeys> extends keyof TObj
-      ? TObj[First<TKeys>] extends ShapeCallback
-        ? Record<
-            First<TKeys>,
-            HandleDoneFn<ReturnType< TObj[First<TKeys>] >>
-          > & TResult
-        : TObj[First<TKeys>] extends SimpleToken
-          ? Record<
-            First<TKeys>,
-            AsType<TObj[First<TKeys>]>
-          > & TResult
-          : Record<
-              First<TKeys>,
-              TObj[First<TKeys>]
-            > & TResult
-      : never
-  >;
-
-
-type ProcessUnion<
-  T extends UnionElDefn
-> = T extends Tuple
-    ? TupleToUnion<T>
-    : T extends ShapeCallback
-      ? HandleDoneFn<ReturnType<T>>
-        : never;
-type IterateUnion<T extends readonly UnionElDefn[]> = {
-  [K in keyof T]: ProcessUnion<T[K]>
-}
-
-/**
- * **AsUnion**
- *
- * Receives a `UnionTokenSet`, a `ShapeCallback` or just a tuple of values
- * and makes this into _union type_.
- */
-export type AsUnion<T extends UnionElDefn | readonly [UnionElDefn, ...UnionElDefn[]]> = T extends UnionElDefn[]
-? TupleToUnion<IterateUnion<T>>
-: T extends UnionElDefn
-? ProcessUnion<T>
-: never;
-
-export type IsDictionaryDefinition<T> = T extends Dictionary
-? Contains<Values<T>, ShapeCallback>
-: false;
-
-/**
- * converts non-tuple definition types to actual type
- */
-type ToType<
-  T,
-  TElse
-> = [T] extends [ShapeCallback]
-  ? HandleDoneFn<ReturnType<T>>
-: [IsDictionaryDefinition<T>] extends [true]
-  ? HandleObject<AsDictionary<T>, Keys<AsDictionary<T>>>
-: T extends SimpleToken
-  ? AsType<T>
-: IsEqual<TElse, Constant<"not-set">> extends true
-  ? T
-  : TElse extends SimpleToken
-    ? AsType<TElse>
-    : TElse;
-
-
-
-/**
- * iterates over tuple definition types to convert into real types
- */
-type IterateOverDefinitions<
-  T extends readonly unknown[],
-  TElse
-> = {
-  [K in keyof T]: ToType<T[K], TElse>;
-}
-
-export type TypeDefinition = NarrowableScalar | ShapeCallback;
-
-
-/**
- * **DictShapeDefn**`<T>`
- *
- * A _dictionary_ shape which provides direct value input or use of
- * the `ShapeCallback` API to any of the dictionaries values.
- *
- * Use of the generic `T` is not required but adding it as a separate
- * generic will increase the narrowness of your types.
- */
-export type DictTypeDefinition<
-  V extends TypeDefinition = TypeDefinition
-> = Record<
-  ObjectKey,
-  V
->;
-
-
-/**
- * **FromDefn**`<T, [TElse]>`
- *
- * Takes either a singular `T` or a tuple of values for `T` and
- * looks for any cases where a `ShapeCallback` is found:
- *
- * - where it is found, it will resolve the type
- * - if the type is a `SimpleToken` then this too is resolved
- * - in other cases it simply proxies the values through
- * - if `TElse` is set you can redirect values which don't use
- * the ShapeCallback API to a specific type.
- *
- * Note: when dictionary objects are found the _values_ will be
- * interrogated for ShapeCallback's.
- */
-export type FromDefn<
-  T,
-  TElse = Constant<"not-set">
-> = T extends readonly unknown[]
-? IterateOverDefinitions<T,TElse>
-: ToType<T,TElse>;
-
-
-

package/src/types/literals/FromTokenNames.ts

@@ -1,81 +0,0 @@
-import { ObjectKey } from "../base-types/ObjectKey";
-import { IsNever } from "../boolean-logic/operators/IsNever";
-
-export type WideTokenNames = "string" 
-| "number" 
-| "boolean" 
-| "null" 
-| "undefined" 
-| "never" 
-| "unknown" 
-| "string[]" 
-| "number[]" 
-| "boolean[]" 
-| "unknown[]";
-
-
-export type ConvertWideTokenNames<T extends WideTokenNames> = T extends "string"
-? string
-: T extends "number"
-? number
-: T extends "boolean"
-? boolean
-: T extends "null"
-? null
-: T extends "undefined"
-? undefined
-: T extends "never"
-? never
-: T extends "unknown"
-? unknown
-: T extends "string[]"
-? string[]
-: T extends "number[]"
-? number[]
-: T extends "boolean[]"
-? boolean[]
-: T extends "unknown[]"
-? unknown[]
-: never;
-
-
-export type WideContainerNames = "object"
-| "Dictionary"
-| "Map"
-| "Set"
-| "WeakMap";
-
-type ConvertWideContainerNames<T extends WideContainerNames> = T extends "object"
-? object
-: T extends "Dictionary"
-? Record<ObjectKey,unknown>
-: T extends "Map"
-? Map<unknown,unknown>
-: T extends "Set"
-? Set<unknown>
-: T extends "WeakMap"
-? WeakMap<object, unknown>
-: never;
-
-/**
- * **FromWideTokens**`<T, [TElse]>`
- * 
- * Looks for `WideContainerNames` or `WideTokenNames` and converts them to
- * the type they describe. If it is `T` is not any of these tokens it is
- * simply proxied through.
- * 
- * If you'd prefer to setup a different type for when no token is matched
- * you can add it under `TElse`.
- */
-export type FromWideTokens<
-  T,
-  TElse = never
-> = T extends WideTokenNames | WideContainerNames
-? T extends WideTokenNames
-  ? ConvertWideTokenNames<T>
-  : T extends WideContainerNames
-  ? ConvertWideContainerNames<T>
-  : never
-: IsNever<TElse> extends true
-  ? T
-  : TElse

package/src/types/literals/Narrow.ts

@@ -1,10 +0,0 @@
-import { Narrowable } from "./Narrowable";
-
-/**
- * **Narrow**
- * 
- * Just like the `Narrowable` type, this type is used in the _extends_
- * clause during runtime to extract the narrowest types possible. Unlike
- * the `Narrowable` type, **Narrow** _excludes_ **symbols**.
- */
-export type Narrow = Exclude<Narrowable, symbol>;