inferred-types 0.51.1 → 0.51.2

package/src/constants/Social.ts

@@ -1,131 +0,0 @@
-type SocialMediaCompany = {
-  name: string;
-  description: string;
-  baseUrls: string[];
-  profileUrl: string;
-  approximateUserSize?: number;
-  tickerSymbol?: string;
-};
-
-export const SOCIAL_MEDIA = [
-  {
-    name: "Facebook",
-    description: "Connect with friends, family, and communities worldwide on one of the largest social networks.",
-    baseUrls: ["https://www.facebook.com"],
-    profileUrl: "https://www.facebook.com/:user_id",
-    approximateUserSize: 3000000000, // 3 billion
-    tickerSymbol: "META",
-  },
-  {
-    name: "YouTube",
-    description: "A platform for sharing and watching videos, connecting creators with audiences globally.",
-    baseUrls: ["https://www.youtube.com"],
-    profileUrl: "https://www.youtube.com/user/:user_id",
-    approximateUserSize: 2500000000, // 2.5 billion
-    tickerSymbol: "GOOGL",
-  },
-  {
-    name: "WhatsApp",
-    description: "A secure messaging app for personal and business communication.",
-    baseUrls: ["https://www.whatsapp.com", "https://wa.me"],
-    profileUrl: "https://wa.me/:user_id",
-    approximateUserSize: 2000000000, // 2 billion
-    tickerSymbol: "META",
-  },
-  {
-    name: "Instagram",
-    description: "Share photos and videos with friends and followers through posts, stories, and reels.",
-    baseUrls: ["https://www.instagram.com"],
-    profileUrl: "https://www.instagram.com/:user_id",
-    approximateUserSize: 2000000000, // 2 billion
-    tickerSymbol: "META",
-  },
-  {
-    name: "TikTok",
-    description: "A short-form video platform known for its highly engaging content and viral trends.",
-    baseUrls: ["https://www.tiktok.com"],
-    profileUrl: "https://www.tiktok.com/@:user_id",
-    approximateUserSize: 1600000000, // 1.6 billion
-  },
-  {
-    name: "WeChat",
-    description: "China's popular messaging and lifestyle app, integrating social media and mobile payments.",
-    baseUrls: ["https://www.wechat.com"],
-    profileUrl: "https://www.wechat.com/:user_id", // Profile URLs typically restricted in China
-    approximateUserSize: 1300000000, // 1.3 billion
-  },
-  {
-    name: "Facebook Messenger",
-    description: "A messaging app used for personal and business interactions, seamlessly integrated with Facebook.",
-    baseUrls: ["https://www.messenger.com"],
-    profileUrl: "https://www.messenger.com/t/:user_id",
-    approximateUserSize: 1000000000, // 1 billion
-    tickerSymbol: "META",
-  },
-  {
-    name: "Telegram",
-    description: "A messaging platform focused on privacy, with channels and group capabilities.",
-    baseUrls: ["https://www.telegram.org", "https://t.me"],
-    profileUrl: "https://t.me/:user_id",
-    approximateUserSize: 900000000, // 900 million
-  },
-  {
-    name: "Snapchat",
-    description: "A multimedia app popular for its disappearing messages and creative filters.",
-    baseUrls: ["https://www.snapchat.com"],
-    profileUrl: "https://www.snapchat.com/add/:user_id",
-    approximateUserSize: 800000000, // 800 million
-    tickerSymbol: "SNAP",
-  },
-  {
-    name: "Douyin",
-    description: "The Chinese version of TikTok, with similar short-form video content tailored for China.",
-    baseUrls: ["https://www.douyin.com"],
-    profileUrl: "https://www.douyin.com/user/:user_id",
-    approximateUserSize: 750000000, // 750 million
-  },
-  {
-    name: "LinkedIn",
-    description: "The largest professional networking platform, where users connect for career opportunities, insights, and business networking.",
-    baseUrls: ["https://www.linkedin.com"],
-    profileUrl: "https://www.linkedin.com/in/:user_id",
-    approximateUserSize: 930000000, // 930 million
-    tickerSymbol: "MSFT",
-  },
-  {
-    name: "X (formerly Twitter)",
-    description: "A platform for real-time updates, news sharing, and public discourse with a focus on brief, impactful posts.",
-    baseUrls: ["https://www.twitter.com", "https://x.com"],
-    profileUrl: "https://twitter.com/:user_id",
-    approximateUserSize: 540000000, // 540 million
-  },
-  {
-    name: "Pinterest",
-    description: "A visually-driven platform for sharing ideas, DIY projects, fashion, and more.",
-    baseUrls: ["https://www.pinterest.com"],
-    profileUrl: "https://www.pinterest.com/:user_id",
-    approximateUserSize: 460000000, // 460 million
-    tickerSymbol: "PINS",
-  },
-  {
-    name: "Reddit",
-    description: "A community-driven platform organized into niche forums or 'subreddits' focused on various topics.",
-    baseUrls: ["https://www.reddit.com"],
-    profileUrl: "https://www.reddit.com/user/:user_id",
-    approximateUserSize: 430000000, // 430 million
-  },
-  {
-    name: "Clubhouse",
-    description: "A voice-based social network where users engage in live audio conversations on various topics.",
-    baseUrls: ["https://www.clubhouse.com"],
-    profileUrl: "https://www.clubhouse.com/:user_id",
-    approximateUserSize: 10000000, // 10 million
-  },
-  {
-    name: "Discord",
-    description: "Originally aimed at gamers, Discord is now widely used by various communities for group chat, video, and voice calls.",
-    baseUrls: ["https://www.discord.com", "https://discord.com"],
-    profileUrl: "https://discord.com/users/:user_id",
-    approximateUserSize: 300000000, // 300 million
-  }
-] as const satisfies SocialMediaCompany[];

