inferred-types 0.45.3 → 0.46.0

package/dist/inferred-types/index.cjs

@@ -1,3233 +0,0 @@
-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,
-  GITHUB_INSIGHT_CATEGORY_LOOKUP: () => GITHUB_INSIGHT_CATEGORY_LOOKUP,
-  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,
-  NETWORK_PROTOCOL_LOOKUP: () => NETWORK_PROTOCOL_LOOKUP,
-  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,
-  PHONE_COUNTRY_CODES: () => PHONE_COUNTRY_CODES,
-  PHONE_FORMAT: () => PHONE_FORMAT,
-  PLURAL_EXCEPTIONS: () => PLURAL_EXCEPTIONS,
-  PLURAL_EXCEPTIONS_OLD: () => PLURAL_EXCEPTIONS_OLD,
-  PROXMOX_CT_STATE: () => PROXMOX_CT_STATE,
-  REPO_PAGE_TYPES: () => REPO_PAGE_TYPES,
-  REPO_SOURCES: () => REPO_SOURCES,
-  REPO_SOURCE_LOOKUP: () => REPO_SOURCE_LOOKUP,
-  RESULT: () => RESULT,
-  SHAPE_DELIMITER: () => SHAPE_DELIMITER,
-  SHAPE_PREFIXES: () => SHAPE_PREFIXES,
-  SINGULAR_NOUN_ENDINGS: () => SINGULAR_NOUN_ENDINGS,
-  ShapeApiImplementation: () => ShapeApiImplementation,
-  TOP_LEVEL_DOMAINS: () => TOP_LEVEL_DOMAINS,
-  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,
-  WHITESPACE_CHARS: () => WHITESPACE_CHARS,
-  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,
-  asApi: () => asApi,
-  asApiCallback: () => asApiCallback,
-  asArray: () => asArray,
-  asCallbackProp: () => asCallbackProp,
-  asChars: () => asChars,
-  asEscapeFunction: () => asEscapeFunction,
-  asHandledApiCallback: () => asHandledApiCallback,
-  asOptionalParamFunction: () => asOptionalParamFunction,
-  asPhoneNumber: () => asPhoneNumber,
-  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,
-  getEscapeFunction: () => getEscapeFunction,
-  getPhoneCountryCode: () => getPhoneCountryCode,
-  getUrlPath: () => getUrlPath,
-  getUrlPort: () => getUrlPort,
-  getUrlProtocol: () => getUrlProtocol,
-  getUrlQueryParams: () => getUrlQueryParams,
-  getUrlSource: () => getUrlSource,
-  getYouTubePageType: () => getYouTubePageType,
-  handleDoneFn: () => handleDoneFn,
-  hasDefaultValue: () => hasDefaultValue,
-  hasIndexOf: () => hasIndexOf,
-  hasKeys: () => hasKeys,
-  hasUrlPort: () => hasUrlPort,
-  hasUrlQueryParameter: () => hasUrlQueryParameter,
-  hasWhiteSpace: () => hasWhiteSpace,
-  idLiteral: () => idLiteral,
-  idTypeGuard: () => idTypeGuard,
-  identity: () => identity,
-  ifLowercaseChar: () => ifLowercaseChar,
-  ifUppercaseChar: () => ifUppercaseChar,
-  indexOf: () => indexOf,
-  intersect: () => intersect,
-  intersection: () => intersection,
-  ip6GroupExpansion: () => ip6GroupExpansion,
-  ip6Prefix: () => ip6Prefix,
-  isApi: () => isApi,
-  isApiSurface: () => isApiSurface,
-  isArray: () => isArray,
-  isBitbucketUrl: () => isBitbucketUrl,
-  isBoolean: () => isBoolean,
-  isBox: () => isBox,
-  isCodeCommitUrl: () => isCodeCommitUrl,
-  isConstant: () => isConstant,
-  isContainer: () => isContainer,
-  isCssAspectRatio: () => isCssAspectRatio,
-  isDefined: () => isDefined,
-  isDomainName: () => isDomainName,
-  isDoneFn: () => isDoneFn,
-  isEmail: () => isEmail,
-  isEqual: () => isEqual,
-  isErrorCondition: () => isErrorCondition,
-  isEscapeFunction: () => isEscapeFunction,
-  isFalse: () => isFalse,
-  isFalsy: () => isFalsy,
-  isFnWithParams: () => isFnWithParams,
-  isFunction: () => isFunction,
-  isGithubRepoUrl: () => isGithubRepoUrl,
-  isGithubUrl: () => isGithubUrl,
-  isHexadecimal: () => isHexadecimal,
-  isIndexable: () => isIndexable,
-  isInlineSvg: () => isInlineSvg,
-  isIp4Address: () => isIp4Address,
-  isIp6Address: () => isIp6Address,
-  isIpAddress: () => isIpAddress,
-  isLength: () => isLength,
-  isNever: () => isNever,
-  isNotNull: () => isNotNull,
-  isNothing: () => isNothing,
-  isNull: () => isNull,
-  isNumber: () => isNumber,
-  isNumericString: () => isNumericString,
-  isObject: () => isObject,
-  isOptionalParamFunction: () => isOptionalParamFunction,
-  isPhoneNumber: () => isPhoneNumber,
-  isReadonlyArray: () => isReadonlyArray,
-  isRef: () => isRef,
-  isRepoSource: () => isRepoSource,
-  isRepoUrl: () => isRepoUrl,
-  isSameTypeOf: () => isSameTypeOf,
-  isScalar: () => isScalar,
-  isSemanticVersion: () => isSemanticVersion,
-  isSet: () => isSet,
-  isShape: () => isShape,
-  isSpecificConstant: () => isSpecificConstant,
-  isString: () => isString,
-  isSymbol: () => isSymbol,
-  isTrimable: () => isTrimable,
-  isTrue: () => isTrue,
-  isTruthy: () => isTruthy,
-  isTuple: () => isTuple,
-  isTypeOf: () => isTypeOf,
-  isTypeToken: () => isTypeToken,
-  isTypeTuple: () => isTypeTuple,
-  isUndefined: () => isUndefined,
-  isUnset: () => isUnset,
-  isUri: () => isUri,
-  isUrl: () => isUrl,
-  isUrlPath: () => isUrlPath,
-  isUrlSource: () => isUrlSource,
-  isYouTubeCreatorUrl: () => isYouTubeCreatorUrl,
-  isYouTubeFeedUrl: () => isYouTubeFeedUrl,
-  isYouTubePlaylistUrl: () => isYouTubePlaylistUrl,
-  isYouTubeShareUrl: () => isYouTubeShareUrl,
-  isYouTubeUrl: () => isYouTubeUrl,
-  isYouTubeVideoUrl: () => isYouTubeVideoUrl,
-  isYouTubeVideosInPlaylist: () => isYouTubeVideosInPlaylist,
-  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,
-  removePhoneCountryCode: () => removePhoneCountryCode,
-  removeUrlProtocol: () => removeUrlProtocol,
-  result: () => result,
-  retain: () => retain,
-  retainAfter: () => retainAfter,
-  retainChars: () => retainChars,
-  retainWhile: () => retainWhile,
-  reverse: () => reverse,
-  shape: () => shape,
-  sharedKeys: () => sharedKeys,
-  shift: () => shift,
-  slice: () => slice,
-  split: () => split,
-  startsWith: () => startsWith,
-  stripAfter: () => stripAfter,
-  stripBefore: () => stripBefore,
-  stripChars: () => stripChars,
-  stripLeading: () => stripLeading,
-  stripTrailing: () => stripTrailing,
-  surround: () => surround,
-  takeNumericCharacters: () => takeNumericCharacters,
-  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: () => union,
-  unionize: () => unionize,
-  unique: () => unique,
-  uniqueKeys: () => uniqueKeys,
-  uppercase: () => uppercase,
-  urlMeta: () => urlMeta,
-  valuesOf: () => valuesOf,
-  widen: () => widen,
-  withDefaults: () => withDefaults,
-  withKeys: () => withKeys,
-  withoutKeys: () => withoutKeys,
-  withoutValue: () => withoutValue,
-  wrapFn: () => wrapFn,
-  youtubeMeta: () => youtubeMeta
-});
-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/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/constants/RepoConstants.js
-var REPO_SOURCES = [
-  "github",
-  "bitbucket",
-  "gitlab",
-  "codecommit",
-  "local"
-];
-var REPO_PAGE_TYPES = [
-  "repo",
-  "commits",
-  "author",
-  "org",
-  "profile",
-  "issues",
-  "actions",
-  "followers",
-  "following",
-  "docs",
-  "unknown"
-];
-var REPO_SOURCE_LOOKUP = {
-  "github": [`github.com`, "github.io"],
-  "bitbucket": ["bitbucket.com"],
-  "gitlab": ["gitlab.com"],
-  "codecommit": ["https://aws.amazon.com/codecommit/"],
-  "local": []
-};
-var GITHUB_INSIGHT_CATEGORY_LOOKUP = {
-  pulse: "pulse",
-  contributors: "graphs/contributors",
-  community: "graphs/community",
-  standards: "community",
-  traffic: "graphs/traffic",
-  commits: "graphs/commit-activity",
-  code_frequency: "graphs/code-frequency",
-  dependencies: "network/dependencies",
-  dependents: "network/dependents",
-  dependabot: "network/updates",
-  network: "network",
-  forks: "forks",
-  people: "people"
-};
-
-// dist/constants/NetworkConstants.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"
-};
-var NETWORK_PROTOCOL_LOOKUP = {
-  http: ["http", "https"],
-  ftp: ["ftp", "sftp"],
-  file: ["", "file"],
-  ws: ["ws", "wss"],
-  ssh: ["", "ssh"],
-  "scp": ["", "scp"]
-};
-var TOP_LEVEL_DOMAINS = [
-  "com",
-  "org",
-  "net",
-  "int",
-  "edu",
-  "gov",
-  "io",
-  "mil",
-  "arpa",
-  "academy",
-  "agency",
-  "analytics",
-  "app",
-  "art",
-  "bet",
-  "beer",
-  "book",
-  "coffee",
-  "dot",
-  "doctor",
-  "dog",
-  "family",
-  "game",
-  "guide",
-  "guru",
-  "info",
-  "inc",
-  "news",
-  "new",
-  "ninja",
-  "now",
-  "online",
-  "page",
-  "photos",
-  "place",
-  "pub",
-  "room",
-  "show",
-  "technology",
-  "tel",
-  "tech",
-  "team",
-  "talk",
-  "travel",
-  "website",
-  "work",
-  "works",
-  "wow",
-  "uk",
-  "us",
-  "fr",
-  "de",
-  "eu",
-  "london"
-];
-
-// dist/constants/Characters.js
-var WHITESPACE_CHARS = [
-  " ",
-  "\n",
-  "	"
-];
-
-// dist/constants/Phone.js
-var PHONE_FORMAT = [
-  "Dashed (e.g., 456-555-1212)",
-  "Dotted (e.g., 456.555.1212)",
-  "ParaSpaced (e.g., (456) 555 1212)",
-  "ParaDashed (e.g., (456) 555-1212)"
-];
-var PHONE_COUNTRY_CODES = [
-  ["886", "TWN", "TW"],
-  ["93", "AFG", "AF"],
-  ["355", "ALB", "AL"],
-  ["213", "DZA", "DZ"],
-  ["1-684", "ASM", "AS"],
-  ["376", "AND", "AD"],
-  ["244", "AGO", "AO"],
-  ["1-264", "AIA", "AI"],
-  ["672", "ATA", "AQ"],
-  ["1-268", "ATG", "AG"],
-  ["54", "ARG", "AR"],
-  ["374", "ARM", "AM"],
-  ["297", "ABW", "AW"],
-  ["61", "AUS", "AU"],
-  ["43", "AUT", "AT"],
-  ["994", "AZE", "AZ"],
-  ["1-242", "BHS", "BS"],
-  ["973", "BHR", "BH"],
-  ["880", "BGD", "BD"],
-  ["1-246", "BRB", "BB"],
-  ["375", "BLR", "BY"],
-  ["32", "BEL", "BE"],
-  ["501", "BLZ", "BZ"],
-  ["229", "BEN", "BJ"],
-  ["1-441", "BMU", "BM"],
-  ["975", "BTN", "BT"],
-  ["591", "BOL", "BO"],
-  ["599", "BES", "BQ"],
-  ["387", "BIH", "BA"],
-  ["267", "BWA", "BW"],
-  ["47", "BVT", "BV"],
-  ["55", "BRA", "BR"],
-  ["246", "IOT", "IO"],
-  ["1-284", "VGB", "VG"],
-  ["673", "BRN", "BN"],
-  ["359", "BGR", "BG"],
-  ["226", "BFA", "BF"],
-  ["257", "BDI", "BI"],
-  ["238", "CPV", "CV"],
-  ["855", "KHM", "KH"],
-  ["237", "CMR", "CM"],
-  ["1", "CAN", "CA"],
-  ["1-345", "CYM", "KY"],
-  ["236", "CAF", "CF"],
-  ["235", "TCD", "TD"],
-  ["56", "CHL", "CL"],
-  ["86", "CHN", "CN"],
-  ["852", "HKG", "HK"],
-  ["853", "MAC", "MO"],
-  ["61", "CXR", "CX"],
-  ["61", "CCK", "CC"],
-  ["57", "COL", "CO"],
-  ["269", "COM", "KM"],
-  ["242", "COG", "CG"],
-  ["682", "COK", "CK"],
-  ["506", "CRI", "CR"],
-  ["385", "HRV", "HR"],
-  ["53", "CUB", "CU"],
-  ["599", "CUW", "CW"],
-  ["357", "CYP", "CY"],
-  ["420", "CZE", "CZ"],
-  ["225", "CIV", "CI"],
-  ["850", "PRK", "KP"],
-  ["243", "COD", "CD"],
-  ["45", "DNK", "DK"],
-  ["253", "DJI", "DJ"],
-  ["1-767", "DMA", "DM"],
-  ["1-809", "DOM", "DO"],
-  ["1-829", "DOM", "DO"],
-  ["1-849", "DOM", "DO"],
-  ["593", "ECU", "EC"],
-  ["20", "EGY", "EG"],
-  ["503", "SLV", "SV"],
-  ["240", "GNQ", "GQ"],
-  ["291", "ERI", "ER"],
-  ["372", "EST", "EE"],
-  ["268", "SWZ", "SZ"],
-  ["251", "ETH", "ET"],
-  ["500", "FLK", "FK"],
-  ["298", "FRO", "FO"],
-  ["679", "FJI", "FJ"],
-  ["358", "FIN", "FI"],
-  ["33", "FRA", "FR"],
-  ["594", "GUF", "GF"],
-  ["689", "PYF", "PF"],
-  ["262", "ATF", "TF"],
-  ["241", "GAB", "GA"],
-  ["220", "GMB", "GM"],
-  ["995", "GEO", "GE"],
-  ["49", "DEU", "DE"],
-  ["233", "GHA", "GH"],
-  ["350", "GIB", "GI"],
-  ["30", "GRC", "GR"],
-  ["299", "GRL", "GL"],
-  ["1-473", "GRD", "GD"],
-  ["590", "GLP", "GP"],
-  ["1-671", "GUM", "GU"],
-  ["502", "GTM", "GT"],
-  ["44", "GGY", "GG"],
-  ["224", "GIN", "GN"],
-  ["245", "GNB", "GW"],
-  ["592", "GUY", "GY"],
-  ["509", "HTI", "HT"],
-  ["672", "HMD", "HM"],
-  ["39-06", "VAT", "VA"],
-  ["504", "HND", "HN"],
-  ["36", "HUN", "HU"],
-  ["354", "ISL", "IS"],
-  ["91", "IND", "IN"],
-  ["62", "IDN", "ID"],
-  ["98", "IRN", "IR"],
-  ["964", "IRQ", "IQ"],
-  ["353", "IRL", "IE"],
-  ["44", "IMN", "IM"],
-  ["972", "ISR", "IL"],
-  ["39", "ITA", "IT"],
-  ["1-876", "JAM", "JM"],
-  ["81", "JPN", "JP"],
-  ["44", "JEY", "JE"],
-  ["962", "JOR", "JO"],
-  ["7", "KAZ", "KZ"],
-  ["254", "KEN", "KE"],
-  ["686", "KIR", "KI"],
-  ["965", "KWT", "KW"],
-  ["996", "KGZ", "KG"],
-  ["856", "LAO", "LA"],
-  ["371", "LVA", "LV"],
-  ["961", "LBN", "LB"],
-  ["266", "LSO", "LS"],
-  ["231", "LBR", "LR"],
-  ["218", "LBY", "LY"],
-  ["423", "LIE", "LI"],
-  ["370", "LTU", "LT"],
-  ["352", "LUX", "LU"],
-  ["261", "MDG", "MG"],
-  ["265", "MWI", "MW"],
-  ["60", "MYS", "MY"],
-  ["960", "MDV", "MV"],
-  ["223", "MLI", "ML"],
-  ["356", "MLT", "MT"],
-  ["692", "MHL", "MH"],
-  ["596", "MTQ", "MQ"],
-  ["222", "MRT", "MR"],
-  ["230", "MUS", "MU"],
-  ["262", "MYT", "YT"],
-  ["52", "MEX", "MX"],
-  ["691", "FSM", "FM"],
-  ["377", "MCO", "MC"],
-  ["976", "MNG", "MN"],
-  ["382", "MNE", "ME"],
-  ["1-664", "MSR", "MS"],
-  ["212", "MAR", "MA"],
-  ["258", "MOZ", "MZ"],
-  ["95", "MMR", "MM"],
-  ["264", "NAM", "NA"],
-  ["674", "NRU", "NR"],
-  ["977", "NPL", "NP"],
-  ["31", "NLD", "NL"],
-  ["687", "NCL", "NC"],
-  ["64", "NZL", "NZ"],
-  ["505", "NIC", "NI"],
-  ["227", "NER", "NE"],
-  ["234", "NGA", "NG"],
-  ["683", "NIU", "NU"],
-  ["672", "NFK", "NF"],
-  ["1-670", "MNP", "MP"],
-  ["47", "NOR", "NO"],
-  ["968", "OMN", "OM"],
-  ["92", "PAK", "PK"],
-  ["680", "PLW", "PW"],
-  ["507", "PAN", "PA"],
-  ["675", "PNG", "PG"],
-  ["595", "PRY", "PY"],
-  ["51", "PER", "PE"],
-  ["63", "PHL", "PH"],
-  ["870", "PCN", "PN"],
-  ["48", "POL", "PL"],
-  ["351", "PRT", "PT"],
-  ["974", "QAT", "QA"],
-  ["82", "KOR", "KR"],
-  ["373", "MDA", "MD"],
-  ["40", "ROU", "RO"],
-  ["7", "RUS", "RU"],
-  ["250", "RWA", "RW"],
-  ["262", "REU", "RE"],
-  ["590", "BLM", "BL"],
-  ["290", "SHN", "SH"],
-  ["1-869", "KNA", "KN"],
-  ["1-758", "LCA", "LC"],
-  ["590", "MAF", "MF"],
-  ["508", "SPM", "PM"],
-  ["1-784", "VCT", "VC"],
-  ["685", "WSM", "WS"],
-  ["378", "SMR", "SM"],
-  ["239", "STP", "ST"],
-  ["966", "SAU", "SA"],
-  ["221", "SEN", "SN"],
-  ["381", "SRB", "RS"],
-  ["248", "SYC", "SC"],
-  ["232", "SLE", "SL"],
-  ["65", "SGP", "SG"],
-  ["1-721", "SXM", "SX"],
-  ["421", "SVK", "SK"],
-  ["386", "SVN", "SI"],
-  ["677", "SLB", "SB"],
-  ["252", "SOM", "SO"],
-  ["27", "ZAF", "ZA"],
-  ["500", "SGS", "GS"],
-  ["211", "SSD", "SS"],
-  ["34", "ESP", "ES"],
-  ["94", "LKA", "LK"],
-  ["970", "PSE", "PS"],
-  ["249", "SDN", "SD"],
-  ["597", "SUR", "SR"],
-  ["47", "SJM", "SJ"],
-  ["46", "SWE", "SE"],
-  ["41", "CHE", "CH"],
-  ["963", "SYR", "SY"],
-  ["992", "TJK", "TJ"],
-  ["66", "THA", "TH"],
-  ["389", "MKD", "MK"],
-  ["670", "TLS", "TL"],
-  ["228", "TGO", "TG"],
-  ["690", "TKL", "TK"],
-  ["676", "TON", "TO"],
-  ["1-868", "TTO", "TT"],
-  ["216", "TUN", "TN"],
-  ["90", "TUR", "TR"],
-  ["993", "TKM", "TM"],
-  ["1-649", "TCA", "TC"],
-  ["688", "TUV", "TV"],
-  ["256", "UGA", "UG"],
-  ["380", "UKR", "UA"],
-  ["971", "ARE", "AE"],
-  ["44", "GBR", "GB"],
-  ["255", "TZA", "TZ"],
-  ["1-340", "VIR", "VI"],
-  ["1", "USA", "US"],
-  ["598", "URY", "UY"],
-  ["998", "UZB", "UZ"],
-  ["678", "VUT", "VU"],
-  ["58", "VEN", "VE"],
-  ["84", "VNM", "VN"],
-  ["681", "WLF", "WF"],
-  ["212", "ESH", "EH"],
-  ["967", "YEM", "YE"],
-  ["260", "ZMB", "ZM"],
-  ["263", "ZWE", "ZW"],
-  ["358", "ALA", "AX"]
-];
-
-// dist/constants/ProxmoxConstants.js
-var PROXMOX_CT_STATE = [
-  "started",
-  "stopped",
-  "enabled",
-  "disabled",
-  "ignored"
-];
-
-// 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/api/defineApi.js
-var asEscapeFunction = (fn2) => createFnWithProps(fn2, { escape: true });
-var asOptionalParamFunction = (fn2) => createFnWithProps(fn2, { optionalParams: true });
-var asApi = (api) => isApi(api) ? api : isApiSurface(api) ? { _kind: "api", surface: api } : createErrorCondition("invalid-api");
-var asCallbackProp = (...args) => args;
-var getEscapeFunction = (api) => {
-  const surface = api.surface;
-  return isFunction(surface) && "escape" in surface && surface.escape === true ? surface : isObject(surface) ? surface[Object.keys(surface).find((k) => isEscapeFunction(surface[k]))] : Never;
-};
-var defaultApiHandler = (_api) => {
-  return (_result) => {
-  };
-};
-var cb = (api) => (cb2) => {
-  try {
-    return cb2(api.surface);
-  } catch (e) {
-    throw new Error("oops");
-  }
-};
-var asApiCallback = (api) => cb(api);
-var asHandledApiCallback = (api, handler) => {
-  let _h = handler ? handler : defaultApiHandler;
-  let _cb = asApiCallback(api);
-};
-
-// dist/runtime/api/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 stripper = strip.find((i) => content.startsWith(i));
-  return stripper ? (
-    // starts with
-    content.slice(stripper.length)
-  ) : (
-    // 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/split.js
-function split(str, sep = "") {
-  return str.split(sep);
-}
-
-// 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/literals/takeNumericCharacters.js
-var takeNumericCharacters = (content) => {
-  let nonNumericIdx = asChars(content).findIndex((i) => !NUMERIC_CHAR.includes(i));
-  return content.slice(0, nonNumericIdx);
-};
-
-// dist/runtime/type-conversion/asChars.js
-var asChars = (str) => {
-  return str.split("");
-};
-
-// dist/runtime/literals/retainChars.js
-var retainChars = (content, ...retain2) => {
-  return asChars(content).filter((c) => retain2.includes(c)).join("");
-};
-
-// dist/runtime/literals/stripChars.js
-var stripChars = (content, ...strip) => {
-  return asChars(content).filter((c) => !strip.includes(c)).join("");
-};
-
-// 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-guards/isUndefined.js
-function isUndefined(value) {
-  return typeof value === "undefined" ? true : false;
-}
-
-// 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 union = (...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/type-conversion/ip6GroupExpansion.js
-var ip6GroupExpansion = (ip) => {
-  return stripTrailing(ip.replaceAll("::", ":0000:"), ":");
-};
-
-// dist/runtime/literals/retainWhile.js
-var retainWhile = (content, ...retain2) => {
-  const stopIdx = asChars(content).findIndex((c) => !retain2.includes(c));
-  return content.slice(0, stopIdx);
-};
-
-// dist/runtime/literals/asPhoneNumber.js
-var getPhoneCountryCode = (phone) => {
-  return phone.trim().startsWith("+") || phone.trim().startsWith("00") ? retainWhile(stripLeading(stripLeading(phone.trim(), "+"), "00"), ...NUMERIC_CHAR) : "";
-};
-var removePhoneCountryCode = (phone) => {
-  const countryCode = getPhoneCountryCode(phone);
-  return countryCode !== "" ? stripLeading(stripLeading(phone.trim(), "+", "00"), countryCode).trim() : phone.trim();
-};
-var convert = (countryCode, phone, delimiter, para) => {
-  const parts = stripChars(phone, "(", ")").trim().split(/[-. ]/);
-  const isRegional = parts.length === 2 ? true : false;
-  const isCountry = parts.length === 3 ? true : false;
-  const isShortCode = parts.length === 1 && asChars(phone).length < 7 ? true : false;
-  const replacement = isShortCode ? phone : isRegional ? parts.join(delimiter) : isCountry && para ? `(${parts[0]}) ${parts.slice(1).join(delimiter)}` : isCountry ? parts.join(delimiter) : void 0;
-  if (!replacement) {
-    throw new Error(`invalid phone number: ${phone}. Unable to parse!`);
-  }
-  return countryCode === "" ? replacement : `+${countryCode} ${replacement}`;
-};
-var asPhoneNumber = (phone, format = "Dotted (e.g., 456.555.1212)") => {
-  if (!isPhoneNumber(phone)) {
-    throw new Error(`Invalid phone number presented to asPhoneNumber(phone,format)!`);
-  }
-  const countryCode = getPhoneCountryCode(phone);
-  const remaining = removePhoneCountryCode(phone);
-  let result2;
-  switch (format) {
-    case "Dashed (e.g., 456-555-1212)":
-      result2 = convert(countryCode, remaining, "-", false);
-      break;
-    case "Dotted (e.g., 456.555.1212)":
-      result2 = convert(countryCode, remaining, ".", false);
-      break;
-    case "ParaDashed (e.g., (456) 555-1212)":
-      result2 = convert(countryCode, remaining, "-", true);
-      break;
-    case "ParaSpaced (e.g., (456) 555 1212)":
-      result2 = convert(countryCode, remaining, " ", true);
-      break;
-  }
-  return result2;
-};
-
-// 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/functions/wrapFn.js
-var wrapFn = "NOT IMPLEMENTED";
-
-// 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/boolean-logic/ifNotNull.js
-function ifNotNull(val, ifVal, elseVal) {
-  return isNull(val) ? elseVal() : ifVal(val);
-}
-
-// 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/meta/youtube-meta.js
-var getYouTubePageType = (url) => {
-  return isYouTubeUrl(url) ? isYouTubeVideoUrl(url) && (hasUrlQueryParameter(url, "v") || isYouTubeShareUrl(url)) ? hasUrlQueryParameter(url, "list") ? isYouTubeShareUrl(url) ? hasUrlQueryParameter(url, "t") ? `play::video::in-list::share-link::with-timestamp` : `play::video::in-list::share-link` : `play::video::in-list` : isYouTubeShareUrl(url) ? hasUrlQueryParameter(url, "t") ? `play::video::solo::share-link::with-timestamp` : `play::video::solo::share-link` : `play::video::solo` : isYouTubeCreatorUrl(url) ? getUrlPath(url).includes("/videos") ? "creator::videos" : getUrlPath(url).includes("/playlists") ? "creator::playlists" : last(getUrlPath(url).split("/")).startsWith("@") || getUrlPath(url).includes("/featured") ? "creator::featured" : "creator::other" : isYouTubeFeedUrl(url) ? isYouTubeFeedUrl(url, "history") ? "feed::history" : isYouTubeFeedUrl(url, "playlists") ? "feed::playlists" : isYouTubeFeedUrl(url, "liked") ? "feed::liked" : isYouTubeFeedUrl(url, "subscriptions") ? "feed::subscriptions" : isYouTubeFeedUrl(url, "trending") ? "feed::trending" : "feed::other" : isYouTubeVideosInPlaylist(url) ? "playlist::show" : "other" : Never;
-};
-var youtubeMeta = (url) => {
-  return isYouTubeUrl(url) ? {
-    url,
-    isYouTubeUrl: true,
-    isShareUrl: isYouTubeShareUrl(url),
-    pageType: getYouTubePageType(url)
-  } : {
-    url,
-    isYouTubeUrl: false
-  };
-};
-
-// dist/runtime/meta/urlMeta.js
-var PROTOCOLS = Object.values(NETWORK_PROTOCOL_LOOKUP).flat().filter((i) => i !== "");
-var getUrlProtocol = (url) => {
-  const proto = PROTOCOLS.find((p) => url.startsWith(`${p}://`));
-  return proto;
-};
-var removeUrlProtocol = (url) => {
-  return stripBefore(url, "://");
-};
-var ensurePath = (val) => val === "" ? "" : stripTrailing(ensureLeading(val, "/"), "/");
-var getUrlPath = (url) => {
-  return isUrl(url) ? ensurePath(stripAfter(stripBefore(removeUrlProtocol(url), "/"), "?")) : Never;
-};
-var getUrlQueryParams = (url) => {
-  const qp = stripBefore(url, "?");
-  return qp === "" ? qp : `?${qp}`;
-};
-var getUrlPort = (url) => {
-  const candidate = takeNumericCharacters(stripBefore(removeUrlProtocol(url), ":"));
-  return candidate === "" ? "default" : Number(candidate);
-};
-var getUrlSource = (url) => {
-  const candidate = stripAfter(stripAfter(stripAfter(removeUrlProtocol(url), "/"), "?"), ":");
-  return isIpAddress(candidate) || isDomainName(candidate) ? candidate : Never;
-};
-var urlMeta = (url) => {
-  return {
-    url,
-    isUrl: isUrl(url),
-    protocol: getUrlProtocol(url),
-    path: getUrlPath(url),
-    queryParameters: getUrlQueryParams(url),
-    port: getUrlPort(url),
-    source: getUrlSource(url),
-    isIpAddress: isIpAddress(getUrlSource(url)),
-    isIp4Address: isIp4Address(getUrlSource(url)),
-    isIp6Address: isIp6Address(getUrlSource(url))
-  };
-};
-
-// 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 union2 = (...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: union2,
-  fn,
-  record,
-  array,
-  set,
-  map,
-  weakMap,
-  dictionary,
-  tuple: tuple2
-};
-var shape = (cb2) => {
-  const rtn = cb2(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/type-guards/isArray.js
-function isArray(value) {
-  return Array.isArray(value) === true;
-}
-
-// 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-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/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/isConstant.js
-function isConstant(value) {
-  return isObject(value) && "_type" in value && "kind" in value && 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/isSpecificConstant.js
-function isSpecificConstant(kind) {
-  return (value) => {
-    return isConstant(value) && 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/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/isUrl.js
-var isUri = (val, ...protocols) => {
-  const p = protocols.length === 0 ? valuesOf(NETWORK_PROTOCOL_LOOKUP).flat().filter((i) => i) : protocols;
-  return isString(val) && p.some((i) => val.startsWith(`${i}://`));
-};
-var isUrl = (val, ...protocols) => {
-  const p = protocols.length === 0 ? ["http", "https"] : protocols;
-  return isString(val) && p.some((i) => val.startsWith(`${i}://`));
-};
-
-// dist/runtime/type-guards/isCssAspectRatio.js
-var tokens = [
-  "1",
-  "inherit",
-  "initial",
-  "revert",
-  "revert-layer",
-  "unset",
-  "auto"
-];
-var isRatio = (val) => /[0-9]{1,4}\s*\/\s*[0-9]{1,4}/.test(val);
-var isCssAspectRatio = (val) => {
-  return isString(val) && val.split(/\s+/).every((i) => tokens.includes(i) || isRatio(i));
-};
-
-// dist/runtime/type-guards/isInlineSvg.js
-var isInlineSvg = (v) => {
-  return isString(v) && v.trim().startsWith(`<svg`) && v.trim().endsWith(`</svg>`);
-};
-
-// dist/runtime/type-guards/isAlpha.js
-var isAlpha = (value) => {
-  return isString(value) && split(value).every((v) => ALPHA_CHARS.includes(v));
-};
-
-// dist/runtime/type-guards/isHexadecimal.js
-var isHexadecimal = (val) => {
-  return isString(val) && asChars(val).every((i) => isNumericString(i) || ["a", "b", "c", "d", "e", "f"].includes(i.toLowerCase()));
-};
-
-// dist/runtime/type-guards/network-tg.js
-var isIp4Address = (val) => {
-  return isString(val) && val.split(".").length === 4 && val.split(".").every((i) => isNumericString(i)) && val.split(".").every((i) => Number(i) >= 0 && Number(i) <= 255);
-};
-var isIp6Address = (val) => {
-  const expanded = isString(val) ? ip6GroupExpansion(val) : "";
-  return isString(val) && isString(expanded) && expanded.split(":").every((i) => asChars(i).length >= 1 && asChars(i).length <= 4) && expanded.split(":").every((i) => isHexadecimal(i));
-};
-var isIpAddress = (val) => {
-  return isIp4Address(val) || isIp6Address(val);
-};
-var hasUrlPort = (val) => {
-  return isString(val) && asChars(removeUrlProtocol(val)).some((i) => i === ":");
-};
-var isUrlPath = (val) => {
-  return isString(val) && (val === "" || val.startsWith("/")) && asChars(val).every((c) => isAlpha(c) || isNumericString(c) || c === "_" || c === "@" || c === "." || c === "-");
-};
-var isDomainName = (val) => {
-  return isString(val) && val.split(".").filter((i) => i).length > 1 && isString(val.split(".").filter((i) => i).pop()) && asChars(val.split(".").filter((i) => i).pop()).length > 1 && val.split(".").filter((i) => i).every((i) => isAlpha(i) || isNumericString(i) || i === "-" || i === "_");
-};
-var isUrlSource = (val) => {
-  return isDomainName(val) || isIpAddress(val);
-};
-var hasUrlQueryParameter = (val, prop) => {
-  const re = new RegExp(`${prop}=`);
-  return isString(val) && re.test(getUrlQueryParams(val));
-};
-
-// dist/runtime/type-guards/youtube.js
-var isYouTubeUrl = (val) => {
-  return isString(val) && (val.startsWith("https://www.youtube.com") || val.startsWith("https://youtube.com") || val.startsWith("https://youtu.be"));
-};
-var isYouTubeShareUrl = (val) => {
-  return isString(val) && val.startsWith(`https://youtu.be`);
-};
-var isYouTubeVideoUrl = (val) => {
-  return isString(val) && (val.startsWith("https://www.youtube.com") || val.startsWith("https://youtube.com") || val.startsWith("https://youtu.be"));
-};
-var isYouTubePlaylistUrl = (val) => {
-  return isString(val) && (val === `https://www.youtube.com/feed/playlists` || val === `https://youtube.com/feed/playlists` || val === `https://www.youtube.com/channel/playlists` || val === `https://youtube.com/channel/playlists` || val.startsWith(`https://www.youtube.com/@`) && val.endsWith(`/playlists`) || val.startsWith(`https://youtube.com/@`) && val.endsWith(`/playlists`));
-};
-var feed_map = (type) => {
-  return isUndefined(type) ? `/feed` : type === "liked" ? `/playlist?list=LL` : ["history", "playlists", "trending", "subscriptions"].includes(type) ? `/feed/${type}` : `/feed/`;
-};
-var isYouTubeFeedUrl = (val, type = void 0) => {
-  return isString(val) && (val.startsWith(`https://www.youtube.com${feed_map(type)}`) || val.startsWith(`https://youtube.com${feed_map(type)}`));
-};
-var isYouTubeCreatorUrl = (url) => {
-  return isString(url) && (url.startsWith(`https://www.youtube.com/@`) || url.startsWith(`https://youtube.com/@`) || url.startsWith(`https://www.youtube.com/channel/`));
-};
-var isYouTubeVideosInPlaylist = (val) => {
-  return isString(val) && (val.startsWith(`https://www.youtube.com/playlist?`) || val.startsWith(`https://youtube.com/playlist?`)) && hasUrlQueryParameter(val, "list");
-};
-
-// dist/runtime/type-guards/repos.js
-var isRepoSource = (v) => {
-  return isString(v) && REPO_SOURCES.includes(v);
-};
-var isSemanticVersion = (v, allowPrefix = false) => {
-  return isString(v) && v.split(".").length === 3 && !Number.isNaN(Number(v.split(".")[1])) && !Number.isNaN(Number(v.split(".")[2])) && (!Number.isNaN(Number(v.split(".")[0])) || allowPrefix && !Number.isNaN(Number(stripLeading(v.split(".")[0], "v").trim())));
-};
-var isRepoUrl = (val) => {
-  const baseUrls = valuesOf(REPO_SOURCE_LOOKUP).flat();
-  return isString(val) && baseUrls.every((u) => val === u || val.startsWith(`${u}/`));
-};
-var isGithubUrl = (val) => {
-  const baseUrls = REPO_SOURCE_LOOKUP["github"];
-  return isString(val) && baseUrls.every((u) => val === u || val.startsWith(`${u}/`));
-};
-var isGithubRepoUrl = (val) => {
-  const baseUrls = [""];
-  return isString(val) && baseUrls.every((u) => val === u || val.startsWith(`${u}/`));
-};
-var isBitbucketUrl = (val) => {
-  const baseUrls = REPO_SOURCE_LOOKUP["bitbucket"];
-  return isString(val) && baseUrls.every((u) => val === u || val.startsWith(`${u}/`));
-};
-var isCodeCommitUrl = (val) => {
-  const baseUrls = REPO_SOURCE_LOOKUP["codecommit"];
-  return isString(val) && baseUrls.every((u) => val === u || val.startsWith(`${u}/`));
-};
-
-// dist/runtime/type-guards/isTrimmable.js
-var isTrimable = (val) => {
-  return isString(val) && val !== val.trim();
-};
-
-// dist/runtime/type-guards/hasWhitespace.js
-var hasWhiteSpace = (val) => {
-  return isString(val) && asChars(val).some((c) => WHITESPACE_CHARS.includes(c));
-};
-
-// dist/runtime/type-guards/isEmail.js
-var isEmail = (val) => {
-  return isString(val) && (val.split("@").length === 2 && val.split("@")[1].split(".").length > 1 && asChars(last(val.split("@")[1].split("."))).length > 1);
-};
-
-// dist/runtime/type-guards/isPhoneNumber.js
-var isPhoneNumber = (val) => {
-  return isString(val) && ["+", "(", ...NUMERIC_CHAR].includes(asChars(val.trim())[0]) && [...NUMERIC_CHAR].includes([...asChars(val.trim())].pop()) && (val.trim().startsWith(`+`) ? asChars(retainChars(val, ...NUMERIC_CHAR)).length >= 8 : val.trim().startsWith("00") ? asChars(retainChars(val, ...NUMERIC_CHAR)).length >= 10 : asChars(retainChars(val, ...NUMERIC_CHAR)).length >= 7) && stripChars(val, ...NUMERIC_CHAR, ...WHITESPACE_CHARS, "(", ")", "+", ".", "-") === "";
-};
-
-// dist/runtime/type-guards/isUnset.js
-var isUnset = (val) => {
-  return isObject(val) && val.kind === "Unset";
-};
-var isSet = (val) => {
-  return isObject(val) ? val.kind !== "Unset" ? true : false : true;
-};
-
-// dist/runtime/type-guards/api-tg.js
-var isEscapeFunction = (val) => {
-  return isFunction(val) && "escape" in val && val.escape === true;
-};
-var isOptionalParamFunction = (val) => {
-  return isFunction(val) && "optionalParams" in val && val.optionalParams === true;
-};
-var isApi = (api) => {
-  return isObject(api) && "surface" in api && "_kind" in api && api._kind === "api";
-};
-var isApiSurface = (val) => {
-  return isObject(val) && Object.keys(val).some((k) => isEscapeFunction(val[k]));
-};
-
-// dist/runtime/boolean-logic/ifString.js
-function ifString(val, ifVal, elseVal) {
-  return isString(val) ? ifVal(val) : elseVal(val);
-}
-
-// dist/runtime/boolean-logic/ifNumber.js
-function ifNumber(val, ifVal, elseVal) {
-  return isNumber(val) ? ifVal(val) : elseVal(val);
-}
-
-// 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/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/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/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,
-  GITHUB_INSIGHT_CATEGORY_LOOKUP,
-  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,
-  NETWORK_PROTOCOL_LOOKUP,
-  NON_ZERO_NUMERIC_CHAR,
-  NOT_APPLICABLE,
-  NOT_DEFINED,
-  NO_DEFAULT_VALUE,
-  NUMERIC_CHAR,
-  NUMERIC_DIGIT,
-  Never,
-  OPTION,
-  PHONE_COUNTRY_CODES,
-  PHONE_FORMAT,
-  PLURAL_EXCEPTIONS,
-  PLURAL_EXCEPTIONS_OLD,
-  PROXMOX_CT_STATE,
-  REPO_PAGE_TYPES,
-  REPO_SOURCES,
-  REPO_SOURCE_LOOKUP,
-  RESULT,
-  SHAPE_DELIMITER,
-  SHAPE_PREFIXES,
-  SINGULAR_NOUN_ENDINGS,
-  ShapeApiImplementation,
-  TOP_LEVEL_DOMAINS,
-  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,
-  WHITESPACE_CHARS,
-  WIDE_CONTAINER_TYPE_KINDS,
-  WIDE_TYPE_KINDS,
-  WideAssignment,
-  ZIP_TO_STATE,
-  addFnToProps,
-  addPropsToFn,
-  and,
-  asApi,
-  asApiCallback,
-  asArray,
-  asCallbackProp,
-  asChars,
-  asEscapeFunction,
-  asHandledApiCallback,
-  asOptionalParamFunction,
-  asPhoneNumber,
-  asRecord,
-  asString,
-  asVueRef,
-  box,
-  boxDictionaryValues,
-  capitalize,
-  choices,
-  createConstant,
-  createConverter,
-  createErrorCondition,
-  createFnWithProps,
-  defineObj,
-  defineTuple,
-  dict,
-  endsWith,
-  ensureLeading,
-  ensureSurround,
-  ensureTrailing,
-  entries,
-  find,
-  fnMeta,
-  get,
-  getEach,
-  getEscapeFunction,
-  getPhoneCountryCode,
-  getUrlPath,
-  getUrlPort,
-  getUrlProtocol,
-  getUrlQueryParams,
-  getUrlSource,
-  getYouTubePageType,
-  handleDoneFn,
-  hasDefaultValue,
-  hasIndexOf,
-  hasKeys,
-  hasUrlPort,
-  hasUrlQueryParameter,
-  hasWhiteSpace,
-  idLiteral,
-  idTypeGuard,
-  identity,
-  ifLowercaseChar,
-  ifUppercaseChar,
-  indexOf,
-  intersect,
-  intersection,
-  ip6GroupExpansion,
-  ip6Prefix,
-  isApi,
-  isApiSurface,
-  isArray,
-  isBitbucketUrl,
-  isBoolean,
-  isBox,
-  isCodeCommitUrl,
-  isConstant,
-  isContainer,
-  isCssAspectRatio,
-  isDefined,
-  isDomainName,
-  isDoneFn,
-  isEmail,
-  isEqual,
-  isErrorCondition,
-  isEscapeFunction,
-  isFalse,
-  isFalsy,
-  isFnWithParams,
-  isFunction,
-  isGithubRepoUrl,
-  isGithubUrl,
-  isHexadecimal,
-  isIndexable,
-  isInlineSvg,
-  isIp4Address,
-  isIp6Address,
-  isIpAddress,
-  isLength,
-  isNever,
-  isNotNull,
-  isNothing,
-  isNull,
-  isNumber,
-  isNumericString,
-  isObject,
-  isOptionalParamFunction,
-  isPhoneNumber,
-  isReadonlyArray,
-  isRef,
-  isRepoSource,
-  isRepoUrl,
-  isSameTypeOf,
-  isScalar,
-  isSemanticVersion,
-  isSet,
-  isShape,
-  isSpecificConstant,
-  isString,
-  isSymbol,
-  isTrimable,
-  isTrue,
-  isTruthy,
-  isTuple,
-  isTypeOf,
-  isTypeToken,
-  isTypeTuple,
-  isUndefined,
-  isUnset,
-  isUri,
-  isUrl,
-  isUrlPath,
-  isUrlSource,
-  isYouTubeCreatorUrl,
-  isYouTubeFeedUrl,
-  isYouTubePlaylistUrl,
-  isYouTubeShareUrl,
-  isYouTubeUrl,
-  isYouTubeVideoUrl,
-  isYouTubeVideosInPlaylist,
-  join,
-  keysOf,
-  kindError,
-  kindLiteral,
-  last,
-  list,
-  literal,
-  logicalReturns,
-  lowercase,
-  mergeObjects,
-  mergeScalars,
-  mergeTuples,
-  nameLiteral,
-  narrow,
-  never,
-  omit,
-  optional,
-  or,
-  parse,
-  pathJoin,
-  pluralize,
-  pop,
-  removePhoneCountryCode,
-  removeUrlProtocol,
-  result,
-  retain,
-  retainAfter,
-  retainChars,
-  retainWhile,
-  reverse,
-  shape,
-  sharedKeys,
-  shift,
-  slice,
-  split,
-  startsWith,
-  stripAfter,
-  stripBefore,
-  stripChars,
-  stripLeading,
-  stripTrailing,
-  surround,
-  takeNumericCharacters,
-  takeProp,
-  toCamelCase,
-  toKebabCase,
-  toNumber,
-  toNumericArray,
-  toPascalCase,
-  toSnakeCase,
-  toString,
-  toUppercase,
-  trim,
-  trimEnd,
-  trimLeft,
-  trimRight,
-  trimStart,
-  truncate,
-  tuple,
-  unbox,
-  uncapitalize,
-  union,
-  unionize,
-  unique,
-  uniqueKeys,
-  uppercase,
-  urlMeta,
-  valuesOf,
-  widen,
-  withDefaults,
-  withKeys,
-  withoutKeys,
-  withoutValue,
-  wrapFn,
-  youtubeMeta
-});