inferred-types 0.43.1 → 0.43.2

package/dist/inferred-types/index.cjs

@@ -0,0 +1,2505 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/inferred-types/index.js
+var inferred_types_exports = {};
+__export(inferred_types_exports, {
+  ALPHA_CHARS: () => ALPHA_CHARS,
+  COMMA: () => COMMA,
+  COMMON_OBJ_PROPS: () => COMMON_OBJ_PROPS,
+  CONSONANTS: () => CONSONANTS,
+  DEFAULT_MANY_TO_ONE_MAPPING: () => DEFAULT_MANY_TO_ONE_MAPPING,
+  DEFAULT_ONE_TO_MANY_MAPPING: () => DEFAULT_ONE_TO_MANY_MAPPING,
+  DEFAULT_ONE_TO_ONE_MAPPING: () => DEFAULT_ONE_TO_ONE_MAPPING,
+  FALSY_TYPE_KINDS: () => FALSY_TYPE_KINDS,
+  FALSY_VALUES: () => FALSY_VALUES,
+  FILTER: () => FILTER,
+  HASH_TABLE_ALPHA_LOWER: () => HASH_TABLE_ALPHA_LOWER,
+  HASH_TABLE_ALPHA_UPPER: () => HASH_TABLE_ALPHA_UPPER,
+  HASH_TABLE_CHAR: () => HASH_TABLE_CHAR,
+  HASH_TABLE_DIGIT: () => HASH_TABLE_DIGIT,
+  HASH_TABLE_OTHER: () => HASH_TABLE_OTHER,
+  HASH_TABLE_SPECIAL: () => HASH_TABLE_SPECIAL,
+  HASH_TABLE_WIDE: () => HASH_TABLE_WIDE,
+  IPv4: () => IPv4,
+  IPv6: () => IPv6,
+  LITERAL_TYPE_KINDS: () => LITERAL_TYPE_KINDS,
+  LOWER_ALPHA_CHARS: () => LOWER_ALPHA_CHARS,
+  MARKED: () => MARKED,
+  MONTH_ABBR: () => MONTH_ABBR,
+  MONTH_NAME: () => MONTH_NAME,
+  MapCardinality: () => MapCardinality,
+  NARROW_CONTAINER_TYPE_KINDS: () => NARROW_CONTAINER_TYPE_KINDS,
+  NON_ZERO_NUMERIC_CHAR: () => NON_ZERO_NUMERIC_CHAR,
+  NOT_APPLICABLE: () => NOT_APPLICABLE,
+  NOT_DEFINED: () => NOT_DEFINED,
+  NO_DEFAULT_VALUE: () => NO_DEFAULT_VALUE,
+  NUMERIC_CHAR: () => NUMERIC_CHAR,
+  NUMERIC_DIGIT: () => NUMERIC_DIGIT,
+  Never: () => Never,
+  OPTION: () => OPTION,
+  PLURAL_EXCEPTIONS: () => PLURAL_EXCEPTIONS,
+  PLURAL_EXCEPTIONS_OLD: () => PLURAL_EXCEPTIONS_OLD,
+  RESULT: () => RESULT,
+  SHAPE_DELIMITER: () => SHAPE_DELIMITER,
+  SHAPE_PREFIXES: () => SHAPE_PREFIXES,
+  SINGULAR_NOUN_ENDINGS: () => SINGULAR_NOUN_ENDINGS,
+  ShapeApiImplementation: () => ShapeApiImplementation,
+  TT_Atomics: () => TT_Atomics,
+  TT_Containers: () => TT_Containers,
+  TT_Functions: () => TT_Functions,
+  TT_SEP: () => TT_SEP,
+  TT_START: () => TT_START,
+  TT_STOP: () => TT_STOP,
+  TT_Sets: () => TT_Sets,
+  TT_Singletons: () => TT_Singletons,
+  TYPE_COMPARISONS: () => TYPE_COMPARISONS,
+  TYPE_KINDS: () => TYPE_KINDS,
+  TYPE_OF: () => TYPE_OF,
+  TYPE_TOKEN_ALL: () => TYPE_TOKEN_ALL,
+  TYPE_TOKEN_IDENTITIES: () => TYPE_TOKEN_IDENTITIES,
+  TYPE_TOKEN_PARAM_CSV: () => TYPE_TOKEN_PARAM_CSV,
+  TYPE_TOKEN_PARAM_DATE: () => TYPE_TOKEN_PARAM_DATE,
+  TYPE_TOKEN_PARAM_DATETIME: () => TYPE_TOKEN_PARAM_DATETIME,
+  TYPE_TOKEN_PARAM_STR: () => TYPE_TOKEN_PARAM_STR,
+  TYPE_TOKEN_PARAM_TIME: () => TYPE_TOKEN_PARAM_TIME,
+  TYPE_TRANSFORMS: () => TYPE_TRANSFORMS,
+  UPPER_ALPHA_CHARS: () => UPPER_ALPHA_CHARS,
+  US_STATE_LOOKUP: () => US_STATE_LOOKUP,
+  US_STATE_LOOKUP_PROVINCES: () => US_STATE_LOOKUP_PROVINCES,
+  US_STATE_LOOKUP_STRICT: () => US_STATE_LOOKUP_STRICT,
+  WIDE_CONTAINER_TYPE_KINDS: () => WIDE_CONTAINER_TYPE_KINDS,
+  WIDE_TYPE_KINDS: () => WIDE_TYPE_KINDS,
+  WideAssignment: () => WideAssignment,
+  ZIP_TO_STATE: () => ZIP_TO_STATE,
+  addFnToProps: () => addFnToProps,
+  addPropsToFn: () => addPropsToFn,
+  and: () => and,
+  asArray: () => asArray,
+  asRecord: () => asRecord,
+  asString: () => asString,
+  asVueRef: () => asVueRef,
+  box: () => box,
+  boxDictionaryValues: () => boxDictionaryValues,
+  capitalize: () => capitalize,
+  choices: () => choices,
+  createConstant: () => createConstant,
+  createConverter: () => createConverter,
+  createErrorCondition: () => createErrorCondition,
+  createFnWithProps: () => createFnWithProps,
+  defineObj: () => defineObj,
+  defineTuple: () => defineTuple,
+  dict: () => dict,
+  endsWith: () => endsWith,
+  ensureLeading: () => ensureLeading,
+  ensureSurround: () => ensureSurround,
+  ensureTrailing: () => ensureTrailing,
+  entries: () => entries,
+  find: () => find,
+  fnMeta: () => fnMeta,
+  get: () => get,
+  getEach: () => getEach,
+  handleDoneFn: () => handleDoneFn,
+  hasDefaultValue: () => hasDefaultValue,
+  hasIndexOf: () => hasIndexOf,
+  hasKeys: () => hasKeys,
+  idLiteral: () => idLiteral,
+  idTypeGuard: () => idTypeGuard,
+  identity: () => identity,
+  ifArray: () => ifArray,
+  ifArrayPartial: () => ifArrayPartial,
+  ifBoolean: () => ifBoolean,
+  ifChar: () => ifChar,
+  ifContainer: () => ifContainer,
+  ifDefined: () => ifDefined,
+  ifFalse: () => ifFalse,
+  ifFunction: () => ifFunction,
+  ifHasKey: () => ifHasKey,
+  ifLength: () => ifLength,
+  ifLowercaseChar: () => ifLowercaseChar,
+  ifNotNull: () => ifNotNull,
+  ifNull: () => ifNull,
+  ifNumber: () => ifNumber,
+  ifObject: () => ifObject,
+  ifSameType: () => ifSameType,
+  ifScalar: () => ifScalar,
+  ifString: () => ifString,
+  ifTrue: () => ifTrue,
+  ifUndefined: () => ifUndefined,
+  ifUppercaseChar: () => ifUppercaseChar,
+  indexOf: () => indexOf,
+  intersect: () => intersect,
+  intersection: () => intersection,
+  ip6Prefix: () => ip6Prefix,
+  isArray: () => isArray,
+  isBoolean: () => isBoolean,
+  isBox: () => isBox,
+  isConstant: () => isConstant,
+  isContainer: () => isContainer,
+  isDefined: () => isDefined,
+  isDoneFn: () => isDoneFn,
+  isEqual: () => isEqual,
+  isErrorCondition: () => isErrorCondition,
+  isFalse: () => isFalse,
+  isFalsy: () => isFalsy,
+  isFnWithParams: () => isFnWithParams,
+  isFunction: () => isFunction,
+  isIndexable: () => isIndexable,
+  isLength: () => isLength,
+  isNever: () => isNever,
+  isNotNull: () => isNotNull,
+  isNothing: () => isNothing,
+  isNull: () => isNull,
+  isNumber: () => isNumber,
+  isNumericString: () => isNumericString,
+  isObject: () => isObject,
+  isReadonlyArray: () => isReadonlyArray,
+  isRef: () => isRef,
+  isSameTypeOf: () => isSameTypeOf,
+  isScalar: () => isScalar,
+  isShape: () => isShape,
+  isSpecificConstant: () => isSpecificConstant,
+  isString: () => isString,
+  isSymbol: () => isSymbol,
+  isTrue: () => isTrue,
+  isTruthy: () => isTruthy,
+  isTuple: () => isTuple,
+  isTypeOf: () => isTypeOf,
+  isTypeToken: () => isTypeToken,
+  isTypeTuple: () => isTypeTuple,
+  isUndefined: () => isUndefined,
+  join: () => join,
+  keysOf: () => keysOf,
+  kindError: () => kindError,
+  kindLiteral: () => kindLiteral,
+  last: () => last,
+  list: () => list,
+  literal: () => literal,
+  logicalReturns: () => logicalReturns,
+  lowercase: () => lowercase,
+  mergeObjects: () => mergeObjects,
+  mergeScalars: () => mergeScalars,
+  mergeTuples: () => mergeTuples,
+  nameLiteral: () => nameLiteral,
+  narrow: () => narrow,
+  never: () => never,
+  omit: () => omit,
+  optional: () => optional,
+  or: () => or,
+  parse: () => parse,
+  pathJoin: () => pathJoin,
+  pluralize: () => pluralize,
+  pop: () => pop,
+  result: () => result,
+  retain: () => retain,
+  retainAfter: () => retainAfter,
+  reverse: () => reverse,
+  shape: () => shape,
+  sharedKeys: () => sharedKeys,
+  shift: () => shift,
+  slice: () => slice,
+  split: () => split,
+  startsWith: () => startsWith,
+  stripAfter: () => stripAfter,
+  stripBefore: () => stripBefore,
+  stripLeading: () => stripLeading,
+  stripTrailing: () => stripTrailing,
+  surround: () => surround,
+  takeProp: () => takeProp,
+  toCamelCase: () => toCamelCase,
+  toKebabCase: () => toKebabCase,
+  toNumber: () => toNumber,
+  toNumericArray: () => toNumericArray,
+  toPascalCase: () => toPascalCase,
+  toSnakeCase: () => toSnakeCase,
+  toString: () => toString,
+  toUppercase: () => toUppercase,
+  trim: () => trim,
+  trimEnd: () => trimEnd,
+  trimLeft: () => trimLeft,
+  trimRight: () => trimRight,
+  trimStart: () => trimStart,
+  truncate: () => truncate,
+  tuple: () => tuple,
+  unbox: () => unbox,
+  uncapitalize: () => uncapitalize,
+  union: () => union2,
+  unionize: () => unionize,
+  unique: () => unique,
+  uniqueKeys: () => uniqueKeys,
+  uppercase: () => uppercase,
+  valuesOf: () => valuesOf,
+  widen: () => widen,
+  withDefaults: () => withDefaults,
+  withKeys: () => withKeys,
+  withoutKeys: () => withoutKeys,
+  withoutValue: () => withoutValue
+});
+module.exports = __toCommonJS(inferred_types_exports);
+
+// dist/constants/createConstant.js
+function createConstant(kind) {
+  return {
+    _type: "Constant",
+    kind
+  };
+}
+
+// dist/constants/NoDefaultValue.js
+var NO_DEFAULT_VALUE = createConstant("no-default-value");
+
+// dist/constants/NotApplicable.js
+var NOT_APPLICABLE = Symbol("not applicable");
+
+// dist/constants/DateTime.js
+var MONTH_NAME = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var MONTH_ABBR = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+
+// dist/constants/Types.js
+var FALSY_TYPE_KINDS = [
+  "undefined",
+  "null"
+];
+var LITERAL_TYPE_KINDS = [
+  "true",
+  "false",
+  "stringLiteral",
+  "numericLiteral"
+];
+var WIDE_TYPE_KINDS = [
+  "string",
+  "number",
+  "boolean"
+];
+var NARROW_CONTAINER_TYPE_KINDS = [
+  "object",
+  "explicitFunctions",
+  "fnType",
+  "fnWithDict",
+  "tuple",
+  "union",
+  "intersection",
+  "arrayOf"
+];
+var WIDE_CONTAINER_TYPE_KINDS = [
+  "anyArray",
+  "anyObject",
+  "unknownObject",
+  "anyFunction",
+  "emptyObject"
+];
+var TYPE_KINDS = [
+  ...FALSY_TYPE_KINDS,
+  ...WIDE_TYPE_KINDS,
+  ...LITERAL_TYPE_KINDS,
+  ...NARROW_CONTAINER_TYPE_KINDS,
+  ...WIDE_CONTAINER_TYPE_KINDS
+];
+
+// dist/constants/Comma.js
+var COMMA = createConstant("comma");
+
+// dist/constants/Functional.js
+var RESULT = {
+  Ok: "ok",
+  Err: "err"
+};
+var OPTION = {
+  Some: 1,
+  None: 0
+};
+
+// dist/constants/Alpha.js
+var LOWER_ALPHA_CHARS = [
+  "a",
+  "b",
+  "c",
+  "d",
+  "e",
+  "f",
+  "g",
+  "h",
+  "i",
+  "j",
+  "k",
+  "l",
+  "m",
+  "n",
+  "o",
+  "p",
+  "q",
+  "r",
+  "s",
+  "t",
+  "u",
+  "v",
+  "w",
+  "x",
+  "y",
+  "z"
+];
+var UPPER_ALPHA_CHARS = [
+  "A",
+  "B",
+  "C",
+  "D",
+  "E",
+  "F",
+  "G",
+  "H",
+  "I",
+  "J",
+  "K",
+  "L",
+  "M",
+  "N",
+  "O",
+  "P",
+  "Q",
+  "R",
+  "S",
+  "T",
+  "U",
+  "V",
+  "W",
+  "X",
+  "Y",
+  "Z"
+];
+var ALPHA_CHARS = [
+  ...LOWER_ALPHA_CHARS,
+  ...UPPER_ALPHA_CHARS
+];
+
+// dist/constants/Consonants.js
+var CONSONANTS = [
+  "b",
+  "c",
+  "d",
+  "f",
+  "g",
+  "h",
+  "j",
+  "k",
+  "l",
+  "m",
+  "n",
+  "p",
+  "q",
+  "r",
+  "s",
+  "t",
+  "v",
+  "w",
+  "x",
+  "z",
+  "y"
+];
+
+// dist/constants/PluralExceptions.js
+var PLURAL_EXCEPTIONS_OLD = [
+  ["photo", "photos"],
+  ["piano", "pianos"],
+  ["halo", "halos"],
+  ["foot", "feet"],
+  ["man", "men"],
+  ["woman", "women"],
+  ["person", "people"],
+  ["mouse", "mice"],
+  ["series", "series"],
+  ["sheep", "sheep"],
+  ["money", "monies"],
+  ["deer", "deer"]
+];
+var PLURAL_EXCEPTIONS = {
+  photo: "photos",
+  piano: "pianos",
+  halo: "halos",
+  foot: "feet",
+  man: "men",
+  woman: "women",
+  person: "people",
+  mouse: "mice",
+  series: "series",
+  sheep: "sheep",
+  money: "monies",
+  deer: "deer",
+  goose: "geese",
+  child: "children",
+  tooth: "teeth",
+  ox: "oxen",
+  basis: "bases",
+  radius: "radii",
+  syllabus: "syllabi",
+  ice: "ice",
+  fish: "fish",
+  means: "means",
+  phenomenon: "phenomena",
+  criterion: "criteria",
+  datum: "data",
+  memorandum: "memoranda",
+  bacterium: "bacteria",
+  stratum: "strata",
+  curriculum: "curricula",
+  index: "indices",
+  appendix: "appendices",
+  vortex: "vortices",
+  bison: "bison",
+  axis: "axes",
+  antenna: "antennas",
+  cactus: "cacti",
+  corpus: "corpora",
+  beau: "beaux",
+  die: "dice",
+  ellipsis: "ellipses",
+  erratum: "errata",
+  focus: "foci",
+  formula: "formulas",
+  fungus: "fungi",
+  genus: "genera",
+  graffito: "graffiti",
+  grouse: "grouses",
+  half: "halves",
+  hoof: "hooves",
+  hypothesis: "hypothesis",
+  larva: "larvae",
+  libretto: "libretti",
+  loaf: "loaves",
+  locus: "loci",
+  medium: "mediums",
+  minutia: "minutiae",
+  nucleus: "nuclei",
+  oasis: "oases",
+  opus: "opuses",
+  ovum: "ova",
+  parenthesis: "parentheses",
+  phylum: "phyla",
+  quiz: "quizzes",
+  referendum: "referendums",
+  self: "selves",
+  species: "species",
+  stimulus: "stimuli",
+  swine: "swine",
+  synopsis: "synopses",
+  thesis: "theses",
+  thief: "thieves",
+  vertex: "vertexes",
+  wife: "wives",
+  wolf: "wolves"
+};
+
+// dist/constants/SingularNounEnding.js
+var SINGULAR_NOUN_ENDINGS = [
+  "s",
+  "sh",
+  "ch",
+  "x",
+  "z",
+  "o"
+];
+
+// dist/constants/CommonObjProps.js
+var COMMON_OBJ_PROPS = [
+  "id",
+  "type",
+  "kind",
+  "_type",
+  "_kind",
+  "key",
+  "value",
+  "name"
+];
+
+// dist/constants/NumericChar.js
+var NUMERIC_CHAR = [
+  "0",
+  "1",
+  "2",
+  "3",
+  "4",
+  "5",
+  "6",
+  "7",
+  "8",
+  "9"
+];
+var NON_ZERO_NUMERIC_CHAR = [
+  "1",
+  "2",
+  "3",
+  "4",
+  "5",
+  "6",
+  "7",
+  "8",
+  "9"
+];
+
+// dist/constants/NumericDigit.js
+var NUMERIC_DIGIT = [
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9
+];
+
+// dist/constants/FalsyValues.js
+var FALSY_VALUES = [
+  false,
+  0,
+  -0,
+  "",
+  null,
+  void 0,
+  Number.NaN
+];
+
+// dist/constants/NotDefined.js
+var NOT_DEFINED = createConstant("not-defined");
+
+// dist/constants/TypeOf.js
+var TYPE_OF = ["string", "number", "boolean", "undefined", "symbol", "bigint", "function", "object"];
+
+// dist/constants/Wide.js
+var WideAssignment = {
+  boolean: () => "<<boolean>>",
+  string: () => "<<string>>",
+  number: () => "<<number>>",
+  symbol: () => "<<symbol>>",
+  null: () => "<<null>>",
+  function: () => "<<function>>",
+  tuple: () => "<<tuple>>",
+  singularTuple: () => ["<<tuple>>"],
+  object: () => "<<object>>",
+  emptyObject: () => "<<empty-object>>",
+  undefined: () => "<<undefined>>",
+  /**
+   * run-time value is a type token for `unknown` and type is of course `unknown`
+   */
+  unknown: () => "<<unknown>>",
+  nothing: () => "<<nothing>>",
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  something: () => "<<something>>"
+};
+
+// dist/constants/TypeComparisons.js
+var wide = WideAssignment;
+var entry = (refType, desc, ...params) => [
+  refType(wide),
+  desc,
+  params.map((i) => typeof i === "function" ? i(wide) : i)
+];
+var 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())
+};
+
+// dist/constants/TypeTransforms.js
+var t_unknown = "<<unknown>>";
+var t_string = "<<string>>";
+var t_number = "<<number>>";
+var t_union_string_tuple = "<<union:string,tuple>>";
+var 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"]
+};
+
+// dist/constants/Never.js
+var Never = createConstant("never");
+
+// dist/constants/TypeTokens.js
+var TT_Atomics = [
+  "undefined",
+  "null",
+  "boolean",
+  "true",
+  "false"
+];
+var TT_Singletons = [
+  "string",
+  "number"
+];
+var TT_Sets = [
+  "string-set",
+  "numeric-set",
+  "union-set"
+];
+var TT_Functions = [
+  "fn",
+  "gen"
+];
+var TT_Containers = [
+  "rec",
+  "arr",
+  "set",
+  "map",
+  "union",
+  "obj",
+  "tuple"
+];
+var TT_START = "<<";
+var TT_STOP = ">>";
+var TT_SEP = "::";
+var TYPE_TOKEN_IDENTITIES = [
+  "string",
+  "number",
+  "numericString",
+  "booleanString",
+  "null",
+  "undefined",
+  "boolean",
+  "true",
+  "false",
+  "space",
+  "whitespace",
+  "object",
+  "emptyObject",
+  "function",
+  "array"
+];
+var TYPE_TOKEN_PARAM_STR = [
+  "explicitClass",
+  "startsWith",
+  "endsWith",
+  "ensureLeading",
+  "stripLeading",
+  "ensureTrailing",
+  "stripTrailing",
+  "camelCase",
+  "pascalCase",
+  "snakeCase",
+  "kebabCase",
+  "explicitType"
+];
+var TYPE_TOKEN_PARAM_CSV = [
+  "stringLiteral",
+  "numericLiteral",
+  "objectLiteral",
+  "tuple",
+  "union"
+];
+var TYPE_TOKEN_PARAM_DATETIME = [
+  "datetime"
+];
+var TYPE_TOKEN_PARAM_DATE = [
+  "ymd",
+  "monthThenDate",
+  "dateThenMonth"
+];
+var TYPE_TOKEN_PARAM_TIME = [
+  "timeInMinutes",
+  "timeInSeconds",
+  "militaryTimeInMinutes",
+  "militaryTimeInSeconds",
+  "militaryTimeInMilliseconds",
+  "civilianTimeInMinutes"
+];
+var 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
+];
+
+// dist/constants/Shape.js
+var SHAPE_PREFIXES = [
+  "string",
+  "number",
+  "boolean",
+  "null",
+  "undefined",
+  "unknown",
+  "opt::",
+  "union::",
+  "tuple::",
+  "array::",
+  "object",
+  "record::"
+];
+var SHAPE_DELIMITER = "||,||";
+
+// dist/constants/Marked.js
+var MARKED = createConstant("Marked");
+
+// dist/constants/HashTable.js
+var HASH_TABLE_WIDE = {
+  string: "318",
+  number: "523",
+  boolean: "21",
+  never: "!!!",
+  unknown: "ed",
+  undefined: "ce",
+  null: "cc",
+  symbol: "78",
+  object: "fe8",
+  array: "17",
+  record: "ee",
+  map: "e65",
+  weakMap: "e64",
+  set: "f62",
+  union: "f61"
+};
+var HASH_TABLE_ALPHA_LOWER = {
+  "a": "8",
+  "b": "~",
+  "c": "^",
+  "d": ".",
+  "e": "82",
+  "f": "89",
+  "g": ",",
+  "h": "!",
+  "i": "-7",
+  "j": "-8",
+  "k": "88",
+  "l": "8f",
+  "m": "8e",
+  "n": "6e",
+  "o": "44",
+  "p": "60",
+  "q": "61",
+  "r": "71",
+  "s": ":",
+  "t": "-45",
+  "u": "-5",
+  "v": "-9",
+  "w": "-f",
+  "x": "+1",
+  "y": ";",
+  "z": "*1"
+};
+var HASH_TABLE_SPECIAL = {
+  "!": "1",
+  "@": "8",
+  "#": "5",
+  "$": "4",
+  "%": "3",
+  "^": "2",
+  "&": "9",
+  "*": "7",
+  "(": "6",
+  ")": "12",
+  "{": "33",
+  "}": "54",
+  "[": "x8",
+  "]": "y4",
+  ":": "z2",
+  ";": "e88",
+  '"': "c11",
+  "'": "c12",
+  "<": "p3",
+  ",": "45",
+  ">": "e9",
+  ".": "f2",
+  "?": "ee",
+  "/": "u9",
+  "\\": "f9",
+  "|": "q1",
+  "~": "fe",
+  "`": "8e"
+};
+var HASH_TABLE_DIGIT = {
+  "0": "-2",
+  "1": "-9",
+  "2": "ff",
+  "3": "fe",
+  "4": "2e",
+  "5": "cd",
+  "6": "54",
+  "7": "27",
+  "8": "49",
+  "9": "51"
+};
+var HASH_TABLE_ALPHA_UPPER = {
+  "A": "b8",
+  "B": "~9",
+  "C": "6^",
+  "D": ".8",
+  "E": "5<",
+  "F": ">7",
+  "G": "1,",
+  "H": "!7",
+  "I": "8#",
+  "J": "@9",
+  "K": "1*",
+  "L": "4&",
+  "M": "+5",
+  "N": "j|",
+  "O": "-l",
+  "P": "q{",
+  "Q": "]9",
+  "R": "f%",
+  "S": ":3",
+  "T": "?+",
+  "U": "}5",
+  "V": "'4",
+  "W": "1@g",
+  "X": "0+1",
+  "Y": "4;",
+  "Z": "a*1"
+};
+var HASH_TABLE_CHAR = {
+  ...HASH_TABLE_ALPHA_LOWER,
+  ...HASH_TABLE_ALPHA_UPPER,
+  ...HASH_TABLE_SPECIAL
+};
+var HASH_TABLE_OTHER = "999";
+
+// dist/constants/TCP_IP.js
+var IPv6 = {
+  "Loopback": "::1/128",
+  "Multicast": "ff00::/8",
+  "IPv4MappedAddresses": "::FFFF:0:0/96",
+  "Unicast": "fe80::/10",
+  "DocumentationAddresses": "2001:db8::/32"
+};
+var IPv4 = {
+  "Loopback": "127.0.0.1"
+};
+
+// dist/constants/Geo.js
+var US_STATE_LOOKUP_STRICT = [
+  { name: "Alabama", abbrev: "AL" },
+  { name: "Alaska", abbrev: "AK" },
+  { name: "Arizona", abbrev: "AZ" },
+  { name: "Arkansas", abbrev: "AR" },
+  { name: "California", abbrev: "CA" },
+  { name: "Colorado", abbrev: "CO" },
+  { name: "Connecticut", abbrev: "CT" },
+  { name: "Delaware", abbrev: "DE" },
+  { name: "Florida", abbrev: "FL" },
+  { name: "Georgia", abbrev: "GA" },
+  { name: "Hawaii", abbrev: "HI" },
+  { name: "Idaho", abbrev: "ID" },
+  { name: "Illinois", abbrev: "IL" },
+  { name: "Indiana", abbrev: "IN" },
+  { name: "Iowa", abbrev: "IA" },
+  { name: "Kansas", abbrev: "KS" },
+  { name: "Kentucky", abbrev: "KY" },
+  { name: "Louisiana", abbrev: "LA" },
+  { name: "Maine", abbrev: "ME" },
+  { name: "Maryland", abbrev: "MD" },
+  { name: "Massachusetts", abbrev: "MA" },
+  { name: "Michigan", abbrev: "MI" },
+  { name: "Minnesota", abbrev: "MN" },
+  { name: "Mississippi", abbrev: "MS" },
+  { name: "Missouri", abbrev: "MO" },
+  { name: "Montana", abbrev: "MT" },
+  { name: "Nebraska", abbrev: "NE" },
+  { name: "Nevada", abbrev: "NV" },
+  { name: "New Hampshire", abbrev: "NH" },
+  { name: "New Jersey", abbrev: "NJ" },
+  { name: "New Mexico", abbrev: "NM" },
+  { name: "New York", abbrev: "NY" },
+  { name: "North Carolina", abbrev: "NC" },
+  { name: "North Dakota", abbrev: "ND" },
+  { name: "Ohio", abbrev: "OH" },
+  { name: "Oklahoma", abbrev: "OK" },
+  { name: "Oregon", abbrev: "OR" },
+  { name: "Pennsylvania", abbrev: "PA" },
+  { name: "Rhode Island", abbrev: "RI" },
+  { name: "South Carolina", abbrev: "SC" },
+  { name: "South Dakota", abbrev: "SD" },
+  { name: "Tennessee", abbrev: "TN" },
+  { name: "Texas", abbrev: "TX" },
+  { name: "Utah", abbrev: "UT" },
+  { name: "Vermont", abbrev: "VT" },
+  { name: "Virginia", abbrev: "VA" },
+  { name: "Washington", abbrev: "WA" },
+  { name: "West Virginia", abbrev: "WV" },
+  { name: "Wisconsin", abbrev: "WI" },
+  { name: "Wyoming", abbrev: "WY" }
+];
+var US_STATE_LOOKUP_PROVINCES = [
+  { name: "Puerto Rico", abbrev: "PR" },
+  { name: "Virgin Islands", abbrev: "VI" },
+  { name: "Palau", abbrev: "PW" },
+  { name: "Federated States of Micronesia", abbrev: "FM" },
+  { name: "Northern Mariana Islands", abbrev: "MP" },
+  { name: "District of Columbia", abbrev: "DC" },
+  { name: "Marshall Islands", abbrev: "MH" },
+  { name: "American Samoa", abbrev: "AS" },
+  { name: "Guam", abbrev: "GU" }
+];
+var US_STATE_LOOKUP = [
+  ...US_STATE_LOOKUP_STRICT,
+  ...US_STATE_LOOKUP_PROVINCES
+];
+var ZIP_TO_STATE = {
+  "0": ["CT", "MA", "ME", "NH", "NJ", "NY", "PR", "RI", "VT", "VI"],
+  "1": ["DE", "NY", "PA"],
+  "2": ["DC", "MD", "NC", "SC", "VA", "WV"],
+  "3": ["AL", "FL", "GA", "MS", "TN"],
+  "4": ["IN", "KY", "MI", "OH"],
+  "5": ["IA", "MN", "MT", "ND", "SD", "WI"],
+  "6": ["IL", "KS", "MO", "NE"],
+  "7": ["AR", "LA", "OK", "TX"],
+  "8": ["AZ", "CO", "ID", "NM", "NV", "UT", "WY"],
+  "9": ["AK", "AS", "CA", "GU", "HI", "MH", "FM", "MP", "OR", "PW", "WA"]
+};
+
+// dist/types/dictionary/MapTo.js
+var toFinalizedConfig = (config) => {
+  return { ...config, finalized: true };
+};
+var DEFAULT_ONE_TO_MANY_MAPPING = toFinalizedConfig({
+  input: "req",
+  output: "opt",
+  cardinality: "I -> O[]"
+});
+var DEFAULT_ONE_TO_ONE_MAPPING = toFinalizedConfig({
+  input: "req",
+  output: "req",
+  cardinality: "I -> O"
+});
+var DEFAULT_MANY_TO_ONE_MAPPING = toFinalizedConfig({
+  input: "req",
+  output: "req",
+  cardinality: "I[] -> O"
+});
+var MapCardinality;
+(function(MapCardinality2) {
+  MapCardinality2["OneToMany"] = "I -> O[]";
+  MapCardinality2["OneToOne"] = "I -> O";
+  MapCardinality2["ManyToOne"] = "I[] -> O";
+})(MapCardinality || (MapCardinality = {}));
+
+// dist/runtime/boolean-logic/ifArray.js
+function ifArray(val, isAnArray, isNotAnArray) {
+  return Array.isArray(val) ? isAnArray(val) : isNotAnArray(val);
+}
+
+// dist/runtime/boolean-logic/ifBoolean.js
+function ifBoolean(val, ifBoolean2, notBoolean) {
+  return isBoolean(val) ? ifBoolean2(val) : notBoolean(val);
+}
+
+// dist/runtime/boolean-logic/ifNumber.js
+function ifNumber(val, ifVal, elseVal) {
+  return isNumber(val) ? ifVal(val) : elseVal(val);
+}
+
+// dist/runtime/boolean-logic/ifString.js
+function ifString(val, ifVal, elseVal) {
+  return isString(val) ? ifVal(val) : elseVal(val);
+}
+
+// dist/runtime/boolean-logic/ifNotNull.js
+function ifNotNull(val, ifVal, elseVal) {
+  return isNull(val) ? elseVal() : ifVal(val);
+}
+
+// dist/runtime/boolean-logic/ifSameType.js
+function ifSameType(value, comparator, same, notSame) {
+  return (
+    // runtime values match
+    typeof value === typeof comparator ? same(value) : notSame(value)
+  );
+}
+
+// dist/runtime/boolean-logic/ifFunction.js
+function ifFunction(value, isFnCallback, notFnCallback) {
+  return isFunction(value) ? isFnCallback(value) : notFnCallback(value);
+}
+
+// dist/runtime/boolean-logic/ifContainer.js
+function ifContainer(value, ifContainer2, notContainer) {
+  return isObject(value) || isArray(value) ? ifContainer2(value) : notContainer(value);
+}
+
+// dist/runtime/boolean-logic/ifHasKey.js
+var ifHasKey = (container, key, hasKey, doesNotHaveKey) => hasIndexOf(container, key) ? hasKey(container) : doesNotHaveKey(container);
+
+// dist/runtime/boolean-logic/ifLength.js
+function ifLength(value, length, ifVal, elseVal) {
+  return Array.isArray(value) && value.length === length ? ifVal(value) : elseVal(value);
+}
+
+// dist/runtime/boolean-logic/ifScalar.js
+function ifScalar(value, ifCallback, notCallback) {
+  const result2 = isScalar(value) ? ifCallback(value) : notCallback(value);
+  return result2;
+}
+
+// dist/runtime/boolean-logic/ifNull.js
+function ifNull(val, ifVal, elseVal) {
+  return isNull(val) ? ifVal() : elseVal(val);
+}
+
+// dist/runtime/boolean-logic/ifObject.js
+function ifObject(val, ifObj, notObj) {
+  return isObject(val) ? ifObj : notObj;
+}
+
+// dist/runtime/boolean-logic/ifTrue.js
+function ifTrue(val, ifVal, elseVal) {
+  return (
+    //
+    isTrue(val) ? ifVal(val) : elseVal(val)
+  );
+}
+
+// dist/runtime/boolean-logic/ifFalse.js
+function ifFalse(val, ifVal, elseVal) {
+  return isFalse(val) ? ifVal : elseVal;
+}
+
+// dist/runtime/boolean-logic/ifChar.js
+var def_if = (v) => v;
+var def_else = () => Never;
+function ifChar(ch, callback_if_match = def_if, callback_not_match = def_else) {
+  return ch.length === 1 ? callback_if_match(ch) : callback_not_match(ch);
+}
+
+// dist/runtime/type-guards/isDefined.js
+function isDefined(value) {
+  return typeof value === "undefined" ? false : true;
+}
+
+// dist/runtime/type-guards/isFalsy.js
+var isFalsy = (val) => {
+  return FALSY_VALUES.includes(val);
+};
+
+// dist/runtime/type-guards/isNull.js
+function isNull(value) {
+  return value === null ? true : false;
+}
+
+// dist/runtime/type-guards/isNotNull.js
+function isNotNull(value) {
+  return value === null ? true : false;
+}
+
+// dist/runtime/type-guards/isTruthy.js
+var isTruthy = (val) => {
+  return !FALSY_VALUES.includes(val);
+};
+
+// dist/runtime/type-guards/isTypeTuple.js
+function isTypeTuple(value) {
+  return Array.isArray(value) && value.length === 3 && typeof value[1] === "function";
+}
+
+// dist/runtime/type-guards/isUndefined.js
+function isUndefined(value) {
+  return typeof value === "undefined" ? true : false;
+}
+
+// dist/runtime/type-guards/isBoolean.js
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+
+// dist/runtime/type-guards/isString.js
+function isString(value) {
+  return typeof value === "string";
+}
+
+// dist/runtime/type-guards/isIndexable.js
+function isIndexable(value) {
+  return Array.isArray(value) || typeof value === "object" && keysOf(value).length > 0 ? true : false;
+}
+
+// dist/runtime/type-guards/isObject.js
+function isObject(value) {
+  return typeof value === "object" && value !== null && Array.isArray(value) === false;
+}
+
+// dist/runtime/type-guards/isTrue.js
+function isTrue(value) {
+  return value === true;
+}
+
+// dist/runtime/type-guards/isArray.js
+function isArray(value) {
+  return Array.isArray(value) === true;
+}
+
+// dist/runtime/type-guards/isConstant.js
+function isConstant(value) {
+  return isObject(value) && "_type" in value && isTypeOf("string")(value._type) && isEqual(value._type)("Constant") ? true : false;
+}
+
+// dist/runtime/type-guards/isNever.js
+var isNever = (val) => {
+  return isConstant(val) && val.kind === "never";
+};
+
+// dist/runtime/type-guards/isContainer.js
+function isContainer(value) {
+  return Array.isArray(value) || isObject(value) ? true : false;
+}
+
+// dist/runtime/type-guards/higher-order/isSameTypeOf.js
+var isSameTypeOf = (base) => (compare) => {
+  return typeof base === typeof compare;
+};
+
+// dist/runtime/type-guards/higher-order/isEqual.js
+var isEqual = (base) => (value) => isSameTypeOf(base)(value) ? value === base ? true : false : false;
+
+// dist/runtime/type-guards/isSpecificConstant.js
+function isSpecificConstant(kind) {
+  return (value) => {
+    return isConstant(value) && isEqual(value.kind)(kind) ? true : false;
+  };
+}
+
+// dist/runtime/type-guards/isReadonlyArray.js
+function isReadonlyArray(value) {
+  return Array.isArray(value) === true;
+}
+
+// dist/runtime/type-guards/hasIndexOf.js
+var hasIndexOf = (value, idx) => {
+  const result2 = isObject(value) ? String(idx) in value : Array.isArray(value) ? Number(idx) in value : false;
+  return isErrorCondition(result2, "invalid-index") ? false : result2;
+};
+
+// dist/runtime/type-guards/isRef.js
+function isRef(value) {
+  return isObject(value) && "value" in value && Array.from(Object.keys(value)).includes("_value");
+}
+
+// dist/runtime/type-guards/isFalse.js
+function isFalse(i) {
+  return typeof i === "boolean" && !i;
+}
+
+// dist/runtime/type-guards/hasDefaultValue.js
+function hasDefaultValue(value) {
+  const noDefault = isSpecificConstant("no-default-value");
+  return noDefault(value) ? false : true;
+}
+
+// dist/runtime/literals/split.js
+function split(str, sep = "") {
+  return str.split(sep);
+}
+
+// dist/runtime/type-guards/isNumericString.js
+function isNumericString(value) {
+  const validChars = [...NUMERIC_CHAR, "x", "E"];
+  return typeof value === "string" && split(value).every((i) => validChars.includes(i));
+}
+
+// dist/runtime/type-guards/isFnWithParams.js
+function isFnWithParams(input) {
+  var _a;
+  return typeof input === "function" && ((_a = Object.keys(input)) == null ? void 0 : _a.length) > 0;
+}
+
+// dist/runtime/type-guards/isFunction.js
+function isFunction(value) {
+  return typeof value === "function" ? true : false;
+}
+
+// dist/runtime/type-guards/isNumber.js
+function isNumber(value) {
+  return typeof value === "number";
+}
+
+// dist/runtime/type-guards/isNothing.js
+function isNothing(val) {
+  return val === null || val === void 0 ? true : false;
+}
+
+// dist/runtime/type-guards/isSymbol.js
+function isSymbol(value) {
+  return typeof value === "symbol";
+}
+
+// dist/runtime/type-guards/isScalar.js
+function isScalar(value) {
+  return isString(value) || isNumber(value) || isSymbol(value) || isNull(value);
+}
+
+// dist/runtime/type-guards/isTypeToken.js
+function isTypeToken(val) {
+  if (isString(val) && startsWith("<<")(val) && endsWith(">>")(val)) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+// dist/runtime/type-guards/isErrorCondition.js
+function isErrorCondition(value, kind = null) {
+  return isObject(value) && "__kind" in value && value.__kind === "ErrorCondition" && "kind" in value ? kind !== null ? value["kind"] === kind : true : false;
+}
+
+// dist/runtime/type-guards/hasKeys.js
+var hasKeys = (...props) => (
+  /**
+   * Type guard which validates whether the configured properties
+   * exist on a given `Record<ObjectKey, unknown` and if they do at
+   * runtime will provide the type support for them.
+   */
+  (val) => {
+    const keys = Array.isArray(props) ? props : Object.keys(props).filter((i) => typeof i === "string");
+    return (isFunction(val) || isObject(val)) && keys.every((k) => k in val) ? true : false;
+  }
+);
+
+// dist/runtime/type-guards/isDoneFn.js
+var isDoneFn = (val) => {
+  return hasKeys("done")(val) && typeof val.done === "function";
+};
+
+// dist/runtime/type-guards/higher-order/endsWith.js
+var endsWith = (endingIn2) => (val) => {
+  return ifString(val, (v) => v.endsWith(endingIn2) ? true : false, (v) => ifNumber(v, (n) => String(n).endsWith(endingIn2) ? true : false, () => false));
+};
+
+// dist/runtime/type-guards/higher-order/startsWith.js
+var startsWith = (startingWith) => (val) => {
+  return isString(val) ? val.startsWith(startingWith) ? true : false : isNumber(val) ? String(val).startsWith(startingWith) ? true : false : false;
+};
+
+// dist/runtime/type-guards/higher-order/isLength.js
+function isLength(value, len) {
+  return isArray(value) ? isEqual(value.length)(len) ? true : false : isString(value) ? isEqual(value.length)(len) ? true : false : isObject(value) ? isEqual(keysOf(value))(len) ? true : false : false;
+}
+
+// dist/runtime/type-guards/higher-order/isTypeOf.js
+var isTypeOf = (type) => (value) => {
+  return typeof value === type;
+};
+
+// dist/runtime/type-guards/higher-order/isTuple.js
+var isTuple = (...tuple3) => {
+  const results = tuple3.map((i) => i(ShapeApiImplementation)).map((i) => isDoneFn(i) ? i.done() : i);
+  return (v) => {
+    return isArray(v) && v.length === results.length && results.every(isShape) && v.every((item, idx) => isSameTypeOf(results[idx])(item));
+  };
+};
+
+// dist/runtime/boolean-logic/ifUndefined.js
+function ifUndefined(val, ifUndefined2, ifDefined2) {
+  return isUndefined(val) ? ifUndefined2() : ifDefined2(val);
+}
+function ifDefined(val, ifVal, elseVal) {
+  return isDefined(val) ? ifVal : elseVal;
+}
+
+// dist/runtime/boolean-logic/ifArrayPartial.js
+function ifArrayPartial() {
+  return (isAnArray, isNotAnArray) => {
+    return (val) => ifArray(val, isAnArray, isNotAnArray);
+  };
+}
+
+// dist/runtime/boolean-logic/handleDoneFn.js
+var handleDoneFn = (val, call_bare_fn = false) => {
+  return isObject(val) || isFunction(val) ? isDoneFn(val) ? val.done() : isFunction(val) ? call_bare_fn ? val() : val : val : isFunction(val) ? call_bare_fn ? val() : val : val;
+};
+
+// dist/runtime/combinators/and.js
+var and = (...values) => {
+  return values.every((i) => i === true);
+};
+
+// dist/runtime/combinators/or.js
+function or(...conditions) {
+  const values = conditions.some((v) => v === true ? true : false);
+  return values;
+}
+
+// dist/runtime/dictionary/keysOf.js
+function keysOf(container) {
+  const keys = Array.isArray(container) ? Object.keys(container).map((i) => Number(i)) : isObject(container) ? isRef(container) ? ["value"] : Object.keys(container) : [];
+  return keys;
+}
+
+// dist/runtime/dictionary/entries.js
+function entries(obj) {
+  const iterable = {
+    *[Symbol.iterator]() {
+      for (const k of keysOf(obj)) {
+        yield [k, obj[k]];
+      }
+    }
+  };
+  return iterable;
+}
+
+// dist/runtime/dictionary/get.js
+function updatedDotPath(value, dotpath, segment) {
+  return isRef(value) ? dotpath.replace(segment, `Ref(${segment})`) : dotpath;
+}
+function getValue(value, dotPath, defaultValue, handleInvalid, fullDotPath) {
+  const pathSegments = isTruthy(dotPath) ? dotPath.split(".") : [];
+  const idx = pathSegments[0];
+  const hasMoreSegments = pathSegments.length > 1;
+  const valueIsIndexable = isContainer(value) && hasIndexOf(value, idx);
+  const hasHandler = !isSpecificConstant("not-defined")(handleInvalid);
+  const invalidDotPath = createErrorCondition("invalid-dot-path", `The segment "${idx}" in the dotpath "${fullDotPath}" was not indexable and no default value existed on: ${JSON.stringify(value)}`);
+  const current = hasMoreSegments ? isContainer(value) && idx in value ? getValue(indexOf(value, idx), pathSegments.join(".").replace(`${idx}.`, ""), defaultValue, handleInvalid, updatedDotPath(value, fullDotPath, idx)) : hasHandler ? handleInvalid : invalidDotPath : valueIsIndexable ? hasDefaultValue(hasDefaultValue) ? indexOf(value, idx) || defaultValue : indexOf(value, idx) : hasHandler ? handleInvalid : invalidDotPath;
+  return current;
+}
+function get(value, dotPath, options = {
+  defaultValue: NO_DEFAULT_VALUE,
+  handleInvalidDotpath: NOT_DEFINED
+}) {
+  const outcome = dotPath === null || dotPath === "" ? value : getValue(value, dotPath, (options == null ? void 0 : options.defaultValue) || NO_DEFAULT_VALUE, (options == null ? void 0 : options.handleInvalidDotpath) || NOT_DEFINED, String(dotPath));
+  return outcome;
+}
+
+// dist/runtime/dictionary/omit.js
+function omit(obj, ...removeKeys) {
+  const keys = Object.keys(obj);
+  return keys.reduce((acc, key) => removeKeys.includes(key) ? acc : {
+    ...acc,
+    [key]: obj[key]
+  }, {});
+}
+
+// dist/runtime/dictionary/retain.js
+var retain = (dict2, ...keys) => {
+  let output = {};
+  for (const k of keys) {
+    output = {
+      ...output,
+      [k]: dict2[k]
+    };
+  }
+  return output;
+};
+
+// dist/runtime/dictionary/sharedKeys.js
+var sharedKeys = (a, b) => {
+  const ka = Object.keys(a);
+  const kb = Object.keys(b);
+  return ka.filter((k) => kb.includes(k));
+};
+
+// dist/runtime/dictionary/takeProp.js
+var takeProp = (val, prop, otherwise) => {
+  return (isObject(val) || isArray(val)) && prop in val ? val[prop] : otherwise;
+};
+
+// dist/runtime/dictionary/withKeys.js
+var withKeys = (dict2, ...keys) => retain(dict2, ...keys);
+
+// dist/runtime/dictionary/withoutKeys.js
+var withoutKeys = (dict2, ...exclude) => omit(dict2, ...exclude);
+
+// dist/runtime/dictionary/withoutValue.js
+function withoutValue(val) {
+  return (obj) => {
+    return Object.keys(obj).reduce((acc, key) => val === obj[key] ? acc : { ...acc, [key]: obj[key] }, {});
+  };
+}
+
+// dist/runtime/dictionary/withDefaults.js
+var withDefaults = (with_defaults) => (obj) => {
+  const merged = {
+    ...with_defaults,
+    ...obj
+  };
+  return merged;
+};
+
+// dist/runtime/dictionary/valuesOf.js
+var valuesOf = (obj) => {
+  const values = [];
+  for (const k of Object.keys(obj)) {
+    values.push(obj[k]);
+  }
+  return values;
+};
+
+// dist/runtime/errors/createErrorCondition.js
+var createErrorCondition = (kind, msg = "", utility = "") => {
+  return {
+    __kind: "ErrorCondition",
+    kind,
+    msg,
+    utility
+  };
+};
+
+// dist/runtime/literals/box.js
+function box(value) {
+  const rtn = {
+    __type: "box",
+    value,
+    unbox: (...p) => {
+      return typeof value === "function" ? value(...p) : value;
+    }
+  };
+  return rtn;
+}
+function isBox(thing) {
+  return typeof thing === "object" && "__type" in thing && thing.__type === "box";
+}
+function boxDictionaryValues(dict2) {
+  const keys = Object.keys(dict2);
+  return keys.reduce((acc, key) => ({ ...acc, [key]: box(dict2[key]) }), {});
+}
+function unbox(val) {
+  return isBox(val) ? val.value : val;
+}
+
+// dist/runtime/literals/identity.js
+var identity = (v) => v;
+
+// dist/runtime/literals/literal.js
+function idLiteral(o) {
+  return { ...o, id: o.id };
+}
+function nameLiteral(o) {
+  return o;
+}
+function kindLiteral(o) {
+  return o;
+}
+function idTypeGuard(_o) {
+  return true;
+}
+function literal(obj) {
+  return obj;
+}
+
+// dist/runtime/literals/stripTrailing.js
+var switchType = (content) => (val) => {
+  return typeof content === "number" ? Number(val) : val;
+};
+function stripTrailing(content, strip) {
+  var _a;
+  const re = new RegExp(`(.*)${strip}$`);
+  return ((_a = String(content)) == null ? void 0 : _a.endsWith(String(strip))) ? switchType(content)(String(content).replace(re, "$1")) : switchType(content)(String(content));
+}
+
+// dist/runtime/literals/stripLeading.js
+function stripLeading(content, strip) {
+  const re = new RegExp(`^${strip}(.*)`);
+  return content.startsWith(strip) ? (
+    // starts with
+    content.replace(re, "$1")
+  ) : (
+    // does not
+    content
+  );
+}
+
+// dist/runtime/literals/ensureTrailing.js
+function ensureTrailing(content, ensure) {
+  return (
+    //
+    content.endsWith(ensure) ? content : `${content}${ensure}`
+  );
+}
+
+// dist/runtime/literals/ensureLeading.js
+function ensureLeading(content, ensure) {
+  return String(content).startsWith(ensure) ? content : `${ensure}${content}`;
+}
+
+// dist/runtime/literals/ensureSurround.js
+function ensureSurround(prefix, postfix) {
+  const fn2 = (input) => {
+    const result2 = ensureTrailing(ensureLeading(input, prefix), postfix);
+    return result2;
+  };
+  return fn2;
+}
+
+// dist/runtime/literals/ifUppercase.js
+function ifUppercaseChar(ch, callbackForMatch, callbackForNoMatch) {
+  if (ch.length !== 1) {
+    throw new Error(`Invalid string length passed to ifUppercaseChar(ch); this function requires a single character but ${ch.length} were received`);
+  }
+  return LOWER_ALPHA_CHARS.includes(ch) ? callbackForMatch(ch) : callbackForNoMatch(ch);
+}
+
+// dist/runtime/literals/pathJoin.js
+function pathJoin(...segments) {
+  const clean_path = segments.map((i) => stripTrailing(stripLeading(i, "/"), "/")).join("/");
+  const original_path = segments.join("/");
+  const pre = original_path.startsWith("/") ? "/" : "";
+  const post = original_path.endsWith("/") ? "/" : "";
+  return `${pre}${clean_path}${post}`;
+}
+
+// dist/runtime/literals/narrow.js
+function narrow(...values) {
+  return values.length === 1 ? values[0] : values;
+}
+
+// dist/runtime/literals/tuple.js
+var tuple = (...values) => {
+  const arr = values.length === 1 ? values[0] : values;
+  return asArray(arr);
+};
+
+// dist/runtime/literals/capitalize.js
+function capitalize(str) {
+  return `${str == null ? void 0 : str.slice(0, 1).toUpperCase()}${str == null ? void 0 : str.slice(1)}`;
+}
+
+// dist/runtime/literals/uncapitalize.js
+function uncapitalize(str) {
+  return `${str == null ? void 0 : str.slice(0, 1).toLowerCase()}${str == null ? void 0 : str.slice(1)}`;
+}
+
+// dist/runtime/literals/uppercase.js
+function uppercase(str) {
+  return str.toUpperCase();
+}
+
+// dist/runtime/literals/lowercase.js
+function lowercase(str) {
+  return str.toLowerCase();
+}
+
+// dist/runtime/literals/widen.js
+function widen(value) {
+  return value;
+}
+
+// dist/runtime/literals/toCamelCase.js
+function toCamelCase(input, preserveWhitespace) {
+  const pascal = preserveWhitespace ? toPascalCase(input, preserveWhitespace) : toPascalCase(input);
+  const [_, preWhite, focus, postWhite] = /^(\s*)(.*?)(\s*)$/.exec(pascal);
+  const camel = (preserveWhitespace ? preWhite : "") + focus.replace(/^.*?([0-9]*?[a-z|A-Z]{1})/s, (_2, p1) => p1.toLowerCase()) + (preserveWhitespace ? postWhite : "");
+  return camel;
+}
+
+// dist/runtime/literals/toKebabCase.js
+function toKebabCase(input, _preserveWhitespace) {
+  const [_, preWhite, focus, postWhite] = /^(\s*)(.*?)(\s*)$/.exec(input);
+  const replaceWhitespace = (i) => i.replace(/\s/gs, "-");
+  const replaceUppercase = (i) => i.replace(/[A-Z]/g, (c) => `-${c[0].toLowerCase()}`);
+  const replaceLeadingDash = (i) => i.replace(/^-/s, "");
+  const replaceTrailingDash = (i) => i.replace(/-$/s, "");
+  const replaceUnderscore = (i) => i.replace(/_/g, "-");
+  const removeDupDashes = (i) => i.replace(/-+/g, "-");
+  return removeDupDashes(`${preWhite}${replaceUnderscore(replaceTrailingDash(replaceLeadingDash(removeDupDashes(replaceWhitespace(replaceUppercase(focus))))))}${postWhite}`);
+}
+
+// dist/runtime/literals/ifLowercase.js
+function ifLowercaseChar(ch, callbackForMatch, callbackForNoMatch) {
+  if (ch.length !== 1) {
+    throw new Error(`call to ifUppercaseChar received ${ch.length} characters but is only valid when one character is passed in!`);
+  }
+  return LOWER_ALPHA_CHARS.includes(ch) ? callbackForMatch(ch) : callbackForNoMatch(ch);
+}
+
+// dist/runtime/literals/toSnakeCase.js
+function toSnakeCase(input, preserveWhitespace = false) {
+  const [_, preWhite, focus, postWhite] = /^(\s*)(.*?)(\s*)$/.exec(input);
+  const convertInteriorSpace = (input2) => input2.replace(/\s+/gs, "_");
+  const convertDashes = (input2) => input2.replace(/-/gs, "_");
+  const injectUnderscoreBeforeCaps = (input2) => input2.replace(/([A-Z])/gs, "_$1");
+  const removeLeadingUnderscore = (input2) => input2.startsWith("_") ? input2.slice(1) : input2;
+  return ((preserveWhitespace ? preWhite : "") + removeLeadingUnderscore(injectUnderscoreBeforeCaps(convertDashes(convertInteriorSpace(focus)))).toLowerCase() + (preserveWhitespace ? postWhite : "")).replace(/__/g, "_");
+}
+
+// dist/runtime/literals/toString.js
+function toString(val) {
+  return String(val);
+}
+
+// dist/runtime/literals/pluralize.js
+var isException = (word) => Object.keys(PLURAL_EXCEPTIONS).includes(word);
+var endingIn = (word, postfix) => {
+  switch (postfix) {
+    case "is":
+      return word.endsWith(postfix) ? `${word}es` : void 0;
+    case "singular-noun":
+      return SINGULAR_NOUN_ENDINGS.some((i) => word.endsWith(i)) ? split(word).every((i) => [...ALPHA_CHARS].includes(i)) ? `${word}es` : void 0 : void 0;
+    case "f":
+      return word.endsWith("f") ? stripTrailing(word, "f") + "ves" : word.endsWith("fe") ? stripTrailing(word, "fe") + "ves" : void 0;
+    case "y":
+      return word.endsWith("y") ? CONSONANTS.includes(word.slice(-2, 1)) ? stripTrailing(word, "y") + "ies" : void 0 : void 0;
+    default:
+      throw new Error(`endingIn received "${postfix}" as a postfix but this ending is not known!`);
+  }
+};
+var pluralize = (word) => {
+  const result2 = isException(word) ? PLURAL_EXCEPTIONS[word] : endingIn(word, "is") || endingIn(word, "singular-noun") || endingIn(word, "f") || endingIn(word, "y") || `${word}s`;
+  return result2;
+};
+
+// dist/runtime/literals/retainAfter.js
+function retainAfter(content, find2) {
+  const parts = content.split(find2);
+  parts.shift();
+  return parts.join(find2);
+}
+
+// dist/runtime/literals/surround.js
+function surround(prefix, postfix) {
+  return (input) => `${prefix}${input}${postfix}`;
+}
+
+// dist/runtime/literals/stripAfter.js
+function stripAfter(content, find2) {
+  return content.split(find2).shift();
+}
+
+// dist/runtime/literals/stripBefore.js
+function stripBefore(content, find2) {
+  return content.split(find2).slice(1).join(find2);
+}
+
+// dist/runtime/literals/trim.js
+function trim(input) {
+  return input.trim();
+}
+function trimLeft(input) {
+  return input.trimStart();
+}
+function trimStart(input) {
+  return input.trimStart();
+}
+function trimRight(input) {
+  return input.trimEnd();
+}
+function trimEnd(input) {
+  return input.trimEnd();
+}
+
+// dist/runtime/literals/toPascalCase.js
+function toPascalCase(input, preserveWhitespace = void 0) {
+  const [_, preWhite, focus, postWhite] = /^(\s*)(.*?)(\s*)$/.exec(input);
+  const convertInteriorToCap = (i) => i.replace(/[ |_|-]+([0-9]*?[a-z|A-Z]{1})/gs, (_2, p1) => p1.toUpperCase());
+  const startingToCap = (i) => i.replace(/^[_|-]*?([0-9]*?[a-z]{1})/gs, (_2, p1) => p1.toUpperCase());
+  const replaceLeadingTrash = (i) => i.replace(/^[-_]/s, "");
+  const replaceTrailingTrash = (i) => i.replace(/[-_]$/s, "");
+  const pascal = `${preserveWhitespace ? preWhite : ""}${capitalize(replaceTrailingTrash(replaceLeadingTrash(convertInteriorToCap(startingToCap(focus)))))}${preserveWhitespace ? postWhite : ""}`;
+  return pascal;
+}
+
+// dist/runtime/literals/toUppercase.js
+function toUppercase(str) {
+  return str.split("").map((i) => ifLowercaseChar(i, (v) => capitalize(v), (v) => v)).join("");
+}
+
+// dist/runtime/literals/toNumericArray.js
+var toNumericArray = (arr) => {
+  return arr.map((i) => Number(i));
+};
+
+// dist/runtime/literals/truncate.js
+var truncate = (content, maxLength, ellipsis = false) => {
+  const overLimit = content.length > maxLength;
+  return overLimit ? ellipsis ? `${content.slice(0, maxLength)}${typeof ellipsis === "string" ? ellipsis : "..."}` : content.slice(0, maxLength) : content;
+};
+
+// dist/runtime/errors/kindedError.js
+var kindError = (kind, _defineContext) => (msg, context) => {
+  const err = new Error(msg);
+  err.name = toPascalCase(kind);
+  err.kind = toKebabCase(kind);
+  err.__kind = "KindError";
+  err.context = context;
+  return err;
+};
+
+// dist/runtime/functional/result.js
+var result = "NOT READY";
+
+// dist/runtime/functions/fnMeta.js
+var fnMeta = (func) => {
+  const fn2 = (...args) => func(...args);
+  const props = Object.keys(fn2).reduce((acc, key) => ({ ...acc, [key]: fn2[key] }), {});
+  return {
+    fn: fn2,
+    props
+  };
+};
+
+// dist/runtime/initializers/addFnToProps.js
+var addPropsToFn = (fn2, clone_fn) => {
+  const localFn = clone_fn ? (...args) => fn2(args) : fn2;
+  return (obj) => {
+    for (const k in obj) {
+      localFn[k] = obj[k];
+    }
+    return localFn;
+  };
+};
+
+// dist/runtime/initializers/addPropsToFn.js
+var addFnToProps = (props, _clone_fn) => (fn2) => {
+  const localFn = (...args) => fn2(args);
+  for (const k in props) {
+    localFn[k] = props[k];
+  }
+  return localFn;
+};
+
+// dist/runtime/initializers/createFnWithProps.js
+var createFnWithProps = (fn2, props, narrowing = false) => {
+  const fnWithProps = fn2;
+  for (const prop of keysOf(props)) {
+    fnWithProps[prop] = props[prop];
+  }
+  return isTrue(narrowing) ? fnWithProps : fnWithProps;
+};
+
+// dist/runtime/initializers/defineObj.js
+function defineObj(literal2 = {}) {
+  return (wide2 = {}) => {
+    const obj = literal2 ? { ...literal2, ...wide2 } : wide2;
+    return obj;
+  };
+}
+
+// dist/runtime/initializers/defineTuple.js
+var defineTuple = (...values) => {
+  return values.map((i) => isFunction(i) ? handleDoneFn(i(ShapeApiImplementation)) : i);
+};
+
+// dist/runtime/lists/asArray.js
+var asArray = (thing) => {
+  return Array.isArray(thing) === true ? (
+    // proxy thing back as it's already an array
+    thing
+  ) : typeof thing === "undefined" ? [] : [thing];
+};
+
+// dist/runtime/lists/getEach.js
+function getEach(list2, dotPath) {
+  const result2 = list2.map((i) => isNull(dotPath) ? i : isContainer(i) ? get(i, dotPath) : Never).filter((i) => !isErrorCondition(i));
+  return result2;
+}
+
+// dist/runtime/lists/indexOf.js
+function indexOf(val, index) {
+  const isNegative = isNumber(index) && index < 0;
+  if (isNegative && !Array.isArray(val)) {
+    throw new Error(`The indexOf(val,idx) utility received a negative index value [${index}] but the value being de-references is not an array [${typeof val}]!`);
+  }
+  if (isNegative && Array.isArray(val) && val.length < Math.abs(index)) {
+    throw new Error(`The indexOf(val,idx) utility received a negative index of ${index} but the length of the array passed in is only ${val.length}! This is not allowed.`);
+  }
+  const idx = isNegative && Array.isArray(val) ? val.length + 1 - Math.abs(index) : index;
+  return index === null ? val : isNull(idx) ? val : isArray(val) ? Number(idx) in val ? val[Number(idx)] : Never : isObject(val) ? String(idx) in val ? val[String(idx)] : Never : Never;
+}
+
+// dist/runtime/lists/intersection.js
+function intersectWithOffset(a, b, deref) {
+  const aIndexable = a.every((i) => isIndexable(i));
+  const bIndexable = b.every((i) => isIndexable(i));
+  if (!aIndexable || !bIndexable) {
+    if (!aIndexable) {
+      throw new Error(`The "a" array passed into intersect(a,b) was not fully composed of indexable properties: ${a.map((i) => typeof i).join(", ")}`);
+    } else {
+      throw new Error(`The "b" array passed into intersect(a,b) was not fully composed of indexable properties: ${b.map((i) => typeof i).join(", ")}`);
+    }
+  }
+  const aMatches = getEach(a, deref);
+  const bMatches = getEach(b, deref);
+  const sharedKeys2 = ifNotNull(deref, (v) => [
+    a.filter((i) => Array.from(bMatches).includes(get(i, v))),
+    b.filter((i) => Array.from(aMatches).includes(get(i, v)))
+  ], () => a.filter((k) => b.includes(k)));
+  return sharedKeys2;
+}
+function intersectNoOffset(a, b) {
+  return a.length < b.length ? a.filter((val) => b.includes(val)) : b.filter((val) => a.includes(val));
+}
+var intersection = (a, b, deref = null) => {
+  return deref === null ? intersectNoOffset(a, b) : intersectWithOffset(a, b, deref);
+};
+
+// dist/runtime/lists/unique.js
+var unique = (...values) => {
+  const u = [];
+  for (const i of values.flat()) {
+    if (!u.includes(i)) {
+      u.push(i);
+    }
+  }
+  return u;
+};
+
+// dist/runtime/lists/logicalReturns.js
+function logicalReturns(conditions) {
+  return conditions.map((c) => isBoolean(c) ? c : isFunction(c) ? c() : Never);
+}
+
+// dist/runtime/lists/find.js
+var find = (list2, deref = null) => (comparator) => {
+  return list2.find((i) => {
+    const val = deref ? isContainer(i) ? deref in i ? i[deref] : void 0 : i : i;
+    return val === comparator;
+  });
+};
+
+// dist/runtime/lists/filter.js
+var FILTER = "NOT READY";
+
+// dist/runtime/lists/createConverter.js
+function createConverter(mapper) {
+  return (input) => {
+    let result2;
+    if (isNothing(input)) {
+      result2 = mapper.nothing ? mapper.nothing(input) : Never;
+    } else if (isObject(input)) {
+      result2 = mapper.object ? mapper.object(input) : Never;
+    } else {
+      switch (typeof input) {
+        case "string":
+          result2 = mapper.string ? mapper.string(input) : Never;
+          break;
+        case "number":
+        case "bigint":
+          result2 = mapper.number ? mapper.number(input) : Never;
+          break;
+        case "boolean":
+          result2 = mapper.boolean ? mapper.boolean(input) : Never;
+          break;
+        default:
+          throw new Error(`Unhandled type: ${typeof input}`);
+      }
+    }
+    return result2;
+  };
+}
+
+// dist/runtime/lists/slice.js
+var slice = (list2, start, end) => {
+  return list2.slice(start, end);
+};
+
+// dist/runtime/lists/last.js
+var last = (list2) => {
+  return [...list2].pop();
+};
+
+// dist/runtime/lists/reverse.js
+var reverse = (list2) => {
+  return [...list2].reverse();
+};
+
+// dist/runtime/lists/pop.js
+var pop = (list2) => {
+  return list2.length > 0 ? [last(list2), slice(list2, 0, -1)] : void 0;
+};
+
+// dist/runtime/lists/join.js
+function join(joinWith) {
+  return (...tuple3) => {
+    return tuple3.join(joinWith);
+  };
+}
+
+// dist/runtime/lists/shift.js
+var shift = (list2) => {
+  return list2.length > 0 ? [list2[0], list2.slice(1)] : void 0;
+};
+
+// dist/runtime/runtime-types/shape-helpers/addToken.js
+var addToken = (token, ...params) => `<<${token}${params.length > 0 ? `::${params.join("::")}` : ""}>>`;
+
+// dist/runtime/runtime-types/shape-helpers/atomics.js
+var boolean = (literal2) => isDefined(literal2) ? isTrue(literal2) ? addToken("true") : isFalse(literal2) ? addToken("false") : addToken("boolean") : addToken("boolean");
+var unknown = () => "<<unknown>>";
+var undefinedType = () => "<<undefined>>";
+var nullType = () => "<<null>>";
+
+// dist/runtime/runtime-types/shape-helpers/singletons.js
+var addSingleton = (token, api) => (...literals) => {
+  return literals.length === 0 ? api ? api : addToken(token) : literals.length === 1 ? addToken(token, literals[0]) : addToken("union", literals.map((l) => addToken(token, `${l}`)).join(","));
+};
+var stringApi = {
+  zip: () => addToken("string-set", "Zip5"),
+  zipPlus4: () => addToken("string-set", "Zip5_4"),
+  zipCode: () => addToken("string-set", "ZipCode"),
+  militaryTime: (resolution) => {
+    return addToken("string-set", "militaryTime", resolution || "HH:MM");
+  },
+  civilianTime: (resolution) => {
+    return addToken("string-set", "militaryTime", resolution || "HH:MM");
+  },
+  numericString: () => addToken("string-set", "numeric"),
+  ipv4Address: () => addToken("string-set", "ipv4Address"),
+  ipv6Address: () => addToken("string-set", "ipv6Address"),
+  done: () => addToken("string")
+};
+var string = addSingleton("string", stringApi);
+var number = addSingleton("number");
+
+// dist/runtime/runtime-types/shape-helpers/functions.js
+var fn = (..._args) => ({
+  returns: (_rtn) => ({
+    addProperties: (_kv) => {
+      return null;
+    },
+    done: () => {
+      return null;
+    }
+  }),
+  done: () => {
+    const result2 = null;
+    return result2;
+  }
+});
+
+// dist/runtime/runtime-types/shape-helpers/literal-containers.js
+var dictionary = (_obj) => {
+  return null;
+};
+var tuple2 = (..._elements) => {
+  return null;
+};
+
+// dist/runtime/runtime-types/shape-helpers/wide-containers.js
+var record = (_key, _value) => {
+  return null;
+};
+var array = (_type) => {
+  return null;
+};
+var set = (_type) => {
+  return null;
+};
+var map = (_key, _value) => {
+  return null;
+};
+var weakMap = (_key, _value) => {
+  return null;
+};
+
+// dist/runtime/runtime-types/shape-helpers/union.js
+var union = (...elements) => {
+  const result2 = elements.map((_el) => {
+  });
+  return result2;
+};
+
+// dist/runtime/runtime-types/shape.js
+var isAddOrDone = (val) => {
+  return isObject(val) && hasKeys("add", "done") && typeof val.done === "function" && typeof val.add === "function";
+};
+var ShapeApiImplementation = {
+  string,
+  number,
+  boolean,
+  unknown,
+  undefined: undefinedType,
+  null: nullType,
+  union,
+  fn,
+  record,
+  array,
+  set,
+  map,
+  weakMap,
+  dictionary,
+  tuple: tuple2
+};
+var shape = (cb) => {
+  const rtn = cb(ShapeApiImplementation);
+  return handleDoneFn(isAddOrDone(rtn) ? rtn.done() : rtn);
+};
+var isShape = (v) => {
+  return isString(v) && v.startsWith("<<") && v.endsWith(">>") && SHAPE_PREFIXES.some((i) => v.startsWith(`<<${i}`)) ? true : false;
+};
+
+// dist/runtime/runtime-types/choices.js
+var choices = "NOT READY";
+
+// dist/runtime/runtime-types/list.js
+var createProxy = (...initialize) => {
+  const state = initialize;
+  state.id = null;
+  const proxy = new Proxy(state, {});
+  Object.defineProperty(proxy, "id", {
+    enumerable: false
+  });
+  return proxy;
+};
+var list = (...init) => {
+  return init.length === 1 && isArray(init[0]) ? createProxy(...init[0]) : createProxy(...init);
+};
+
+// dist/runtime/runtime-types/dict.js
+var process = (obj, _narrow, _opt) => {
+  return Object.defineProperty(obj, "__id", { enumerable: false });
+};
+var dict = (obj, ...props) => process(obj, (props || []).filter((i) => !i.startsWith("opt:")), (props || []).filter((i) => i.startsWith("opt:")));
+
+// dist/runtime/runtime-types/ip6Prefix.js
+var ip6Prefix = (...groups) => {
+  const empty = addToken("string");
+  let count = 4 - groups.length;
+  let fillIn = [];
+  for (let index = 0; index < count; index++) {
+    fillIn.push(empty);
+  }
+  return [
+    "<<string::",
+    [
+      groups.join(":"),
+      fillIn.join(":")
+    ].join(":"),
+    ">>"
+  ].join("");
+};
+
+// dist/runtime/runtime-types/shape-helpers/getTokenName.js
+var getTokenName = (token) => {
+  const [name, ..._rest] = stripLeading(token, "<<").split("::");
+  return name;
+};
+
+// dist/runtime/runtime-types/shape-helpers/getTokenData.js
+var getTokenData = (token) => {
+  const [_name, ...rest] = stripTrailing(token, ">>").split("::");
+  return rest;
+};
+
+// dist/runtime/runtime-types/parse.js
+var handleTypeToken = (token) => () => {
+  return {
+    isToken: true,
+    type: null,
+    token,
+    tokenName: getTokenName(token),
+    tokenData: getTokenData(token)
+  };
+};
+var parse = (value) => {
+  return isShape(value) ? handleTypeToken(value)() : {
+    isToken: false,
+    type: value
+  };
+};
+
+// dist/runtime/sets/uniqueKeys.js
+var uniqueKeys = (left, right) => {
+  const isNumeric = isArray(left) && isArray(right) ? true : false;
+  if (isArray(left) && !isArray(right) || isArray(right) && !isArray(left)) {
+    throw new Error("uniqueKeys(l,r) given invalid comparison; both left and right values should be an object or an array but not one of each!");
+  }
+  const l = isNumeric ? Object.keys(left).map((i) => Number(i)) : Object.keys(left);
+  const r = isNumeric ? Object.keys(right).map((i) => Number(i)) : Object.keys(right);
+  if (isNumeric) {
+    throw new Error("uniqueKeys does not yet work with tuples");
+  }
+  const leftKeys = l.filter((i) => !r.includes(i));
+  const rightKeys = r.filter((i) => !l.includes(i));
+  return [
+    "LeftRight",
+    leftKeys,
+    rightKeys
+  ];
+};
+
+// dist/runtime/type-conversion/mergeObjects.js
+function mergeObjects(defVal, override) {
+  const intersectingKeys = sharedKeys(defVal, override);
+  const defUnique = withoutKeys(defVal, ...intersectingKeys);
+  const overrideUnique = withoutKeys(defVal, ...intersectingKeys);
+  const merged = {
+    ...intersectingKeys.reduce((acc, key) => typeof override[key] === "undefined" ? { ...acc, [key]: defVal[key] } : { ...acc, [key]: override[key] }, {}),
+    ...defUnique,
+    ...overrideUnique
+  };
+  return merged;
+}
+
+// dist/runtime/type-conversion/optional.js
+function optional(...values) {
+  return values.length === 1 ? values[0] : values;
+}
+
+// dist/runtime/type-conversion/mergeScalars.js
+function mergeScalars(a, b) {
+  return isUndefined(b) ? a : b;
+}
+
+// dist/runtime/type-conversion/mergeTuples.js
+function mergeTuples(a, b) {
+  return b.length > a.length ? b.map((v, idx) => v !== void 0 ? v : a[idx]) : [...b, ...a.slice(b.length)].map((v, idx) => v !== void 0 ? v : a[idx]);
+}
+
+// dist/runtime/type-conversion/unionize.js
+function unionize(value, inUnionWith) {
+  return value;
+}
+
+// dist/runtime/type-conversion/intersect.js
+function intersect(value, intersectedWith) {
+  return value;
+}
+
+// dist/runtime/type-conversion/never.js
+function never(val) {
+  return val;
+}
+
+// dist/runtime/type-conversion/union.js
+var union2 = (...options) => (value) => value;
+
+// dist/runtime/type-conversion/toNumber.js
+var convertScalar = (val) => {
+  switch (typeof val) {
+    case "number":
+      return val;
+    case "string":
+      return Number(val);
+    case "boolean":
+      return val ? 1 : 0;
+    default:
+      throw Error(`${typeof val} is an invalid scalar type to convert to a number!`);
+  }
+};
+var convertList = (val) => val.map((i) => convertScalar(i));
+function toNumber(value) {
+  return Array.isArray(value) ? convertList(value) : convertScalar(value);
+}
+
+// dist/runtime/type-conversion/asRecord.js
+var asRecord = (obj) => {
+  return obj;
+};
+
+// dist/runtime/type-conversion/asString.js
+var asString = (value) => {
+  return isString(value) ? value : isNumber(value) ? `${value}` : isBoolean(value) ? `${value}` : String(value);
+};
+
+// dist/runtime/vuejs/asVueRef.js
+var asVueRef = (value) => ({
+  value,
+  _value: null
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALPHA_CHARS,
+  COMMA,
+  COMMON_OBJ_PROPS,
+  CONSONANTS,
+  DEFAULT_MANY_TO_ONE_MAPPING,
+  DEFAULT_ONE_TO_MANY_MAPPING,
+  DEFAULT_ONE_TO_ONE_MAPPING,
+  FALSY_TYPE_KINDS,
+  FALSY_VALUES,
+  FILTER,
+  HASH_TABLE_ALPHA_LOWER,
+  HASH_TABLE_ALPHA_UPPER,
+  HASH_TABLE_CHAR,
+  HASH_TABLE_DIGIT,
+  HASH_TABLE_OTHER,
+  HASH_TABLE_SPECIAL,
+  HASH_TABLE_WIDE,
+  IPv4,
+  IPv6,
+  LITERAL_TYPE_KINDS,
+  LOWER_ALPHA_CHARS,
+  MARKED,
+  MONTH_ABBR,
+  MONTH_NAME,
+  MapCardinality,
+  NARROW_CONTAINER_TYPE_KINDS,
+  NON_ZERO_NUMERIC_CHAR,
+  NOT_APPLICABLE,
+  NOT_DEFINED,
+  NO_DEFAULT_VALUE,
+  NUMERIC_CHAR,
+  NUMERIC_DIGIT,
+  Never,
+  OPTION,
+  PLURAL_EXCEPTIONS,
+  PLURAL_EXCEPTIONS_OLD,
+  RESULT,
+  SHAPE_DELIMITER,
+  SHAPE_PREFIXES,
+  SINGULAR_NOUN_ENDINGS,
+  ShapeApiImplementation,
+  TT_Atomics,
+  TT_Containers,
+  TT_Functions,
+  TT_SEP,
+  TT_START,
+  TT_STOP,
+  TT_Sets,
+  TT_Singletons,
+  TYPE_COMPARISONS,
+  TYPE_KINDS,
+  TYPE_OF,
+  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,
+  TYPE_TRANSFORMS,
+  UPPER_ALPHA_CHARS,
+  US_STATE_LOOKUP,
+  US_STATE_LOOKUP_PROVINCES,
+  US_STATE_LOOKUP_STRICT,
+  WIDE_CONTAINER_TYPE_KINDS,
+  WIDE_TYPE_KINDS,
+  WideAssignment,
+  ZIP_TO_STATE,
+  addFnToProps,
+  addPropsToFn,
+  and,
+  asArray,
+  asRecord,
+  asString,
+  asVueRef,
+  box,
+  boxDictionaryValues,
+  capitalize,
+  choices,
+  createConstant,
+  createConverter,
+  createErrorCondition,
+  createFnWithProps,
+  defineObj,
+  defineTuple,
+  dict,
+  endsWith,
+  ensureLeading,
+  ensureSurround,
+  ensureTrailing,
+  entries,
+  find,
+  fnMeta,
+  get,
+  getEach,
+  handleDoneFn,
+  hasDefaultValue,
+  hasIndexOf,
+  hasKeys,
+  idLiteral,
+  idTypeGuard,
+  identity,
+  ifArray,
+  ifArrayPartial,
+  ifBoolean,
+  ifChar,
+  ifContainer,
+  ifDefined,
+  ifFalse,
+  ifFunction,
+  ifHasKey,
+  ifLength,
+  ifLowercaseChar,
+  ifNotNull,
+  ifNull,
+  ifNumber,
+  ifObject,
+  ifSameType,
+  ifScalar,
+  ifString,
+  ifTrue,
+  ifUndefined,
+  ifUppercaseChar,
+  indexOf,
+  intersect,
+  intersection,
+  ip6Prefix,
+  isArray,
+  isBoolean,
+  isBox,
+  isConstant,
+  isContainer,
+  isDefined,
+  isDoneFn,
+  isEqual,
+  isErrorCondition,
+  isFalse,
+  isFalsy,
+  isFnWithParams,
+  isFunction,
+  isIndexable,
+  isLength,
+  isNever,
+  isNotNull,
+  isNothing,
+  isNull,
+  isNumber,
+  isNumericString,
+  isObject,
+  isReadonlyArray,
+  isRef,
+  isSameTypeOf,
+  isScalar,
+  isShape,
+  isSpecificConstant,
+  isString,
+  isSymbol,
+  isTrue,
+  isTruthy,
+  isTuple,
+  isTypeOf,
+  isTypeToken,
+  isTypeTuple,
+  isUndefined,
+  join,
+  keysOf,
+  kindError,
+  kindLiteral,
+  last,
+  list,
+  literal,
+  logicalReturns,
+  lowercase,
+  mergeObjects,
+  mergeScalars,
+  mergeTuples,
+  nameLiteral,
+  narrow,
+  never,
+  omit,
+  optional,
+  or,
+  parse,
+  pathJoin,
+  pluralize,
+  pop,
+  result,
+  retain,
+  retainAfter,
+  reverse,
+  shape,
+  sharedKeys,
+  shift,
+  slice,
+  split,
+  startsWith,
+  stripAfter,
+  stripBefore,
+  stripLeading,
+  stripTrailing,
+  surround,
+  takeProp,
+  toCamelCase,
+  toKebabCase,
+  toNumber,
+  toNumericArray,
+  toPascalCase,
+  toSnakeCase,
+  toString,
+  toUppercase,
+  trim,
+  trimEnd,
+  trimLeft,
+  trimRight,
+  trimStart,
+  truncate,
+  tuple,
+  unbox,
+  uncapitalize,
+  union,
+  unionize,
+  unique,
+  uniqueKeys,
+  uppercase,
+  valuesOf,
+  widen,
+  withDefaults,
+  withKeys,
+  withoutKeys,
+  withoutValue
+});