package/src/constants/Tailwind.ts

@@ -1,92 +0,0 @@
-/**
- * **TW_COLOR_HUE**
- *
- * The _hue_ values for [TailwindCSS](https://tailwindcss.com/docs/customizing-colors)
- * when moved into the **oklch** color space.
- */
-export const TW_HUE = {
-  slate: 262,
-  gray: 270,
-  zinc: 269,
-  neutral: 270,
-  stone: 273,
-  red: 24,
-  orange: 44,
-  amber: 79,
-  yellow: 100,
-  lime: 132,
-  green: 144,
-  emerald: 159,
-  teal: 182,
-  cyan: 192,
-  sky: 219,
-  blue: 240,
-  indigo: 268,
-  violet: 283,
-  purple: 294,
-  fuchsia: 319,
-  pink: 334,
-  rose: 15,
-  black: 0,
-  white: 106.37411429114086
-} as const;
-
-export const TW_LUMINOSITY = {
-  "50": 97.78,
-  "100": 93.56,
-  "200": 88.11,
-  "300": 82.67,
-  "400": 74.22,
-  "500": 64.78,
-  "600": 57.33,
-  "700": 46.89,
-  "800": 39.44,
-  "900": 32,
-  "950": 23.78
-} as const;
-
-export const TW_LUMIN_50 = TW_LUMINOSITY["50"];
-export const TW_LUMIN_100 = TW_LUMINOSITY["100"];
-export const TW_LUMIN_200 = TW_LUMINOSITY["200"];
-export const TW_LUMIN_300 = TW_LUMINOSITY["300"];
-export const TW_LUMIN_400 = TW_LUMINOSITY["400"];
-export const TW_LUMIN_500 = TW_LUMINOSITY["500"];
-export const TW_LUMIN_600 = TW_LUMINOSITY["600"];
-export const TW_LUMIN_700 = TW_LUMINOSITY["700"];
-export const TW_LUMIN_800 = TW_LUMINOSITY["800"];
-export const TW_LUMIN_900 = TW_LUMINOSITY["900"];
-export const TW_LUMIN_950 = TW_LUMINOSITY["950"];
-
-/**
- * **TW_CHROMA**
- *
- * The possible chroma values from Tailwind CSS when using
- * the **okhsl** color model.
- *
- * **Related:** `TW_CHROMA_50`, `TW_CHROMA_100`, ...
- */
-export const TW_CHROMA = {
-  "50":  0.0108,
-  "100": 0.0321,
-  "200": 0.0609,
-  "300": 0.0908,
-  "400": 0.1398,
-  "500": 0.1472,
-  "600": 0.1299,
-  "700": 0.1067,
-  "800": 0.0898,
-  "900": 0.0726,
-  "950": 0.054
-} as const;
-
-export const TW_CHROMA_50 = TW_CHROMA["50"];
-export const TW_CHROMA_100 = TW_CHROMA["100"];
-export const TW_CHROMA_200 = TW_CHROMA["200"];
-export const TW_CHROMA_300 = TW_CHROMA["300"];
-export const TW_CHROMA_400 = TW_CHROMA["400"];
-export const TW_CHROMA_500 = TW_CHROMA["500"];
-export const TW_CHROMA_600 = TW_CHROMA["600"];
-export const TW_CHROMA_700 = TW_CHROMA["700"];
-export const TW_CHROMA_800 = TW_CHROMA["800"];
-export const TW_CHROMA_900 = TW_CHROMA["900"];
-export const TW_CHROMA_950 = TW_CHROMA["950"];

package/src/constants/TypeComparisons.ts

@@ -1,63 +0,0 @@
-import { WideAssignment } from "./Wide";
-
-type Scalar = string | number | boolean | null | symbol;
-type WideApi = typeof WideAssignment;
-const wide = WideAssignment as unknown as WideApi;
-
-const entry = <
-  TRefType extends ((kb: WideApi) => unknown),
-  TDesc extends string,
-  TParams extends readonly (Scalar | ((kb: WideApi) => unknown))[],
->(
-  refType: TRefType,
-  desc: TDesc,
-  ...params: TParams
-) => [
-  refType(wide as unknown as WideApi) as ReturnType<TRefType>,
-  desc as TDesc,
-  params.map(i => typeof (i) === "function"
-    ? i(wide)
-    : i
-  ) as unknown as TParams,
-] as [ReturnType<TRefType>, TDesc, TParams];
-
-/**
- * **TYPE_COMPARISONS**
- * 
- * A dictionary of all _comparison_ operations along with their `RefType`, description,
- * and `Params`.
- */
-export const TYPE_COMPARISONS = {
-  "Extends": entry(t => t.unknown(), "extends the type", t => t.unknown()),
-  "NotExtends": entry(t => t.unknown(), "does not extent the type", t => t.unknown()),
-  "Equals": entry(t => t.unknown(), "equals the type", t => t.unknown()),
-  "NotEqual": entry(t => t.unknown(), "does not equal the type", t => t.unknown()),
-  "Truthy": entry(t => t.unknown(), "must be a truthy value"),
-  "Falsy": entry(t => t.unknown(), "must be a falsy value"),
-  "IsSomething": entry(t => t.unknown(), "must be 'something' (aka, not null or undefined)"),
-  "IsNothing": entry(t => t.unknown(), "must be 'nothing' (aka, null or undefined)"),
-  "IsString": entry(t => t.string(), "must extend a string type"),
-  "IsNumber": entry(t => t.number(), "must extend a number type"),
-  "IsBoolean": entry(t => t.boolean(), "must extend a boolean type"),
-  // numeric
-  "GreaterThan": entry(t => t.number(), "must be a numeric literal greater than [[0]]", t => t.number()),
-  "LessThan": entry(t => t.number(), "must be a numeric literal less than [[0]]", t => t.number()),
-  // string
-  "StartsWith": entry(t => t.string(), "must be a string literal that starts with '[[0]]'", t => t.string()),
-  "EndsWith": entry(t => t.string(), "must be a string literal that ends with '[[0]]'", t => t.string()),
-  "Includes": entry(t => t.string(), "must be a string literal that includes the substring '[[0]]'", t => t.string()),
-  // function
-  "ReturnsSomething": entry(t => t.function(), "must be a function which returns 'something' (aka, not null or undefined)"),
-  "ReturnsNothing": entry(t => t.function(), "must be a function which returns 'nothing' (aka, null or undefined)"),
-  "ReturnsTrue": entry(t => t.function(), "must be a function which returns 'true'"),
-  "ReturnsFalse": entry(t => t.function(), "must be a function which returns 'false'"),
-  "ReturnsTruthy": entry(t => t.function(), "must be a function which returns a 'truthy' value"),
-  "ReturnsFalsy": entry(t => t.function(), "must be a function which returns a 'falsy' value"),
-  "ReturnsExtends": entry(t => t.unknown(), "must be a function which returns a value which extends [[0]]", t => t.unknown()),
-  "ReturnsEquals": entry(t => t.unknown(), "must be a function which returns a value which equals [[0]]", t => t.unknown()),
-  "Contains": entry(t => t.tuple(), "must be a tuple and have elements that extends the value [[0]]", t => t.unknown()),
-  // TODO: get the below working`
-  "ContainsSome": entry(t => t.tuple(), "must be a tuple and have elements that extends the value [[0]]", t => t.singularTuple()),
-
-
-} as const;

package/src/constants/TypeOf.ts

@@ -1,6 +0,0 @@
-/**
- * **TYPE_OF**
- * 
- * The set of values which are possible results of the `typeof` command in Javascript.
- */
-export const TYPE_OF = ["string", "number", "boolean", "undefined", "symbol", "bigint", "function", "object"] as const;

package/src/constants/TypeTokens.ts

@@ -1,291 +0,0 @@
-export const SIMPLE_DICT_VALUES = [
-  "string", "number", "boolean", "unknown",
-  "Opt<string>", "Opt<number>", "Opt<boolean>", "Opt<unknown>",
-] as const;
-
-export const SIMPLE_SET_TYPES = [
-  "string", "number", "boolean", "unknown",
-  "Opt<string>", "Opt<number>", "Opt<boolean>", "Opt<unknown>",
-] as const;
-
-
-export const SIMPLE_SCALAR_TOKENS = [
-  "string",
-  "number",
-  `string(TOKEN)` as `string(${string})`,
-  `number(TOKEN)` as `number(${number}${`,${string}` | ""})`,
-  "boolean",
-  "true",
-  "false",
-  "null",
-  "undefined",
-  "unknown",
-  "any",
-  "never"
-] as const;
-
-export const SIMPLE_OPT_SCALAR_TOKENS = [
-  "Opt<string>",
-  "Opt<number>",
-  "Opt<boolean>",
-  "Opt<true>",
-  "Opt<false>",
-  "Opt<null>",
-  "Opt<undefined>",
-  "Opt<unknown>",
-  "Opt<any>",
-  "Opt<string(TOKEN)>" as `Opt<string(${string}${`,${string}` | ""})>`,
-  "Opt<number(TOKEN)>" as `Opt<number(${number}${`,${string}` | ""})`,
-  "Opt<undefined>",
-] as const;
-
-
-export const SIMPLE_FN_TOKENS = [
-  "Fn<none> => Unknown",
-  "Fn<string> => Unknown",
-  "Fn<number> => Unknown",
-  "Fn<boolean> => Unknown",
-] as const;
-
-
-
-export const SIMPLE_UNION_TOKENS = [
-  `Union(TOKEN)` as `union(${string}${`,${string}` | ""})`
-] as const;
-
-
-export const SIMPLE_MAP_KEYS = [
-  "string",
-  "number",
-  "Dict",
-  "Dict<string, string>",
-  "Dict<string, number>",
-  "Dict<string, boolean>",
-  "Dict<string, unknown>",
-  "Dict<string, Opt<string>>",
-  "Dict<string, Opt<number>>",
-  "Dict<string, Opt<boolean>>",
-] as const;
-
-export const SIMPLE_MAP_VALUES = [
-  ...SIMPLE_MAP_KEYS,
-  "boolean",
-  "unknown",
-  "undefined",
-  "Dict",
-  "Array",
-  "Dict<string, Opt<string>>",
-  "Dict<string, Opt<number>>",
-  "Dict<string, Opt<boolean>>",
-  "Dict<string, Opt<unknown>>",
-] as const;
-
-type ReqScalarToken = typeof SIMPLE_SCALAR_TOKENS[number];
-type OptScalarToken = typeof SIMPLE_OPT_SCALAR_TOKENS[number];
-type ScalarToken = ReqScalarToken | OptScalarToken;
-type MapKeys = typeof SIMPLE_MAP_KEYS[number];
-type MapValues = typeof SIMPLE_MAP_VALUES[number];
-type SetType = typeof SIMPLE_SET_TYPES[number];
-
-export const SIMPLE_DICT_TOKENS = [
-  "Dict",
-  "Dict<string, string>",
-  "Dict<string, number>",
-  "Dict<string, boolean>",
-  "Dict<string, unknown>",
-  "Dict<string, Opt<string>>",
-  "Dict<string, Opt<number>>",
-  "Dict<string, Opt<boolean>>",
-  "Dict<string, Opt<unknown>>",
-  "Dict<{TOKEN: TOKEN}>" as `Dict<{${string}: ${ScalarToken}}>`,
-  "Dict<{TOKEN: TOKEN, TOKEN: TOKEN}>" as `Dict<{${string}: ${ScalarToken}, ${string}: ${string}}`,
-] as const;
-
-
-export const SIMPLE_ARRAY_TOKENS = [
-  "Array",
-  "Array<string>",
-  "Array<string(TOKEN)>" as `Array<string(${string})>`,
-  "Array<number>",
-  "Array<number(TOKEN)>" as `Array<number(${number}${`,${string}` | ""})>`,
-  "Array<boolean>",
-  "Array<unknown>",
-  `Array<Dict>`,
-  `Array<Set>`,
-  `Array<Map>`
-] as const;
-
-export const SIMPLE_MAP_TOKENS = [
-  "Map",
-  "Map<TOKEN, TOKEN>" as `Map<${MapKeys}, ${MapValues}>`,
-  "WeakMap"
-] as const;
-
-export const SIMPLE_SET_TOKENS = [
-  "Set",
-  "Set<TOKEN>" as `Set<${SetType}>`
-] as const;
-
-export const SIMPLE_CONTAINER_TOKENS = [
-  ...SIMPLE_DICT_TOKENS,
-  ...SIMPLE_ARRAY_TOKENS,
-  ...SIMPLE_MAP_TOKENS,
-  ...SIMPLE_SET_TOKENS
-] as const;
-
-
-
-
-/**
- * **SIMPLE_TOKENS**
- *
- * A list of strings literals which can be used
- * to express the type of a variable or token
- * in relatively course granularity
- */
-export const SIMPLE_TOKENS = [
-  ...SIMPLE_SCALAR_TOKENS,
-  ...SIMPLE_OPT_SCALAR_TOKENS,
-  ...SIMPLE_CONTAINER_TOKENS,
-  ...SIMPLE_UNION_TOKENS,
-] as const;
-
-
-/**
- * **Type Tokens** which have zero configuration elements.
- */
-export const TT_Atomics = [
-  "undefined",
-  "null",
-  "boolean",
-  "true",
-  "false"
-] as const;
-
-/**
- * **Type Tokens** which have a literal variant which represents
- * the _single_ configuration of this type which is available.
- */
-export const TT_Singletons = [
-  "string",
-  "number"
-] as const;
-
-export const TT_Sets = [
-  "string-set",
-  "numeric-set",
-  "union-set"
-] as const;
-
-/**
- * **Type Tokens** which represent _functions_ (either the typical
- * variety or Generator functions).
- */
-export const TT_Functions = [
-  "fn",
-  "gen"
-] as const;
-
-/**
- * **Type Tokens** which _contain_ other **Type Tokens** to make up their
- * identity.
- */
-export const TT_Containers = [
-  "rec",
-  "arr",
-  "set",
-  "map",
-  "union",
-  "obj",
-  "tuple"
-] as const;
-
-export const TT_START = "<<" as const;
-export const TT_STOP = ">>" as const;
-export const TT_SEP = "::" as const;
-
-/**
- * `TypeToken` names whose name provides the full definition
- * for the type.
- */
-export const TYPE_TOKEN_IDENTITIES = [
-  "string",
-  "number",
-  "numericString",
-  "booleanString",
-  "null",
-  "undefined",
-  "boolean",
-  "true",
-  "false",
-  "space",
-  "whitespace",
-  "object",
-  "emptyObject",
-  "function",
-  "array"
-] as const;
-
-/**
- * `TypeToken` names which need a _string_ parameter to fully qualify
- */
-export const TYPE_TOKEN_PARAM_STR = [
-  "explicitClass",
-  "startsWith",
-  "endsWith",
-  "ensureLeading",
-  "stripLeading",
-  "ensureTrailing",
-  "stripTrailing",
-  "camelCase",
-  "pascalCase",
-  "snakeCase",
-  "kebabCase",
-  "explicitType"
-] as const;
-
-
-/**
- * `TypeToken` names which need a _CSV_ parameter to fully qualify
- */
-export const TYPE_TOKEN_PARAM_CSV = [
-  "stringLiteral",
-  "numericLiteral",
-  "objectLiteral",
-  "tuple",
-  "union"
-] as const;
-
-/**
- * `TypeToken` names which need a _datetime_ parameter to fully qualify
- */
-export const TYPE_TOKEN_PARAM_DATETIME = [
-  "datetime",
-] as const;
-
-/**
- * `TypeToken` names which need a _datetime_ parameter to fully qualify
- */
-export const TYPE_TOKEN_PARAM_DATE = [
-  "ymd",
-  "monthThenDate",
-  "dateThenMonth"
-] as const;
-
-export const TYPE_TOKEN_PARAM_TIME = [
-  "timeInMinutes",
-  "timeInSeconds",
-  "militaryTimeInMinutes",
-  "militaryTimeInSeconds",
-  "militaryTimeInMilliseconds",
-  "civilianTimeInMinutes"
-] as const;
-
-export const TYPE_TOKEN_ALL = [
-  ...TYPE_TOKEN_IDENTITIES,
-  ...TYPE_TOKEN_PARAM_CSV,
-  ...TYPE_TOKEN_PARAM_DATE,
-  ...TYPE_TOKEN_PARAM_DATETIME,
-  ...TYPE_TOKEN_PARAM_STR,
-  ...TYPE_TOKEN_PARAM_TIME
-] as const;

package/src/constants/TypeTransforms.ts

@@ -1,47 +0,0 @@
-
-const t_unknown = "<<unknown>>" as unknown;
-const t_string = "<<string>>" as string;
-const t_number = "<<number>>" as unknown as number;
-const t_union_string_tuple = "<<union:string,tuple>>" as string | readonly unknown[];
-// const t_numeric_array = "<<numeric-array>>" as unknown as readonly (number | `${number}`)[];
-
-/**
- * **TYPE_TRANSFORMS**
- * 
- * A lookup table keyed with the available conversions `ConversionOp` and where
- * each row provides:
- * 
- * 1. Reference Type
- * 2. Parameters
- * 3. Description
- */
-export const TYPE_TRANSFORMS = {
-  Identity: [ t_unknown, [], "a transform which returns the same value passed in"],
-  ToNever: [ t_unknown, [], "converts all incoming types to the Never type"],
-  ToString: [ t_unknown, [], "ensures that any incoming type is converted to a string variant of that value"],
-  ToBoolean: [ t_unknown, [], "uses Javascript's \"truthiness\" to convert inputs to a boolean value; with functions it will use the return type"],
-  Trim: [ t_string, [], "Trims whitespace from start and end of string" ],
-  TrimStart: [ t_string, [], "Trims whitespace from start of string" ],
-  TrimEnd: [ t_string, [], "Trims whitespace from end of string" ],
-  Capitalize: [ t_string, [], "Converts a string input to a capitalized variant"],
-  UnCapitalize: [ t_string, [], "Converts a string input to a un-capitalized variant"],
-  AllCaps: [ t_string, [], "Converts a string input to all uppercase characters"],
-  Lowercase: [ t_string, [], "Converts a string input to all lowercase characters"],
-  ToCamelCase: [ t_string, [], "Converts a string to use the camelCase naming convention"],
-  ToKebabCase: [ t_string, [], "Converts a string to use the kebab-case naming convention"],
-  ToPascalCase: [ t_string, [], "Converts a string to use the PascalCase naming convention"],
-  ToSnakeCase: [ t_string, [], "Converts a string to use the snake_case naming convention"],
-  StripLeading: [ t_string, [t_string], "Strips a string literal from the beginning of a string (if it exists)"],
-  StripTrailing: [ t_string, [t_string], "Strips a string literal from the end of a string (if it exists)"],
-  EnsureLeading: [ t_string, [t_string], "Ensures a string literal is at the beginning of a string (with no change if it already was)"],
-  EnsureTrailing: [ t_string, [t_string], "Ensures a string literal is at the end of a string (with no change if it already was)"],
-  ToPlural: [ t_string, [], "Pluralizes a word"],
-  Surround: [ t_string, [t_string, t_string], "Surrounds a string literal with a pre and post character or set of characters"],
-  Prepend: [ t_union_string_tuple, [t_unknown], "Takes a string or tuple and prepends a value to the start."],
-  Append: [ t_union_string_tuple, [t_unknown], "Takes a string or tuple and appends a value to the end."],
-  Increment: [ t_number, [], "Increments a numeric value by one"],
-  Decrement: [ t_number, [], "Decrements a numeric value by one"],
-} as const; // satisfies Record<TransformOp, 
-
-
-

package/src/constants/Types.ts

@@ -1,32 +0,0 @@
-export const FALSY_TYPE_KINDS = [
-  "undefined", "null",
-] as const;
-
-export const LITERAL_TYPE_KINDS = [
-  "true", "false", "stringLiteral", "numericLiteral",
-] as const;
-
-export const WIDE_TYPE_KINDS = [
-  "string", "number", "boolean",
-] as const;
-
-export const NARROW_CONTAINER_TYPE_KINDS = [
-  "object", "explicitFunctions", "fnType", "fnWithDict",  "tuple", 
-  "union", "intersection", "arrayOf"
-] as const;
-
-export const WIDE_CONTAINER_TYPE_KINDS = [
-  "anyArray", "anyObject", "unknownObject", "anyFunction", "emptyObject"
-] as const;
-
-
-/**
- * A full list of the _types_ of types we have within the `Type` namespace.
- */
-export const TYPE_KINDS = [
-  ...FALSY_TYPE_KINDS,
-  ...WIDE_TYPE_KINDS,
-  ...LITERAL_TYPE_KINDS,
-  ...NARROW_CONTAINER_TYPE_KINDS,
-  ...WIDE_CONTAINER_TYPE_KINDS
-] as const;