inferred-types 0.50.0 → 0.50.2

package/dist/index.js

@@ -0,0 +1,3988 @@
+// src/constants/createConstant.ts
+function createConstant(kind) {
+  return {
+    _type: "Constant",
+    kind
+  };
+}
+
+// src/constants/NoDefaultValue.ts
+var NO_DEFAULT_VALUE = createConstant("no-default-value");
+
+// src/constants/NotApplicable.ts
+var NOT_APPLICABLE = Symbol("not applicable");
+
+// src/constants/DateTime.ts
+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"
+];
+
+// src/constants/Types.ts
+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
+];
+
+// src/constants/Comma.ts
+var COMMA = createConstant("comma");
+
+// src/constants/Functional.ts
+var RESULT = {
+  Ok: "ok",
+  Err: "err"
+};
+var OPTION = {
+  Some: 1,
+  None: 0
+};
+
+// src/constants/Images.ts
+var IMAGE_FORMAT_LOOKUP = [
+  { ext: "jpg", webFormat: true, other_ext: ["jpeg"] },
+  { ext: "png", webFormat: true, other_ext: [] },
+  { ext: "gif", webFormat: true, other_ext: [] },
+  { ext: "heif", webFormat: true, other_ext: [] },
+  { ext: "svg", webFormat: true, other_ext: [] },
+  { ext: "raw", webFormat: false, other_ext: [] },
+  { ext: "dng", webFormat: false, other_ext: [] },
+  { ext: "avif", webFormat: true, other_ext: [] },
+  { ext: "webp", webFormat: true, other_ext: [] },
+  { ext: "tiff", webFormat: false, other_ext: ["tif"] }
+];
+
+// src/constants/Alpha.ts
+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
+];
+
+// src/constants/Consonants.ts
+var CONSONANTS = [
+  "b",
+  "c",
+  "d",
+  "f",
+  "g",
+  "h",
+  "j",
+  "k",
+  "l",
+  "m",
+  "n",
+  "p",
+  "q",
+  "r",
+  "s",
+  "t",
+  "v",
+  "w",
+  "x",
+  "z",
+  "y"
+];
+
+// src/constants/PluralExceptions.ts
+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"
+};
+
+// src/constants/SingularNounEnding.ts
+var SINGULAR_NOUN_ENDINGS = [
+  "s",
+  "sh",
+  "ch",
+  "x",
+  "z",
+  "o"
+];
+
+// src/constants/CommonObjProps.ts
+var COMMON_OBJ_PROPS = [
+  "id",
+  "type",
+  "kind",
+  "_type",
+  "_kind",
+  "key",
+  "value",
+  "name"
+];
+
+// src/constants/NumericChar.ts
+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"
+];
+
+// src/constants/NumericDigit.ts
+var NUMERIC_DIGIT = [
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9
+];
+
+// src/constants/FalsyValues.ts
+var FALSY_VALUES = [
+  false,
+  0,
+  -0,
+  "",
+  null,
+  void 0,
+  Number.NaN
+];
+
+// src/constants/NotDefined.ts
+var NOT_DEFINED = createConstant("not-defined");
+
+// src/constants/TypeOf.ts
+var TYPE_OF = ["string", "number", "boolean", "undefined", "symbol", "bigint", "function", "object"];
+
+// src/constants/Wide.ts
+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>>",
+  something: () => "<<something>>"
+};
+
+// src/constants/TypeComparisons.ts
+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())
+};
+
+// src/constants/TypeTransforms.ts
+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"]
+};
+
+// src/constants/Never.ts
+var Never = createConstant("never");
+
+// src/constants/TypeTokens.ts
+var SIMPLE_DICT_VALUES = [
+  "string",
+  "number",
+  "boolean",
+  "unknown",
+  "Opt<string>",
+  "Opt<number>",
+  "Opt<boolean>",
+  "Opt<unknown>"
+];
+var SIMPLE_SET_TYPES = [
+  "string",
+  "number",
+  "boolean",
+  "unknown",
+  "Opt<string>",
+  "Opt<number>",
+  "Opt<boolean>",
+  "Opt<unknown>"
+];
+var SIMPLE_SCALAR_TOKENS = [
+  "string",
+  "number",
+  `string(TOKEN)`,
+  `number(TOKEN)`,
+  "boolean",
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "unknown",
+  "any",
+  "never"
+];
+var SIMPLE_OPT_SCALAR_TOKENS = [
+  "Opt<string>",
+  "Opt<number>",
+  "Opt<boolean>",
+  "Opt<true>",
+  "Opt<false>",
+  "Opt<null>",
+  "Opt<undefined>",
+  "Opt<unknown>",
+  "Opt<any>",
+  "Opt<string(TOKEN)>",
+  "Opt<number(TOKEN)>",
+  "Opt<undefined>"
+];
+var SIMPLE_UNION_TOKENS = [
+  `Union(TOKEN)`
+];
+var SIMPLE_MAP_KEYS = [
+  "string",
+  "number",
+  "Dict",
+  "Dict<string, string>",
+  "Dict<string, number>",
+  "Dict<string, boolean>",
+  "Dict<string, unknown>",
+  "Dict<string, Opt<string>>",
+  "Dict<string, Opt<number>>",
+  "Dict<string, Opt<boolean>>"
+];
+var SIMPLE_MAP_VALUES = [
+  ...SIMPLE_MAP_KEYS,
+  "boolean",
+  "unknown",
+  "undefined",
+  "Dict",
+  "Array",
+  "Dict<string, Opt<string>>",
+  "Dict<string, Opt<number>>",
+  "Dict<string, Opt<boolean>>",
+  "Dict<string, Opt<unknown>>"
+];
+var SIMPLE_DICT_TOKENS = [
+  "Dict",
+  "Dict<string, string>",
+  "Dict<string, number>",
+  "Dict<string, boolean>",
+  "Dict<string, unknown>",
+  "Dict<string, Opt<string>>",
+  "Dict<string, Opt<number>>",
+  "Dict<string, Opt<boolean>>",
+  "Dict<string, Opt<unknown>>",
+  "Dict<{TOKEN: TOKEN}>",
+  "Dict<{TOKEN: TOKEN, TOKEN: TOKEN}>"
+];
+var SIMPLE_ARRAY_TOKENS = [
+  "Array",
+  "Array<string>",
+  "Array<string(TOKEN)>",
+  "Array<number>",
+  "Array<number(TOKEN)>",
+  "Array<boolean>",
+  "Array<unknown>",
+  `Array<Dict>`,
+  `Array<Set>`,
+  `Array<Map>`
+];
+var SIMPLE_MAP_TOKENS = [
+  "Map",
+  "Map<TOKEN, TOKEN>",
+  "WeakMap"
+];
+var SIMPLE_SET_TOKENS = [
+  "Set",
+  "Set<TOKEN>"
+];
+var SIMPLE_CONTAINER_TOKENS = [
+  ...SIMPLE_DICT_TOKENS,
+  ...SIMPLE_ARRAY_TOKENS,
+  ...SIMPLE_MAP_TOKENS,
+  ...SIMPLE_SET_TOKENS
+];
+var SIMPLE_TOKENS = [
+  ...SIMPLE_SCALAR_TOKENS,
+  ...SIMPLE_OPT_SCALAR_TOKENS,
+  ...SIMPLE_CONTAINER_TOKENS,
+  ...SIMPLE_UNION_TOKENS
+];
+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
+];
+
+// src/constants/Shape.ts
+var SHAPE_PREFIXES = [
+  "string",
+  "number",
+  "boolean",
+  "null",
+  "undefined",
+  "unknown",
+  "opt::",
+  "union::",
+  "tuple::",
+  "array::",
+  "object",
+  "record::"
+];
+var SHAPE_DELIMITER = "||,||";
+
+// src/constants/Marked.ts
+var MARKED = createConstant("Marked");
+
+// src/constants/HashTable.ts
+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";
+
+// src/constants/Geo.ts
+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"]
+};
+
+// src/constants/RepoConstants.ts
+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"
+};
+
+// src/constants/NetworkConstants.ts
+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"
+];
+
+// src/constants/Characters.ts
+var WHITESPACE_CHARS = [
+  " ",
+  "\n",
+  "	",
+  "\b"
+];
+
+// src/constants/Phone.ts
+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"]
+];
+
+// src/constants/ProxmoxConstants.ts
+var PROXMOX_CT_STATE = [
+  "started",
+  "stopped",
+  "enabled",
+  "disabled",
+  "ignored"
+];
+
+// src/constants/Tailwind.ts
+var TW_HUE = {
+  slate: 262,
+  gray: 270,
+  zinc: 269,
+  neutral: 270,
+  stone: 273,
+  red: 24,
+  orange: 44,
+  amber: 79,
+  yellow: 100,
+  lime: 132,
+  green: 144,
+  emerald: 159,
+  teal: 182,
+  cyan: 192,
+  sky: 219,
+  blue: 240,
+  indigo: 268,
+  violet: 283,
+  purple: 294,
+  fuchsia: 319,
+  pink: 334,
+  rose: 15,
+  black: 0,
+  white: 106.37411429114086
+};
+var TW_LUMINOSITY = {
+  "50": 97.78,
+  "100": 93.56,
+  "200": 88.11,
+  "300": 82.67,
+  "400": 74.22,
+  "500": 64.78,
+  "600": 57.33,
+  "700": 46.89,
+  "800": 39.44,
+  "900": 32,
+  "950": 23.78
+};
+var TW_LUMIN_50 = TW_LUMINOSITY["50"];
+var TW_LUMIN_100 = TW_LUMINOSITY["100"];
+var TW_LUMIN_200 = TW_LUMINOSITY["200"];
+var TW_LUMIN_300 = TW_LUMINOSITY["300"];
+var TW_LUMIN_400 = TW_LUMINOSITY["400"];
+var TW_LUMIN_500 = TW_LUMINOSITY["500"];
+var TW_LUMIN_600 = TW_LUMINOSITY["600"];
+var TW_LUMIN_700 = TW_LUMINOSITY["700"];
+var TW_LUMIN_800 = TW_LUMINOSITY["800"];
+var TW_LUMIN_900 = TW_LUMINOSITY["900"];
+var TW_LUMIN_950 = TW_LUMINOSITY["950"];
+var TW_CHROMA = {
+  "50": 0.0108,
+  "100": 0.0321,
+  "200": 0.0609,
+  "300": 0.0908,
+  "400": 0.1398,
+  "500": 0.1472,
+  "600": 0.1299,
+  "700": 0.1067,
+  "800": 0.0898,
+  "900": 0.0726,
+  "950": 0.054
+};
+var TW_CHROMA_50 = TW_CHROMA["50"];
+var TW_CHROMA_100 = TW_CHROMA["100"];
+var TW_CHROMA_200 = TW_CHROMA["200"];
+var TW_CHROMA_300 = TW_CHROMA["300"];
+var TW_CHROMA_400 = TW_CHROMA["400"];
+var TW_CHROMA_500 = TW_CHROMA["500"];
+var TW_CHROMA_600 = TW_CHROMA["600"];
+var TW_CHROMA_700 = TW_CHROMA["700"];
+var TW_CHROMA_800 = TW_CHROMA["800"];
+var TW_CHROMA_900 = TW_CHROMA["900"];
+var TW_CHROMA_950 = TW_CHROMA["950"];
+
+// src/types/dictionary/MapTo.ts
+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 = /* @__PURE__ */ ((MapCardinality2) => {
+  MapCardinality2["OneToMany"] = "I -> O[]";
+  MapCardinality2["OneToOne"] = "I -> O";
+  MapCardinality2["ManyToOne"] = "I[] -> O";
+  return MapCardinality2;
+})(MapCardinality || {});
+
+// src/types/string-literals/character-sets/images/Exif.ts
+var ExifCompression = /* @__PURE__ */ ((ExifCompression2) => {
+  ExifCompression2[ExifCompression2["Uncompressed"] = 1] = "Uncompressed";
+  ExifCompression2[ExifCompression2["CCITT"] = 2] = "CCITT";
+  ExifCompression2[ExifCompression2["T4Group3Fax"] = 3] = "T4Group3Fax";
+  ExifCompression2[ExifCompression2["T6Group3Fax"] = 4] = "T6Group3Fax";
+  ExifCompression2[ExifCompression2["LZW"] = 5] = "LZW";
+  ExifCompression2[ExifCompression2["JpgOldStyle"] = 6] = "JpgOldStyle";
+  ExifCompression2[ExifCompression2["Jpg"] = 7] = "Jpg";
+  ExifCompression2[ExifCompression2["AdobeDeflate"] = 8] = "AdobeDeflate";
+  ExifCompression2[ExifCompression2["JBigBw"] = 9] = "JBigBw";
+  ExifCompression2[ExifCompression2["JBigColor"] = 10] = "JBigColor";
+  ExifCompression2[ExifCompression2["JpegAlt"] = 99] = "JpegAlt";
+  ExifCompression2[ExifCompression2["Kodak262"] = 262] = "Kodak262";
+  ExifCompression2[ExifCompression2["Next"] = 32766] = "Next";
+  ExifCompression2[ExifCompression2["SonyRawCompressed"] = 32767] = "SonyRawCompressed";
+  ExifCompression2[ExifCompression2["PackedRaw"] = 32769] = "PackedRaw";
+  ExifCompression2[ExifCompression2["SamsungSrwCompressed"] = 32770] = "SamsungSrwCompressed";
+  ExifCompression2[ExifCompression2["CCIRLEW"] = 32771] = "CCIRLEW";
+  ExifCompression2[ExifCompression2["SamsungSrwCompressed2"] = 32772] = "SamsungSrwCompressed2";
+  ExifCompression2[ExifCompression2["Packbits"] = 32773] = "Packbits";
+  ExifCompression2[ExifCompression2["Thunderscan"] = 32809] = "Thunderscan";
+  ExifCompression2[ExifCompression2["KodakKdcCompressed"] = 32867] = "KodakKdcCompressed";
+  ExifCompression2[ExifCompression2["IT8CTPAD"] = 32895] = "IT8CTPAD";
+  ExifCompression2[ExifCompression2["IT8LW"] = 32896] = "IT8LW";
+  ExifCompression2[ExifCompression2["IT8MP"] = 32897] = "IT8MP";
+  ExifCompression2[ExifCompression2["IT8BL"] = 32898] = "IT8BL";
+  ExifCompression2[ExifCompression2["PixarFilm"] = 32908] = "PixarFilm";
+  ExifCompression2[ExifCompression2["PixarLog"] = 32909] = "PixarLog";
+  ExifCompression2[ExifCompression2["Deflate"] = 32946] = "Deflate";
+  ExifCompression2[ExifCompression2["DCS"] = 32947] = "DCS";
+  ExifCompression2[ExifCompression2["AperioJpeg2000YCbCr"] = 33003] = "AperioJpeg2000YCbCr";
+  ExifCompression2[ExifCompression2["AperioJpeg2000RGB"] = 33005] = "AperioJpeg2000RGB";
+  ExifCompression2[ExifCompression2["JBig"] = 34661] = "JBig";
+  ExifCompression2[ExifCompression2["SGILog"] = 34676] = "SGILog";
+  ExifCompression2[ExifCompression2["SGILog24"] = 34677] = "SGILog24";
+  ExifCompression2[ExifCompression2["Jpeg2000"] = 34712] = "Jpeg2000";
+  ExifCompression2[ExifCompression2["NikonNEFCompressed"] = 34713] = "NikonNEFCompressed";
+  ExifCompression2[ExifCompression2["JBig2TiffFx"] = 34715] = "JBig2TiffFx";
+  ExifCompression2[ExifCompression2["MicrosoftBinaryLevelCodec"] = 34718] = "MicrosoftBinaryLevelCodec";
+  ExifCompression2[ExifCompression2["MicrosoftProgressiveTransformCodec"] = 34719] = "MicrosoftProgressiveTransformCodec";
+  ExifCompression2[ExifCompression2["MicrosoftVector"] = 34720] = "MicrosoftVector";
+  ExifCompression2[ExifCompression2["ESRCLerc"] = 34887] = "ESRCLerc";
+  ExifCompression2[ExifCompression2["LossyJpeg"] = 34892] = "LossyJpeg";
+  ExifCompression2[ExifCompression2["LZMA2"] = 34925] = "LZMA2";
+  ExifCompression2[ExifCompression2["Zstd"] = 34926] = "Zstd";
+  ExifCompression2[ExifCompression2["WepP"] = 34927] = "WepP";
+  ExifCompression2[ExifCompression2["PNG"] = 34933] = "PNG";
+  ExifCompression2[ExifCompression2["JpegXR"] = 34934] = "JpegXR";
+  ExifCompression2[ExifCompression2["KodakDCRCompressed"] = 65e3] = "KodakDCRCompressed";
+  ExifCompression2[ExifCompression2["PentaxPEFCompressed"] = 65535] = "PentaxPEFCompressed";
+  return ExifCompression2;
+})(ExifCompression || {});
+var ExifLightSource = /* @__PURE__ */ ((ExifLightSource2) => {
+  ExifLightSource2[ExifLightSource2["Unknown"] = 0] = "Unknown";
+  ExifLightSource2[ExifLightSource2["Daylight"] = 1] = "Daylight";
+  ExifLightSource2[ExifLightSource2["Fluorescent"] = 2] = "Fluorescent";
+  ExifLightSource2[ExifLightSource2["Tungsten"] = 3] = "Tungsten";
+  ExifLightSource2[ExifLightSource2["Flash"] = 4] = "Flash";
+  ExifLightSource2[ExifLightSource2["FineWeather"] = 5] = "FineWeather";
+  ExifLightSource2[ExifLightSource2["Cloudy"] = 6] = "Cloudy";
+  ExifLightSource2[ExifLightSource2["Shade"] = 7] = "Shade";
+  ExifLightSource2[ExifLightSource2["DaylightFluorescent"] = 8] = "DaylightFluorescent";
+  ExifLightSource2[ExifLightSource2["DayWhiteFluorescent"] = 9] = "DayWhiteFluorescent";
+  ExifLightSource2[ExifLightSource2["CoolWhiteFluorescent"] = 10] = "CoolWhiteFluorescent";
+  ExifLightSource2[ExifLightSource2["WhiteFluorescent"] = 11] = "WhiteFluorescent";
+  ExifLightSource2[ExifLightSource2["WarmWhiteFluorescent"] = 12] = "WarmWhiteFluorescent";
+  ExifLightSource2[ExifLightSource2["StandardLightA"] = 13] = "StandardLightA";
+  ExifLightSource2[ExifLightSource2["StandardLightB"] = 14] = "StandardLightB";
+  ExifLightSource2[ExifLightSource2["StandardLightC"] = 15] = "StandardLightC";
+  ExifLightSource2[ExifLightSource2["D55"] = 16] = "D55";
+  ExifLightSource2[ExifLightSource2["D65"] = 17] = "D65";
+  ExifLightSource2[ExifLightSource2["D75"] = 18] = "D75";
+  ExifLightSource2[ExifLightSource2["D50"] = 19] = "D50";
+  ExifLightSource2[ExifLightSource2["ISOStudioTungsten"] = 20] = "ISOStudioTungsten";
+  ExifLightSource2[ExifLightSource2["Other"] = 255] = "Other";
+  return ExifLightSource2;
+})(ExifLightSource || {});
+var ExifFlashValues = /* @__PURE__ */ ((ExifFlashValues2) => {
+  ExifFlashValues2[ExifFlashValues2["NoFlash"] = 0] = "NoFlash";
+  ExifFlashValues2[ExifFlashValues2["Fired"] = 1] = "Fired";
+  ExifFlashValues2[ExifFlashValues2["FiredReturnNotDetected"] = 5] = "FiredReturnNotDetected";
+  ExifFlashValues2[ExifFlashValues2["FiredReturnDetected"] = 7] = "FiredReturnDetected";
+  ExifFlashValues2[ExifFlashValues2["OnDidNotFire"] = 8] = "OnDidNotFire";
+  ExifFlashValues2[ExifFlashValues2["OnFired"] = 9] = "OnFired";
+  ExifFlashValues2[ExifFlashValues2["OnReturnNotDetected"] = 13] = "OnReturnNotDetected";
+  ExifFlashValues2[ExifFlashValues2["OnReturnDetected"] = 15] = "OnReturnDetected";
+  ExifFlashValues2[ExifFlashValues2["OffDidNotFire"] = 16] = "OffDidNotFire";
+  ExifFlashValues2[ExifFlashValues2["OffDidNotFireReturnNotDetected"] = 20] = "OffDidNotFireReturnNotDetected";
+  ExifFlashValues2[ExifFlashValues2["AutoDidNotFire"] = 24] = "AutoDidNotFire";
+  ExifFlashValues2[ExifFlashValues2["AutoFired"] = 25] = "AutoFired";
+  ExifFlashValues2[ExifFlashValues2["AutoFiredReturnNotDetected"] = 29] = "AutoFiredReturnNotDetected";
+  ExifFlashValues2[ExifFlashValues2["AutoFiredReturnDetected"] = 31] = "AutoFiredReturnDetected";
+  ExifFlashValues2[ExifFlashValues2["NoFlashFunction"] = 32] = "NoFlashFunction";
+  ExifFlashValues2[ExifFlashValues2["OffNoFlashFunction"] = 48] = "OffNoFlashFunction";
+  ExifFlashValues2[ExifFlashValues2["FiredRedEyeReduction"] = 65] = "FiredRedEyeReduction";
+  ExifFlashValues2[ExifFlashValues2["FiredRedEyeReductionReturnNotDetected"] = 69] = "FiredRedEyeReductionReturnNotDetected";
+  ExifFlashValues2[ExifFlashValues2["FiredRedEyeReductionReturnDetected"] = 71] = "FiredRedEyeReductionReturnDetected";
+  ExifFlashValues2[ExifFlashValues2["OnRedEyeReduction"] = 73] = "OnRedEyeReduction";
+  ExifFlashValues2[ExifFlashValues2["OnRedEyeReductionReturnNotDetected"] = 77] = "OnRedEyeReductionReturnNotDetected";
+  ExifFlashValues2[ExifFlashValues2["OnRedEyeReductionReturnDetected"] = 79] = "OnRedEyeReductionReturnDetected";
+  ExifFlashValues2[ExifFlashValues2["OffRedEyeReduction"] = 80] = "OffRedEyeReduction";
+  ExifFlashValues2[ExifFlashValues2["AutoDidNotFireRedEyeReduction"] = 88] = "AutoDidNotFireRedEyeReduction";
+  ExifFlashValues2[ExifFlashValues2["AutoFiredRedEyeReduction"] = 89] = "AutoFiredRedEyeReduction";
+  ExifFlashValues2[ExifFlashValues2["AutoFiredRedEyeReductionNotDetected"] = 96] = "AutoFiredRedEyeReductionNotDetected";
+  ExifFlashValues2[ExifFlashValues2["AutoFiredRedEyeReductionDetected"] = 93] = "AutoFiredRedEyeReductionDetected";
+  return ExifFlashValues2;
+})(ExifFlashValues || {});
+var ExifPreviewColorSpace = /* @__PURE__ */ ((ExifPreviewColorSpace2) => {
+  ExifPreviewColorSpace2[ExifPreviewColorSpace2["Unknown"] = 0] = "Unknown";
+  ExifPreviewColorSpace2[ExifPreviewColorSpace2["GrayGamma22"] = 1] = "GrayGamma22";
+  ExifPreviewColorSpace2[ExifPreviewColorSpace2["sRGB"] = 2] = "sRGB";
+  ExifPreviewColorSpace2[ExifPreviewColorSpace2["AdobeRGB"] = 3] = "AdobeRGB";
+  ExifPreviewColorSpace2[ExifPreviewColorSpace2["ProPhotoRGB"] = 4] = "ProPhotoRGB";
+  return ExifPreviewColorSpace2;
+})(ExifPreviewColorSpace || {});
+var ExifEmbedPolicy = /* @__PURE__ */ ((ExifEmbedPolicy2) => {
+  ExifEmbedPolicy2[ExifEmbedPolicy2["AllowCopying"] = 0] = "AllowCopying";
+  ExifEmbedPolicy2[ExifEmbedPolicy2["EmbedIfUsed"] = 1] = "EmbedIfUsed";
+  ExifEmbedPolicy2[ExifEmbedPolicy2["NeverEmbed"] = 2] = "NeverEmbed";
+  ExifEmbedPolicy2[ExifEmbedPolicy2["NoRestrictions"] = 3] = "NoRestrictions";
+  return ExifEmbedPolicy2;
+})(ExifEmbedPolicy || {});
+var ExifSubjectDistance = /* @__PURE__ */ ((ExifSubjectDistance2) => {
+  ExifSubjectDistance2[ExifSubjectDistance2["Unknown"] = 0] = "Unknown";
+  ExifSubjectDistance2[ExifSubjectDistance2["Macro"] = 1] = "Macro";
+  ExifSubjectDistance2[ExifSubjectDistance2["Close"] = 2] = "Close";
+  ExifSubjectDistance2[ExifSubjectDistance2["Distant"] = 3] = "Distant";
+  return ExifSubjectDistance2;
+})(ExifSubjectDistance || {});
+var ExifSharpness = /* @__PURE__ */ ((ExifSharpness2) => {
+  ExifSharpness2[ExifSharpness2["Normal"] = 0] = "Normal";
+  ExifSharpness2[ExifSharpness2["Soft"] = 1] = "Soft";
+  ExifSharpness2[ExifSharpness2["Hard"] = 2] = "Hard";
+  return ExifSharpness2;
+})(ExifSharpness || {});
+var ExifSceneCaptureType = /* @__PURE__ */ ((ExifSceneCaptureType2) => {
+  ExifSceneCaptureType2[ExifSceneCaptureType2["Standard"] = 0] = "Standard";
+  ExifSceneCaptureType2[ExifSceneCaptureType2["Landscape"] = 1] = "Landscape";
+  ExifSceneCaptureType2[ExifSceneCaptureType2["Portrait"] = 2] = "Portrait";
+  ExifSceneCaptureType2[ExifSceneCaptureType2["Night"] = 3] = "Night";
+  ExifSceneCaptureType2[ExifSceneCaptureType2["Other"] = 4] = "Other";
+  return ExifSceneCaptureType2;
+})(ExifSceneCaptureType || {});
+var ExifGainControl = /* @__PURE__ */ ((ExifGainControl2) => {
+  ExifGainControl2[ExifGainControl2["None"] = 0] = "None";
+  ExifGainControl2[ExifGainControl2["LowGainUp"] = 1] = "LowGainUp";
+  ExifGainControl2[ExifGainControl2["HighGainUp"] = 2] = "HighGainUp";
+  ExifGainControl2[ExifGainControl2["LowGainDown"] = 3] = "LowGainDown";
+  ExifGainControl2[ExifGainControl2["HighGainDown"] = 4] = "HighGainDown";
+  return ExifGainControl2;
+})(ExifGainControl || {});
+var ExifContrast = /* @__PURE__ */ ((ExifContrast2) => {
+  ExifContrast2[ExifContrast2["Normal"] = 0] = "Normal";
+  ExifContrast2[ExifContrast2["Low"] = 1] = "Low";
+  ExifContrast2[ExifContrast2["High"] = 2] = "High";
+  return ExifContrast2;
+})(ExifContrast || {});
+var ExifSaturation = /* @__PURE__ */ ((ExifSaturation2) => {
+  ExifSaturation2[ExifSaturation2["Normal"] = 0] = "Normal";
+  ExifSaturation2[ExifSaturation2["Low"] = 1] = "Low";
+  ExifSaturation2[ExifSaturation2["High"] = 2] = "High";
+  return ExifSaturation2;
+})(ExifSaturation || {});
+
+// src/runtime/api/defineApi.ts
+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");
+
+// src/runtime/api/handleDoneFn.ts
+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;
+};
+
+// src/runtime/boolean-logic/ifArray.ts
+function ifArray(val, isAnArray, isNotAnArray) {
+  return Array.isArray(val) ? isAnArray(val) : isNotAnArray(val);
+}
+
+// src/runtime/boolean-logic/ifBoolean.ts
+function ifBoolean(val, ifBoolean2, notBoolean) {
+  return isBoolean(val) ? ifBoolean2(val) : notBoolean(val);
+}
+
+// src/runtime/boolean-logic/ifNumber.ts
+function ifNumber(val, ifVal, elseVal) {
+  return isNumber(val) ? ifVal(val) : elseVal(val);
+}
+
+// src/runtime/boolean-logic/ifNotNull.ts
+function ifNotNull(val, ifVal, elseVal) {
+  return isNull(val) ? elseVal() : ifVal(val);
+}
+
+// src/runtime/boolean-logic/ifSameType.ts
+function ifSameType(value, comparator, same, notSame) {
+  return (
+    // runtime values match
+    typeof value === typeof comparator ? same(value) : notSame(value)
+  );
+}
+
+// src/runtime/boolean-logic/ifContainer.ts
+function ifContainer(value, ifContainer2, notContainer) {
+  return isObject(value) || isArray(value) ? ifContainer2(value) : notContainer(value);
+}
+
+// src/runtime/boolean-logic/ifHasKey.ts
+var ifHasKey = (container, key, hasKey, doesNotHaveKey) => hasIndexOf(container, key) ? hasKey(container) : doesNotHaveKey(container);
+
+// src/runtime/boolean-logic/ifLength.ts
+function ifLength(value, length, ifVal, elseVal) {
+  return Array.isArray(value) && value.length === length ? ifVal(value) : elseVal(value);
+}
+
+// src/runtime/type-guards/isString.ts
+function isString(value) {
+  return typeof value === "string";
+}
+
+// src/runtime/type-guards/isNumber.ts
+function isNumber(value) {
+  return typeof value === "number";
+}
+
+// src/runtime/type-guards/isSymbol.ts
+function isSymbol(value) {
+  return typeof value === "symbol";
+}
+
+// src/runtime/type-guards/isNull.ts
+function isNull(value) {
+  return value === null ? true : false;
+}
+
+// src/runtime/type-guards/isScalar.ts
+function isScalar(value) {
+  return isString(value) || isNumber(value) || isSymbol(value) || isNull(value);
+}
+
+// src/runtime/boolean-logic/ifScalar.ts
+function ifScalar(value, ifCallback, notCallback) {
+  const result2 = isScalar(value) ? ifCallback(
+    value
+  ) : notCallback(value);
+  return result2;
+}
+
+// src/runtime/boolean-logic/ifNull.ts
+function ifNull(val, ifVal, elseVal) {
+  return isNull(val) ? ifVal() : elseVal(val);
+}
+
+// src/runtime/boolean-logic/ifObject.ts
+function ifObject(val, ifObj, notObj) {
+  return isObject(val) ? ifObj : notObj;
+}
+
+// src/runtime/boolean-logic/ifTrue.ts
+function ifTrue(val, ifVal, elseVal) {
+  return (
+    //
+    isTrue(val) ? ifVal(val) : elseVal(val)
+  );
+}
+
+// src/runtime/boolean-logic/ifFunction.ts
+function ifFunction(value, isFnCallback, notFnCallback) {
+  return typeof value === "function" ? isFnCallback(value) : notFnCallback(value);
+}
+
+// src/runtime/boolean-logic/ifFalse.ts
+function ifFalse(val, ifVal, elseVal) {
+  return isFalse(val) ? ifVal : elseVal;
+}
+
+// src/runtime/boolean-logic/ifChar.ts
+var def_if = (v) => v;
+var def_else = () => Never;
+function ifChar(ch, callback_if_match = def_if, callback_not_match = def_else) {
+  return ch.length === 1 ? callback_if_match(ch) : callback_not_match(ch);
+}
+
+// src/runtime/boolean-logic/ifString.ts
+function ifString(val, ifVal, elseVal) {
+  return typeof val === "string" ? ifVal(val) : elseVal(val);
+}
+
+// src/runtime/boolean-logic/ifUndefined.ts
+function ifUndefined(val, ifUndefined2, ifDefined2) {
+  return isUndefined(val) ? ifUndefined2() : ifDefined2(val);
+}
+function ifDefined(val, ifVal, elseVal) {
+  return isDefined(val) ? ifVal : elseVal;
+}
+
+// src/runtime/boolean-logic/ifArrayPartial.ts
+function ifArrayPartial() {
+  return (isAnArray, isNotAnArray) => {
+    return (val) => ifArray(val, isAnArray, isNotAnArray);
+  };
+}
+
+// src/runtime/combinators/and.ts
+var and = (...values) => {
+  return values.every((i) => i === true);
+};
+
+// src/runtime/combinators/or.ts
+function or(...conditions) {
+  const values = conditions.some((v) => v === true ? true : false);
+  return values;
+}
+
+// src/runtime/dictionary/entries.ts
+function entries(obj) {
+  const iterable = {
+    *[Symbol.iterator]() {
+      for (const k of keysOf(obj)) {
+        yield [k, obj[k]];
+      }
+    }
+  };
+  return iterable;
+}
+
+// src/runtime/dictionary/get.ts
+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;
+}
+
+// src/runtime/dictionary/keysOf.ts
+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;
+}
+
+// src/runtime/dictionary/omit.ts
+function omit(obj, ...removeKeys) {
+  const keys = Object.keys(obj);
+  return keys.reduce(
+    (acc, key) => removeKeys.includes(key) ? acc : {
+      ...acc,
+      [key]: obj[key]
+    },
+    {}
+  );
+}
+
+// src/runtime/dictionary/retain.ts
+var retain = (dict, ...keys) => {
+  let output = {};
+  for (const k of keys) {
+    output = {
+      ...output,
+      [k]: dict[k]
+    };
+  }
+  return output;
+};
+
+// src/runtime/dictionary/sharedKeys.ts
+var sharedKeys = (a, b) => {
+  const ka = Object.keys(a);
+  const kb = Object.keys(b);
+  return ka.filter((k) => kb.includes(k));
+};
+
+// src/runtime/dictionary/takeProp.ts
+var takeProp = (val, prop, otherwise) => {
+  return (isObject(val) || isArray(val)) && prop in val ? val[prop] : otherwise;
+};
+
+// src/runtime/dictionary/withKeys.ts
+var withKeys = (dict, ...keys) => retain(dict, ...keys);
+
+// src/runtime/dictionary/withoutKeys.ts
+var withoutKeys = (dict, ...exclude) => omit(dict, ...exclude);
+
+// src/runtime/dictionary/withoutValue.ts
+function withoutValue(val) {
+  return (obj) => {
+    return Object.keys(obj).reduce(
+      (acc, key) => val === obj[key] ? acc : { ...acc, [key]: obj[key] },
+      {}
+    );
+  };
+}
+
+// src/runtime/dictionary/withDefaults.ts
+var withDefaults = (with_defaults) => (obj) => {
+  const merged = {
+    ...with_defaults,
+    ...obj
+  };
+  return merged;
+};
+
+// src/runtime/dictionary/valuesOf.ts
+var valuesOf = (obj) => {
+  const values = [];
+  for (const k of Object.keys(obj)) {
+    values.push(obj[k]);
+  }
+  return values;
+};
+
+// src/runtime/errors/createErrorCondition.ts
+var createErrorCondition = (kind, msg = "", utility = "") => {
+  return {
+    __kind: "ErrorCondition",
+    kind,
+    msg,
+    utility
+  };
+};
+var errCondition = (kind, msg) => ({
+  __kind: "ErrorCondition",
+  kind,
+  msg
+});
+
+// src/runtime/literals/box.ts
+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(dict) {
+  const keys = Object.keys(dict);
+  return keys.reduce(
+    (acc, key) => ({ ...acc, [key]: box(dict[key]) }),
+    {}
+  );
+}
+function unbox(val) {
+  return isBox(val) ? val.value : val;
+}
+
+// src/runtime/literals/identity.ts
+var identity = (v) => v;
+
+// src/runtime/literals/literal.ts
+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;
+}
+
+// src/runtime/type-guards/isDefined.ts
+function isDefined(value) {
+  return typeof value === "undefined" ? false : true;
+}
+
+// src/runtime/type-guards/isFalsy.ts
+var isFalsy = (val) => {
+  return FALSY_VALUES.includes(val);
+};
+
+// src/runtime/type-guards/isNotNull.ts
+function isNotNull(value) {
+  return value === null ? true : false;
+}
+
+// src/runtime/type-guards/isTruthy.ts
+var isTruthy = (val) => {
+  return !FALSY_VALUES.includes(val);
+};
+
+// src/runtime/type-guards/isTypeTuple.ts
+function isTypeTuple(value) {
+  return Array.isArray(value) && value.length === 3 && typeof value[1] === "function";
+}
+
+// src/runtime/type-guards/isUndefined.ts
+function isUndefined(value) {
+  return typeof value === "undefined" ? true : false;
+}
+
+// src/runtime/type-guards/isBoolean.ts
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+
+// src/runtime/type-guards/isIndexable.ts
+function isIndexable(value) {
+  return Array.isArray(value) || typeof value === "object" && keysOf(value).length > 0 ? true : false;
+}
+
+// src/runtime/type-guards/isObject.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && Array.isArray(value) === false;
+}
+
+// src/runtime/type-guards/isTrue.ts
+function isTrue(value) {
+  return value === true;
+}
+
+// src/runtime/type-guards/isArray.ts
+function isArray(value) {
+  return Array.isArray(value) === true;
+}
+
+// src/runtime/type-guards/isConstant.ts
+function isConstant(value) {
+  return isObject(value) && "_type" in value && "kind" in value && value._type === "Constant" ? true : false;
+}
+
+// src/runtime/type-guards/isNever.ts
+var isNever = (val) => {
+  return isConstant(val) && val.kind === "never";
+};
+
+// src/runtime/type-guards/isContainer.ts
+function isContainer(value) {
+  return Array.isArray(value) || isObject(value) ? true : false;
+}
+
+// src/runtime/type-guards/isSpecificConstant.ts
+function isSpecificConstant(kind) {
+  return (value) => {
+    return isConstant(value) && value.kind === kind ? true : false;
+  };
+}
+
+// src/runtime/type-guards/isReadonlyArray.ts
+function isReadonlyArray(value) {
+  return Array.isArray(value) === true;
+}
+
+// src/runtime/type-guards/hasIndexOf.ts
+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;
+};
+
+// src/runtime/type-guards/isRef.ts
+function isRef(value) {
+  return isObject(value) && "value" in value && Array.from(Object.keys(value)).includes("_value");
+}
+
+// src/runtime/type-guards/isFalse.ts
+function isFalse(i) {
+  return typeof i === "boolean" && !i;
+}
+
+// src/runtime/type-guards/hasDefaultValue.ts
+function hasDefaultValue(value) {
+  const noDefault = isSpecificConstant("no-default-value");
+  return noDefault(value) ? false : true;
+}
+
+// src/runtime/literals/split.ts
+function split(str, sep = "") {
+  return str.split(sep);
+}
+
+// src/runtime/type-guards/isNumericString.ts
+function isNumericString(value) {
+  const validChars = [...NUMERIC_CHAR, "x", "E"];
+  return typeof value === "string" && split(value).every((i) => validChars.includes(i));
+}
+function isNumberLike(value) {
+  const numericChars = [...NUMERIC_CHAR];
+  return typeof value === "string" && split(value).every((i) => numericChars.includes(i));
+}
+
+// src/runtime/type-guards/isFnWithParams.ts
+function isFnWithParams(input) {
+  var _a;
+  return typeof input === "function" && ((_a = Object.keys(input)) == null ? void 0 : _a.length) > 0;
+}
+
+// src/runtime/type-guards/isFunction.ts
+function isFunction(value) {
+  return typeof value === "function" ? true : false;
+}
+
+// src/runtime/type-guards/isNothing.ts
+function isNothing(val) {
+  return val === null || val === void 0 ? true : false;
+}
+
+// src/runtime/type-guards/isTypeToken.ts
+function isTypeToken(val) {
+  if (isString(val) && startsWith("<<")(val) && endsWith(">>")(val)) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+// src/runtime/type-guards/isThenable.ts
+var isThenable = (val) => {
+  return isObject(val) && "then" in val && "catch" in val && typeof val.then === "function";
+};
+
+// src/runtime/type-guards/isErrorCondition.ts
+function isErrorCondition(value, kind = null) {
+  return isObject(value) && "__kind" in value && value.__kind === "ErrorCondition" && "kind" in value ? kind !== null ? value["kind"] === kind : true : false;
+}
+
+// src/runtime/type-guards/hasKeys.ts
+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;
+  }
+);
+
+// src/runtime/type-guards/isDoneFn.ts
+var isDoneFn = (val) => {
+  return hasKeys("done")(val) && typeof val.done === "function";
+};
+
+// src/runtime/type-guards/isUrl.ts
+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}://`));
+};
+
+// src/runtime/type-guards/isCssAspectRatio.ts
+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));
+};
+
+// src/runtime/type-guards/isInlineSvg.ts
+var isInlineSvg = (v) => {
+  return isString(v) && v.trim().startsWith(`<svg`) && v.trim().endsWith(`</svg>`);
+};
+
+// src/runtime/type-guards/youtube.ts
+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");
+};
+
+// src/runtime/type-guards/repos.ts
+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}/`)
+  );
+};
+
+// src/runtime/type-guards/network-tg.ts
+var isIp4Address = (val) => {
+  return isString(val) && val.split(".").length === 4 && val.split(".").every((i) => isNumberLike(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) || isNumberLike(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) || isNumberLike(i) || i === "-" || i === "_"
+  );
+};
+var isUrlSource = (val) => {
+  return isDomainName(val) || isIpAddress(val);
+};
+var hasUrlQueryParameter = (val, prop) => {
+  return isString(getUrlQueryParams(val, prop));
+};
+
+// src/runtime/type-conversion/asChars.ts
+var asChars = (str) => {
+  return str.split("");
+};
+
+// src/runtime/type-guards/isHexadecimal.ts
+var isHexadecimal = (val) => {
+  return isString(val) && asChars(val).every((i) => isNumericString(i) || ["a", "b", "c", "d", "e", "f"].includes(i.toLowerCase()));
+};
+
+// src/runtime/type-guards/isTrimmable.ts
+var isTrimable = (val) => {
+  return isString(val) && val !== val.trim();
+};
+
+// src/runtime/type-conversion/mergeObjects.ts
+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;
+}
+
+// src/runtime/type-conversion/optional.ts
+function optional(value) {
+  return value;
+}
+function orNull(value) {
+  return value;
+}
+function optionalOrNull(value) {
+  return value;
+}
+
+// src/runtime/type-conversion/mergeScalars.ts
+function mergeScalars(a, b) {
+  return isUndefined(b) ? a : b;
+}
+
+// src/runtime/type-conversion/mergeTuples.ts
+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]);
+}
+
+// src/runtime/type-conversion/unionize.ts
+function unionize(value, inUnionWith) {
+  return value;
+}
+
+// src/runtime/type-conversion/intersect.ts
+function intersect(value, intersectedWith) {
+  return value;
+}
+
+// src/runtime/type-conversion/never.ts
+function never(val) {
+  return val;
+}
+
+// src/runtime/type-conversion/union.ts
+var union = (...options) => (value) => value;
+
+// src/runtime/type-conversion/toNumber.ts
+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);
+}
+
+// src/runtime/type-conversion/asRecord.ts
+var asRecord = (obj) => {
+  return obj;
+};
+
+// src/runtime/type-conversion/asString.ts
+var asString = (value) => {
+  return isString(value) ? value : isNumber(value) ? `${value}` : isBoolean(value) ? `${value}` : isArray(value) ? value.join("") : String(value);
+};
+
+// src/runtime/type-conversion/ip6GroupExpansion.ts
+var ip6GroupExpansion = (ip) => {
+  return stripTrailing(ip.replaceAll("::", ":0000:"), ":");
+};
+
+// src/runtime/type-conversion/csv.ts
+var csv = (csv2, format = `string-numeric-tuple`) => {
+  const tuple3 = [];
+  csv2.split(/,\s{0,1}/).forEach((v) => {
+    tuple3.push(
+      format === "string-numeric-tuple" ? isNumberLike(v) ? Number(v) : v : format === "json-tuple" ? isNumberLike(v) ? Number(v) : v === "true" ? true : v === "false" ? false : `"${v}"` : format === "string-tuple" ? `${v}` : Never
+    );
+  });
+  return tuple3;
+};
+
+// src/runtime/type-conversion/json.ts
+var jsonValue = (val) => {
+  return isNumberLike(val) ? Number(val) : val === "true" ? true : val === "false" ? false : `"${val}"`;
+};
+var jsonValues = (...val) => {
+  return val.map((i) => jsonValue(i));
+};
+
+// src/runtime/type-guards/hasWhitespace.ts
+var hasWhiteSpace = (val) => {
+  return isString(val) && asChars(val).some((c) => WHITESPACE_CHARS.includes(c));
+};
+
+// src/runtime/type-guards/isEmail.ts
+var isEmail = (val) => {
+  if (!isString(val)) {
+    return false;
+  }
+  const parts = val.split("@");
+  const domain = parts[1].split(".");
+  const tld = domain.pop();
+  return isString(val) && (parts.length === 2 && domain.length >= 1 && tld.length >= 2);
+};
+
+// src/runtime/type-guards/isPhoneNumber.ts
+var isPhoneNumber = (val) => {
+  let svelte = String(val).trim();
+  let chars = svelte.split("");
+  let numeric = retainChars(svelte, ...NUMERIC_CHAR);
+  let valid = ["+", "(", ...NUMERIC_CHAR];
+  let nothing = stripChars(svelte, ...[
+    ...NUMERIC_CHAR,
+    ...WHITESPACE_CHARS,
+    "(",
+    ")",
+    "+",
+    ".",
+    "-"
+  ]);
+  return chars.every((i) => valid.includes(i)) && svelte.startsWith(`+`) ? numeric.length >= 8 : svelte.startsWith(`00`) ? numeric.length >= 10 : numeric.length >= 7 && nothing === "";
+};
+
+// src/runtime/type-guards/isUnset.ts
+var isUnset = (val) => {
+  return isObject(val) && val.kind === "Unset";
+};
+var isSet = (val) => {
+  return isObject(val) ? val.kind !== "Unset" ? true : false : true;
+};
+
+// src/runtime/type-guards/api-tg.ts
+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]));
+};
+
+// src/runtime/type-guards/isBooleanLike.ts
+var isBooleanLike = (val) => {
+  return isBoolean(val) || isString(val) && ["true", "false", "boolean"].includes(val);
+};
+
+// src/runtime/type-guards/isRegExp.ts
+var isRegExp = (val) => {
+  return val instanceof RegExp;
+};
+var isLikeRegExp = (val) => {
+  if (isRegExp(val)) {
+    return true;
+  }
+  if (isString(val)) {
+    try {
+      const _re = new RegExp(val);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+};
+
+// src/runtime/type-guards/isAlpha.ts
+var isAlpha = (value) => {
+  return isString(value) && split(value).every((v) => ALPHA_CHARS.includes(v));
+};
+
+// src/runtime/type-guards/tokens/isAtomicToken.ts
+var isAtomicToken = (val) => {
+  return isString(val) && TT_Atomics.some((v) => val === `<<${v}>>`);
+};
+
+// src/runtime/type-guards/tokens/isContainerToken.ts
+var isObjectToken = (val) => {
+  return isString(val) && val.startsWith("<<obj::");
+};
+var isRecordToken = (val) => {
+  return isString(val) && val.startsWith("<<rec::") && val.endsWith(">>");
+};
+var isTupleToken = (val) => {
+  return isString(val) && val.startsWith("<<tuple::");
+};
+var isArrayToken = (val) => {
+  return isString(val) && val.startsWith("<<arr::");
+};
+var isMapToken = (val) => {
+  return isString(val) && val.startsWith("<<map::");
+};
+var isSetToken = (val) => {
+  return isString(val) && val.startsWith("<<set::");
+};
+var isWeakMapToken = (val) => {
+  return isString(val) && val.startsWith("<<weak::");
+};
+var isUnionToken = (val) => {
+  return isString(val) && val.startsWith("<<union::[ ");
+};
+var isUnionSetToken = (val) => {
+  return isString(val) && val.startsWith("<<union-set::");
+};
+var isContainerToken = (val) => {
+  return isString(val) && (isObjectToken(val) || isRecordToken(val) || isTupleToken(val) || isArrayToken(val) || isMapToken(val) || isSetToken(val) || isWeakMapToken(val) || isUnionSetToken(val) || isUnionToken(val));
+};
+
+// src/runtime/type-guards/tokens/isFunctionToken.ts
+var isFnToken = (val) => {
+  return isString(val) && val.startsWith("<<fn::");
+};
+var isGeneratorToken = (val) => {
+  return isString(val) && val.startsWith("<<gen::");
+};
+
+// src/runtime/type-guards/tokens/isSingletonToken.ts
+var isSingletonToken = (val) => {
+  return isString(val) && TT_Atomics.some((v) => val === `<<${v}>>`);
+};
+
+// src/runtime/type-guards/tokens/isSimpleToken.ts
+var split_tokens = SIMPLE_TOKENS.map((i) => i.split("TOKEN"));
+var scalar_split_tokens = SIMPLE_SCALAR_TOKENS.map((i) => i.split("TOKEN"));
+var isSimpleToken = (val) => {
+  return isString(val) && split_tokens.some(
+    (i) => i.length === 1 && val === i[0] || val.startsWith(i[0]) && val.endsWith(i.slice(-1)[0]) && i.every((p) => val.includes(p))
+  );
+};
+var isSimpleScalarToken = (val) => {
+  return isString(val) && scalar_split_tokens.some(
+    (i) => i.length === 1 && val === i[0] || val.startsWith(i[0]) && val.endsWith(i.slice(-1)[0]) && i.every((p) => val.includes(p))
+  );
+};
+var isSimpleContainerToken = (val) => {
+  return isString(val) && scalar_split_tokens.some(
+    (i) => i.length === 1 && val === i[0] || val.startsWith(i[0]) && val.endsWith(i.slice(-1)[0]) && i.every((p) => val.includes(p))
+  );
+};
+var isSimpleTokenTuple = (val) => {
+  return isArray(val) && val.length !== 0 && val.every(isSimpleToken);
+};
+var isSimpleScalarTokenTuple = (val) => {
+  return isArray(val) && val.length !== 0 && val.every(isSimpleScalarToken);
+};
+var isSimpleContainerTokenTuple = (val) => {
+  return isArray(val) && val.length !== 0 && val.every(isSimpleContainerToken);
+};
+
+// src/runtime/type-guards/higher-order/endsWith.ts
+var endsWith = (endingIn2) => (val) => {
+  return isString(val) ? val.endsWith(endingIn2) ? true : false : isNumber(val) ? String(val).endsWith(endingIn2) ? true : false : false;
+};
+
+// src/runtime/type-guards/higher-order/startsWith.ts
+var startsWith = (startingWith) => (val) => {
+  return isString(val) ? val.startsWith(startingWith) ? true : false : isNumber(val) ? String(val).startsWith(startingWith) ? true : false : false;
+};
+
+// src/runtime/type-guards/higher-order/isEqual.ts
+var isEqual = (base) => (value) => isSameTypeOf(base)(value) ? value === base ? true : false : false;
+
+// src/runtime/type-guards/higher-order/isLength.ts
+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;
+}
+
+// src/runtime/type-guards/higher-order/isTypeOf.ts
+var isTypeOf = (type) => (value) => {
+  return typeof value === type;
+};
+
+// src/runtime/type-guards/higher-order/isSameTypeOf.ts
+var isSameTypeOf = (base) => (compare) => {
+  return typeof base === typeof compare;
+};
+
+// src/runtime/type-guards/higher-order/isTuple.ts
+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));
+  };
+};
+
+// src/runtime/type-guards/html/isHtmlElement.ts
+var isHtmlElement = (val) => {
+  return isObject(val) && "attributes" in val && "firstElementChild" in val && "innerHTML" in val;
+};
+
+// src/runtime/literals/stripTrailing.ts
+function stripTrailing(content, ...strip) {
+  let output = String(content);
+  for (const s of strip) {
+    if (output.endsWith(String(s))) {
+      output = output.slice(0, -1 * String(s).length);
+    }
+  }
+  return isNumber(content) ? Number(output) : output;
+}
+
+// src/runtime/literals/stripLeading.ts
+function stripLeading(content, ...strip) {
+  let output = String(content);
+  for (const s of strip) {
+    if (output.startsWith(String(s))) {
+      output = output.slice(String(s).length);
+    }
+  }
+  return isNumber(content) ? Number(output) : output;
+}
+
+// src/runtime/literals/ensureTrailing.ts
+function ensureTrailing(content, ensure) {
+  return (
+    //
+    content.endsWith(ensure) ? content : `${content}${ensure}`
+  );
+}
+
+// src/runtime/literals/ensureLeading.ts
+function ensureLeading(content, ensure) {
+  let output = String(content);
+  return output.startsWith(String(ensure)) ? content : isString(content) ? `${ensure}${content}` : Number(`${ensure}${content}`);
+}
+
+// src/runtime/literals/ensureSurround.ts
+function ensureSurround(prefix, postfix) {
+  const fn2 = (input) => {
+    let result2 = input;
+    result2 = ensureLeading(result2, prefix);
+    result2 = ensureTrailing(result2, postfix);
+    return result2;
+  };
+  return fn2;
+}
+
+// src/runtime/literals/ifUppercase.ts
+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);
+}
+
+// src/runtime/literals/pathJoin.ts
+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}`;
+}
+
+// src/runtime/literals/narrow.ts
+function narrow(...values) {
+  return values.length === 1 ? values[0] : values;
+}
+
+// src/runtime/literals/tuple.ts
+var tuple = (...values) => {
+  const arr = values.length === 1 ? values[0] : values;
+  return asArray(arr);
+};
+
+// src/runtime/literals/capitalize.ts
+function capitalize(str) {
+  return `${str == null ? void 0 : str.slice(0, 1).toUpperCase()}${str == null ? void 0 : str.slice(1)}`;
+}
+
+// src/runtime/literals/uncapitalize.ts
+function uncapitalize(str) {
+  return `${str == null ? void 0 : str.slice(0, 1).toLowerCase()}${str == null ? void 0 : str.slice(1)}`;
+}
+
+// src/runtime/literals/uppercase.ts
+function uppercase(str) {
+  return str.toUpperCase();
+}
+
+// src/runtime/literals/lowercase.ts
+function lowercase(str) {
+  return str.toLowerCase();
+}
+
+// src/runtime/literals/widen.ts
+function widen(value) {
+  return value;
+}
+
+// src/runtime/literals/toCamelCase.ts
+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;
+}
+
+// src/runtime/literals/toKebabCase.ts
+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}`);
+}
+
+// src/runtime/literals/ifLowercase.ts
+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);
+}
+
+// src/runtime/literals/toSnakeCase.ts
+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, "_");
+}
+
+// src/runtime/literals/toString.ts
+function toString(val) {
+  return String(val);
+}
+
+// src/runtime/literals/pluralize.ts
+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") ? stripTrailing(word, "y") + "ies" : void 0;
+    default:
+      throw new Error(`endingIn received "${postfix}" as a postfix but this ending is not known!`);
+  }
+};
+var pluralize = (word) => {
+  const right = rightWhitespace(word);
+  const w = word.trimEnd();
+  const result2 = isException(w) ? PLURAL_EXCEPTIONS[w] : endingIn(w, "is") || endingIn(w, "singular-noun") || endingIn(w, "f") || endingIn(w, "y") || `${w}s`;
+  return `${result2}${right}`;
+};
+
+// src/runtime/literals/retainAfter.ts
+function retainAfter(content, ...find2) {
+  const idx = Math.min(
+    ...find2.map((i) => content.indexOf(i)).filter((i) => i > -1)
+  );
+  const min = Math.min(...find2.map((i) => i.length));
+  let len = Math.max(...find2.map((i) => i.length));
+  if (min !== len) {
+    if (!find2.includes(content.slice(idx, len))) {
+      len = min;
+    }
+  }
+  return idx && idx > 0 ? content.slice(idx + len) : "";
+}
+function retainAfterInclusive(content, ...find2) {
+  const minFound = Math.min(
+    ...find2.map((i) => content.indexOf(i)).filter((i) => i > -1)
+  );
+  return minFound > 0 ? content.slice(minFound) : "";
+}
+
+// src/runtime/literals/surround.ts
+function surround(prefix, postfix) {
+  return (input) => `${prefix}${input}${postfix}`;
+}
+
+// src/runtime/literals/stripAfter.ts
+function stripAfter(content, find2) {
+  return content.split(find2).shift();
+}
+
+// src/runtime/literals/stripBefore.ts
+function stripBefore(content, find2) {
+  return content.split(find2).slice(1).join(find2);
+}
+
+// src/runtime/literals/stripSurround.ts
+var stripSurround = (...chars) => {
+  return (input) => {
+    let output = String(input);
+    for (const s of chars) {
+      if (output.startsWith(String(s))) {
+        output = output.slice(String(s).length);
+      }
+      if (output.endsWith(String(s))) {
+        output = output.slice(0, -1 * String(s).length);
+      }
+    }
+    return isNumber(input) ? Number(output) : output;
+  };
+};
+
+// src/runtime/literals/stripUntil.ts
+var stripUntil = (content, ...until) => {
+  const stopIdx = asChars(content).findIndex((c) => until.includes(c));
+  return content.slice(stopIdx);
+};
+
+// src/runtime/literals/trim.ts
+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();
+}
+
+// src/runtime/literals/toPascalCase.ts
+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;
+}
+
+// src/runtime/literals/toUppercase.ts
+function toUppercase(str) {
+  return str.split("").map((i) => ifLowercaseChar(i, (v) => capitalize(v), (v) => v)).join("");
+}
+
+// src/runtime/literals/toNumericArray.ts
+var toNumericArray = (arr) => {
+  return arr.map((i) => Number(i));
+};
+
+// src/runtime/literals/truncate.ts
+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;
+};
+
+// src/runtime/literals/takeNumericCharacters.ts
+var takeNumericCharacters = (content) => {
+  let nonNumericIdx = asChars(content).findIndex((i) => !NUMERIC_CHAR.includes(i));
+  return content.slice(0, nonNumericIdx);
+};
+
+// src/runtime/literals/retainChars.ts
+var retainChars = (content, ...retain2) => {
+  let chars = asChars(content);
+  return chars.filter((c) => retain2.includes(c)).join("");
+};
+
+// src/runtime/literals/stripChars.ts
+var stripChars = (content, ...strip) => {
+  let chars = asChars(content);
+  return chars.filter((c) => !strip.includes(c)).join("");
+};
+
+// src/runtime/literals/retainWhile.ts
+var retainWhile = (content, ...retain2) => {
+  const stopIdx = asChars(content).findIndex((c) => !retain2.includes(c));
+  return content.slice(0, stopIdx);
+};
+
+// src/runtime/literals/rightWhitespace.ts
+var rightWhitespace = (content) => {
+  const trimmed = content.trimStart();
+  return retainAfterInclusive(
+    trimmed,
+    ...WHITESPACE_CHARS
+  );
+};
+
+// src/runtime/literals/retainUntil.ts
+function retainUntil(content, ...find2) {
+  const chars = asChars(content);
+  let idx = 0;
+  while (!find2.includes(chars[idx]) && idx <= chars.length) {
+    idx = idx + 1;
+  }
+  return idx === 0 ? "" : content.slice(0, idx);
+}
+function retainUntilInclusive(content, ...find2) {
+  const chars = asChars(content);
+  let idx = 0;
+  while (!find2.includes(chars[idx]) && idx <= chars.length) {
+    idx = idx + 1;
+  }
+  return idx === 0 ? content.slice(0, 1) : content.slice(0, idx + 1);
+}
+
+// src/runtime/literals/phone/getPhoneCountryCode.ts
+var getPhoneCountryCode = (phone) => {
+  return phone.trim().startsWith("+") || phone.trim().startsWith("00") ? retainWhile(
+    stripLeading(stripLeading(phone.trim(), "+"), "00"),
+    ...NUMERIC_CHAR
+  ) : "";
+};
+
+// src/runtime/literals/phone/removePhoneCountryCode.ts
+var removePhoneCountryCode = (phone) => {
+  const countryCode = getPhoneCountryCode(phone);
+  return countryCode !== "" ? stripLeading(stripLeading(
+    phone.trim(),
+    "+",
+    "00"
+  ), countryCode).trim() : phone.trim();
+};
+
+// src/runtime/literals/phone/asPhoneNumber.ts
+var asPhoneFormat = () => `NOT IMPLEMENTED`;
+
+// src/runtime/literals/color/twColor.ts
+var twColor = (color, luminosity) => {
+  const lum = TW_LUMINOSITY[luminosity];
+  const chroma = TW_CHROMA[luminosity];
+  const hue = TW_HUE[color];
+  return `oklch(${lum} ${chroma} ${hue})`;
+};
+
+// src/runtime/literals/color/cssColor.ts
+var cssColor = (color, v1, v2, v3, opacity) => {
+  return `color(${color} ${v1} ${v2} ${v3}${opacity ? ` / ${opacity}` : ""}`;
+};
+
+// src/runtime/errors/kindedError.ts
+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;
+};
+
+// src/runtime/functional/result.ts
+var result = "NOT READY";
+
+// src/runtime/functions/fnMeta.ts
+var fnMeta = (func) => {
+  const fn2 = (...args) => func(...args);
+  const props = Object.keys(fn2).reduce(
+    (acc, key) => ({ ...acc, [key]: fn2[key] }),
+    {}
+  );
+  return {
+    fn: fn2,
+    props
+  };
+};
+
+// src/runtime/functions/wrapFn.ts
+var wrapFn = "NOT IMPLEMENTED";
+
+// src/runtime/initializers/addFnToProps.ts
+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;
+  };
+};
+
+// src/runtime/initializers/addPropsToFn.ts
+var addFnToProps = (props, _clone_fn) => (fn2) => {
+  const localFn = (...args) => fn2(args);
+  for (const k in props) {
+    localFn[k] = props[k];
+  }
+  return localFn;
+};
+
+// src/runtime/initializers/createFnWithProps.ts
+var createFnWithProps = (fn2, props, narrowing = false) => {
+  let fnWithProps = fn2;
+  for (let prop of Object.keys(props)) {
+    fnWithProps[prop] = props[prop];
+  }
+  return isTrue(narrowing) ? fnWithProps : fnWithProps;
+};
+
+// src/runtime/initializers/defineObj.ts
+function defineObj(literal2 = {}) {
+  return (wide2 = {}) => {
+    const obj = literal2 ? { ...literal2, ...wide2 } : wide2;
+    return obj;
+  };
+}
+
+// src/runtime/initializers/defineTuple.ts
+var defineTuple = (...values) => {
+  return values.map(
+    (i) => isFunction(i) ? handleDoneFn(i(ShapeApiImplementation)) : i
+  );
+};
+
+// src/runtime/initializers/createCssSelector.ts
+var createCssSelector = (_opt) => (...selectors) => {
+  return selectors.join(" ");
+};
+
+// src/runtime/lists/asArray.ts
+var asArray = (thing) => {
+  return Array.isArray(thing) === true ? (
+    // proxy thing back as it's already an array
+    thing
+  ) : typeof thing === "undefined" ? [] : [thing];
+};
+
+// src/runtime/lists/getEach.ts
+function getEach(list2, dotPath) {
+  const result2 = list2.map(
+    (i) => isNull(dotPath) ? i : isContainer(i) ? get(i, dotPath) : Never
+  ).filter((i) => !isErrorCondition(i));
+  return result2;
+}
+
+// src/runtime/lists/indexOf.ts
+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)] : errCondition("invalid-index", `attempt to index a numeric array with an invalid index: ${Number(idx)}`) : isObject(val) ? String(idx) in val ? val[String(idx)] : errCondition("invalid-index", `attempt to index a dictionary object with an invalid index: ${String(idx)}`) : errCondition("invalid-container-type", `Attempt to use indexOf() on an invalid container type: ${typeof val}`);
+}
+
+// src/runtime/lists/intersection.ts
+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);
+};
+
+// src/runtime/lists/unique.ts
+var unique = (...values) => {
+  const u = [];
+  for (const i of values.flat()) {
+    if (!u.includes(i)) {
+      u.push(i);
+    }
+  }
+  return u;
+};
+
+// src/runtime/lists/logicalReturns.ts
+function logicalReturns(conditions) {
+  return conditions.map(
+    (c) => isBoolean(c) ? c : isFunction(c) ? c() : Never
+  );
+}
+
+// src/runtime/lists/find.ts
+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;
+  });
+};
+
+// src/runtime/lists/filter.ts
+var filter = "NOT READY";
+
+// src/runtime/lists/createConverter.ts
+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;
+  };
+}
+
+// src/runtime/lists/slice.ts
+var slice = (list2, start, end) => {
+  return list2.slice(start, end);
+};
+
+// src/runtime/lists/last.ts
+var last = (list2) => {
+  return [...list2].pop();
+};
+
+// src/runtime/lists/reverse.ts
+var reverse = (list2) => {
+  return [...list2].reverse();
+};
+
+// src/runtime/lists/join.ts
+function joinWith(joinWith2) {
+  return (...tuple3) => {
+    const tup = tuple3;
+    return tup.join(joinWith2);
+  };
+}
+
+// src/runtime/lists/shift.ts
+var shift = (list2) => {
+  let rtn;
+  if (isDefined(list2)) {
+    rtn = list2.length === 0 ? void 0 : list2[0];
+    try {
+      list2 = list2.slice(1);
+    } catch {
+    }
+  } else {
+    rtn = void 0;
+  }
+  return rtn;
+};
+
+// src/runtime/meta/youtube-meta.ts
+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 youtubeEmbed = (url) => {
+  if (hasUrlQueryParameter(url, "v")) {
+    const id = getUrlQueryParams(url, "v");
+    return `https://www.youtube.com/embed/${id}`;
+  } else if (isYouTubeShareUrl(url)) {
+    const id = url.split("/").pop();
+    if (id) {
+      return `https://www.youtube.com/embed/${id}`;
+    } else {
+      throw new Error(`Unexpected problem parsing share URL -- "${url}" -- into a YouTube embed URL`);
+    }
+  } else {
+    throw new Error(`Unexpected URL structure; unable to convert "${url}" to a YouTube embed URL`);
+  }
+};
+var youtubeMeta = (url) => {
+  return isYouTubeUrl(url) ? {
+    url,
+    isYouTubeUrl: true,
+    isShareUrl: isYouTubeShareUrl(url),
+    pageType: getYouTubePageType(url)
+  } : {
+    url,
+    isYouTubeUrl: false
+  };
+};
+
+// src/runtime/meta/urlMeta.ts
+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) => {
+  const val2 = ensureLeading(val, "/");
+  return val === "" ? "" : stripTrailing(val2, "/");
+};
+var getUrlPath = (url) => {
+  return isUrl(url) ? ensurePath(
+    stripAfter(stripBefore(removeUrlProtocol(url), "/"), "?")
+  ) : Never;
+};
+var getUrlQueryParams = (url, specific = void 0) => {
+  const qp = stripBefore(url, "?");
+  if (specific) {
+    return qp.includes(`${specific}=`) ? decodeURIComponent(
+      stripAfter(
+        stripBefore(qp, `${specific}=`),
+        "&"
+      ).replace(/\+/g, "%20")
+    ) : void 0;
+  }
+  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))
+  };
+};
+
+// src/runtime/queues/fifo.ts
+var queue = (state) => ({
+  queue: state,
+  size: state.length,
+  isEmpty() {
+    return state.length === 0;
+  },
+  clear() {
+    state.slice(0, 0);
+  },
+  drain() {
+    const old_state = [...state];
+    state.slice(0, 0);
+    return old_state;
+  },
+  push(...add) {
+    state.push(...add);
+  },
+  drop(quantity) {
+    if (quantity && quantity > state.length) {
+      throw new Error("Cannot drop more elements than present in the queue");
+    }
+    state.splice(0, quantity || 1);
+  },
+  take(quantity) {
+    if (quantity && quantity > state.length) {
+      throw new Error("Cannot take more elements than present in the queue");
+    }
+    const result2 = state.slice(0, quantity || 1);
+    state.splice(0, quantity || 1);
+    return result2;
+  },
+  [Symbol.iterator]: function* () {
+    for (let i = 0; i < state.length; i++) {
+      yield state[i];
+    }
+  }
+});
+var createFifoQueue = (...list2) => {
+  return queue([...list2]);
+};
+
+// src/runtime/queues/lifo.ts
+var queue2 = (state) => ({
+  queue: state,
+  size: state.length,
+  isEmpty() {
+    return state.length === 0;
+  },
+  push(...add) {
+    state.push(...add);
+  },
+  drop(quantity) {
+    state.splice(-quantity);
+  },
+  clear() {
+    state.slice(0, 0);
+  },
+  drain() {
+    const old_state = [...state];
+    state.slice(0, 0);
+    return old_state;
+  },
+  take(quantity) {
+    const result2 = state.slice(-quantity);
+    state.splice(-quantity);
+    return result2;
+  },
+  [Symbol.iterator]: function* () {
+    for (let i = state.length - 1; i >= 0; i--) {
+      yield state[i];
+    }
+  }
+});
+var createLifoQueue = (...list2) => {
+  return queue2([...list2]);
+};
+
+// src/runtime/runtime-types/shape-helpers/addToken.ts
+var addToken = (token, ...params) => `<<${token}${params.length > 0 ? `::${params.join("::")}` : ""}>>`;
+
+// src/runtime/runtime-types/shape-helpers/atomics.ts
+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>>";
+
+// src/runtime/runtime-types/shape-helpers/regexToken.ts
+var regexToken = (re, ...rep) => {
+  let exp = "";
+  if (isString(re)) {
+    try {
+      const test = new RegExp(re);
+      if (!isRegExp(test)) {
+        const err = Error(`Invalid RegEx passed into regexToken(${re}, ${JSON.stringify(rep)})!`);
+        err.name = "InvalidRegEx";
+        throw err;
+      } else {
+        exp = re;
+      }
+    } catch (_e) {
+      const err = Error(`Invalid RegEx passed into regexToken(${re}, ${JSON.stringify(rep)})!`);
+      err.name = "InvalidRegEx";
+      throw err;
+    }
+  } else if (isRegExp(re)) {
+    exp = re.toString();
+  }
+  const token = `<<string-set::regexp::${encodeURIComponent(exp)}>>`;
+  return token;
+};
+
+// src/runtime/runtime-types/shape-helpers/singletons.ts
+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"),
+  regex: (exp, ...literalRepresentation) => {
+    const token = regexToken(exp, ...literalRepresentation);
+    return token;
+  },
+  done: () => addToken("string")
+};
+var string = addSingleton("string", stringApi);
+var number = addSingleton("number");
+
+// src/runtime/runtime-types/shape-helpers/functions.ts
+var fn = (..._args) => ({
+  returns: (_rtn) => ({
+    addProperties: (_kv) => {
+      return null;
+    },
+    done: () => {
+      return null;
+    }
+  }),
+  done: () => {
+    const result2 = null;
+    return result2;
+  }
+});
+
+// src/runtime/runtime-types/shape-helpers/literal-containers.ts
+var dictionary = (_obj) => {
+  return null;
+};
+var tuple2 = (..._elements) => {
+  return null;
+};
+
+// src/runtime/runtime-types/shape-helpers/wide-containers.ts
+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;
+};
+
+// src/runtime/runtime-types/shape-helpers/union.ts
+var union2 = (...elements) => {
+  const result2 = elements.map((_el) => {
+  });
+  return result2;
+};
+
+// src/runtime/runtime-types/shape.ts
+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 = (cb) => {
+  const rtn = cb(ShapeApiImplementation);
+  return handleDoneFn(
+    isAddOrDone(rtn) ? rtn.done() : rtn
+  );
+};
+var isShape = (v) => {
+  return isString(v) && v.startsWith("<<") && v.endsWith(">>") && SHAPE_PREFIXES.some((i) => v.startsWith(`<<${i}`)) ? true : false;
+};
+
+// src/runtime/runtime-types/choices.ts
+var choices = "NOT READY";
+
+// src/runtime/runtime-types/list.ts
+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);
+};
+
+// src/runtime/runtime-types/ip6Prefix.ts
+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("");
+};
+
+// src/runtime/runtime-types/asType.ts
+var asType = (token) => {
+  return token;
+};
+var asStringLiteral = (...values) => {
+  return values.map((i) => i);
+};
+
+// src/runtime/runtime-types/asToken.ts
+var asSimpleToken = (_val) => {
+  return "not ready";
+};
+var scalarToToken = {
+  string: "<<string>>",
+  number: "<<number>>",
+  boolean: "<<boolean>>",
+  true: "<<true>>",
+  false: "<<false>>",
+  null: "<<null>>",
+  undefined: "<<undefined>>",
+  unknown: "<<unknown>>",
+  any: "<<any>>",
+  never: "<<never>>"
+};
+var stringLiteral = (str) => {
+  return stripAfter(stripBefore(str, "string("), ")");
+};
+var numericLiteral = (str) => {
+  return stripAfter(stripBefore(str, "number("), ")");
+};
+var simpleScalarTokenToTypeToken = (val) => {
+  return val in scalarToToken ? scalarToToken[val] : val.startsWith("string(") ? stringLiteral(val).includes(",") ? `<<union::[ ${stringLiteral(val).split(/,\s{0,1}/).map((i) => `"${i}"`).join(", ")} ]>>` : `<<string::${stringLiteral(val)}>>` : val.startsWith("number(") ? numericLiteral(val).includes(",") ? `<<union::[ ${numericLiteral(val).split(/,\s{0,1}/).join(", ")} ]>>` : `<<number::${numericLiteral(val)}>>` : `<<never>>`;
+};
+var unionNode = (node) => {
+  return isNumberLike(node) ? `<<number::${node}>>` : isBooleanLike(node) ? `<<${node}>>` : isSimpleContainerToken(node) ? simpleContainerTokenToTypeToken(node) : isSimpleScalarToken(node) ? simpleScalarToken(node) : `<<string::${node}>>`;
+};
+var union3 = (nodes) => {
+  return Array.isArray(nodes) ? nodes.map((n) => unionNode(n)) : nodes.includes(",") ? nodes.split(/,\s{0,1}/).map((n) => unionNode(n)).join(", ") : unionNode(nodes);
+};
+var stripUnion = stripSurround("Union(", ")");
+var simpleUnionTokenToTypeToken = (val) => {
+  return val.startsWith(`Union(`) && val.endsWith(`)`) ? `<<union::[ ${union3(stripUnion(val))} ]>>` : Never;
+};
+var simpleContainerTokenToTypeToken = (_val) => {
+};
+var asTypeToken = (_val) => {
+  return "not ready";
+};
+
+// src/runtime/runtime-types/tokens/simpleToken.ts
+var simpleToken = (token) => token;
+var simpleScalarToken = (token) => token;
+var simpleContainerToken = (token) => token;
+var simpleScalarType = (token) => {
+  const value = simpleScalarToken(token);
+  return value;
+};
+var simpleContainerType = (token) => {
+  const value = simpleContainerToken(token);
+  return value;
+};
+var simpleType = (token) => {
+  const value = isSimpleScalarToken(token) ? simpleScalarType(token) : isSimpleContainerToken(token) ? simpleContainerToken(token) : Never;
+  return value;
+};
+
+// src/runtime/runtime-types/tokens/createTypeToken.ts
+var unionToken = (...els) => {
+  return `<<union::[${jsonValues(els)}]>>`;
+};
+var singleton = (base) => {
+  const handler = (...lits) => {
+    return lits.length === 0 ? base === "string" ? `<<string>>` : `<<number>>` : lits.length === 1 ? base === "string" ? `<<string::${lits[0]}>>` : `<<number::${lits[0]}>>` : base === "string" ? `<<string::${unionToken(...lits)}>>` : `<<number::${unionToken(...lits)}>>`;
+  };
+  return handler;
+};
+var createTypeToken = (base) => {
+  return isAtomicToken(base) ? `<<${base}>>` : isSingletonToken(base) ? singleton(base) : "";
+};
+
+// src/runtime/sets/uniqueKeys.ts
+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
+  ];
+};
+
+// src/runtime/vuejs/asVueRef.ts
+var asVueRef = (value) => ({
+  value,
+  _value: null
+});
+export {
+  ALPHA_CHARS,
+  COMMA,
+  COMMON_OBJ_PROPS,
+  CONSONANTS,
+  DEFAULT_MANY_TO_ONE_MAPPING,
+  DEFAULT_ONE_TO_MANY_MAPPING,
+  DEFAULT_ONE_TO_ONE_MAPPING,
+  ExifCompression,
+  ExifContrast,
+  ExifEmbedPolicy,
+  ExifFlashValues,
+  ExifGainControl,
+  ExifLightSource,
+  ExifPreviewColorSpace,
+  ExifSaturation,
+  ExifSceneCaptureType,
+  ExifSharpness,
+  ExifSubjectDistance,
+  FALSY_TYPE_KINDS,
+  FALSY_VALUES,
+  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,
+  IMAGE_FORMAT_LOOKUP,
+  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,
+  SIMPLE_ARRAY_TOKENS,
+  SIMPLE_CONTAINER_TOKENS,
+  SIMPLE_DICT_TOKENS,
+  SIMPLE_DICT_VALUES,
+  SIMPLE_MAP_KEYS,
+  SIMPLE_MAP_TOKENS,
+  SIMPLE_MAP_VALUES,
+  SIMPLE_OPT_SCALAR_TOKENS,
+  SIMPLE_SCALAR_TOKENS,
+  SIMPLE_SET_TOKENS,
+  SIMPLE_SET_TYPES,
+  SIMPLE_TOKENS,
+  SIMPLE_UNION_TOKENS,
+  SINGULAR_NOUN_ENDINGS,
+  ShapeApiImplementation,
+  TOP_LEVEL_DOMAINS,
+  TT_Atomics,
+  TT_Containers,
+  TT_Functions,
+  TT_SEP,
+  TT_START,
+  TT_STOP,
+  TT_Sets,
+  TT_Singletons,
+  TW_CHROMA,
+  TW_CHROMA_100,
+  TW_CHROMA_200,
+  TW_CHROMA_300,
+  TW_CHROMA_400,
+  TW_CHROMA_50,
+  TW_CHROMA_500,
+  TW_CHROMA_600,
+  TW_CHROMA_700,
+  TW_CHROMA_800,
+  TW_CHROMA_900,
+  TW_CHROMA_950,
+  TW_HUE,
+  TW_LUMINOSITY,
+  TW_LUMIN_100,
+  TW_LUMIN_200,
+  TW_LUMIN_300,
+  TW_LUMIN_400,
+  TW_LUMIN_50,
+  TW_LUMIN_500,
+  TW_LUMIN_600,
+  TW_LUMIN_700,
+  TW_LUMIN_800,
+  TW_LUMIN_900,
+  TW_LUMIN_950,
+  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,
+  asArray,
+  asChars,
+  asEscapeFunction,
+  asOptionalParamFunction,
+  asPhoneFormat,
+  asRecord,
+  asSimpleToken,
+  asString,
+  asStringLiteral,
+  asType,
+  asTypeToken,
+  asVueRef,
+  box,
+  boxDictionaryValues,
+  capitalize,
+  choices,
+  createConstant,
+  createConverter,
+  createCssSelector,
+  createErrorCondition,
+  createFifoQueue,
+  createFnWithProps,
+  createLifoQueue,
+  createTypeToken,
+  cssColor,
+  csv,
+  defineObj,
+  defineTuple,
+  endsWith,
+  ensureLeading,
+  ensureSurround,
+  ensureTrailing,
+  entries,
+  errCondition,
+  filter,
+  find,
+  fnMeta,
+  get,
+  getEach,
+  getPhoneCountryCode,
+  getUrlPath,
+  getUrlPort,
+  getUrlProtocol,
+  getUrlQueryParams,
+  getUrlSource,
+  getYouTubePageType,
+  handleDoneFn,
+  hasDefaultValue,
+  hasIndexOf,
+  hasKeys,
+  hasUrlPort,
+  hasUrlQueryParameter,
+  hasWhiteSpace,
+  idLiteral,
+  idTypeGuard,
+  identity,
+  ifArray,
+  ifArrayPartial,
+  ifBoolean,
+  ifChar,
+  ifContainer,
+  ifDefined,
+  ifFalse,
+  ifFunction,
+  ifHasKey,
+  ifLength,
+  ifLowercaseChar,
+  ifNotNull,
+  ifNull,
+  ifNumber,
+  ifObject,
+  ifSameType,
+  ifScalar,
+  ifString,
+  ifTrue,
+  ifUndefined,
+  ifUppercaseChar,
+  indexOf,
+  intersect,
+  intersection,
+  ip6GroupExpansion,
+  ip6Prefix,
+  isAlpha,
+  isApi,
+  isApiSurface,
+  isArray,
+  isArrayToken,
+  isAtomicToken,
+  isBitbucketUrl,
+  isBoolean,
+  isBooleanLike,
+  isBox,
+  isCodeCommitUrl,
+  isConstant,
+  isContainer,
+  isContainerToken,
+  isCssAspectRatio,
+  isDefined,
+  isDomainName,
+  isDoneFn,
+  isEmail,
+  isEqual,
+  isErrorCondition,
+  isEscapeFunction,
+  isFalse,
+  isFalsy,
+  isFnToken,
+  isFnWithParams,
+  isFunction,
+  isGeneratorToken,
+  isGithubRepoUrl,
+  isGithubUrl,
+  isHexadecimal,
+  isHtmlElement,
+  isIndexable,
+  isInlineSvg,
+  isIp4Address,
+  isIp6Address,
+  isIpAddress,
+  isLength,
+  isLikeRegExp,
+  isMapToken,
+  isNever,
+  isNotNull,
+  isNothing,
+  isNull,
+  isNumber,
+  isNumberLike,
+  isNumericString,
+  isObject,
+  isObjectToken,
+  isOptionalParamFunction,
+  isPhoneNumber,
+  isReadonlyArray,
+  isRecordToken,
+  isRef,
+  isRegExp,
+  isRepoSource,
+  isRepoUrl,
+  isSameTypeOf,
+  isScalar,
+  isSemanticVersion,
+  isSet,
+  isSetToken,
+  isShape,
+  isSimpleContainerToken,
+  isSimpleContainerTokenTuple,
+  isSimpleScalarToken,
+  isSimpleScalarTokenTuple,
+  isSimpleToken,
+  isSimpleTokenTuple,
+  isSingletonToken,
+  isSpecificConstant,
+  isString,
+  isSymbol,
+  isThenable,
+  isTrimable,
+  isTrue,
+  isTruthy,
+  isTuple,
+  isTupleToken,
+  isTypeOf,
+  isTypeToken,
+  isTypeTuple,
+  isUndefined,
+  isUnionSetToken,
+  isUnionToken,
+  isUnset,
+  isUri,
+  isUrl,
+  isUrlPath,
+  isUrlSource,
+  isWeakMapToken,
+  isYouTubeCreatorUrl,
+  isYouTubeFeedUrl,
+  isYouTubePlaylistUrl,
+  isYouTubeShareUrl,
+  isYouTubeUrl,
+  isYouTubeVideoUrl,
+  isYouTubeVideosInPlaylist,
+  joinWith,
+  jsonValue,
+  jsonValues,
+  keysOf,
+  kindError,
+  kindLiteral,
+  last,
+  list,
+  literal,
+  logicalReturns,
+  lowercase,
+  mergeObjects,
+  mergeScalars,
+  mergeTuples,
+  nameLiteral,
+  narrow,
+  never,
+  omit,
+  optional,
+  optionalOrNull,
+  or,
+  orNull,
+  pathJoin,
+  pluralize,
+  removePhoneCountryCode,
+  removeUrlProtocol,
+  result,
+  retain,
+  retainAfter,
+  retainAfterInclusive,
+  retainChars,
+  retainUntil,
+  retainUntilInclusive,
+  retainWhile,
+  reverse,
+  rightWhitespace,
+  shape,
+  sharedKeys,
+  shift,
+  simpleContainerToken,
+  simpleContainerTokenToTypeToken,
+  simpleContainerType,
+  simpleScalarToken,
+  simpleScalarTokenToTypeToken,
+  simpleScalarType,
+  simpleToken,
+  simpleType,
+  simpleUnionTokenToTypeToken,
+  slice,
+  split,
+  startsWith,
+  stripAfter,
+  stripBefore,
+  stripChars,
+  stripLeading,
+  stripSurround,
+  stripTrailing,
+  stripUntil,
+  surround,
+  takeNumericCharacters,
+  takeProp,
+  toCamelCase,
+  toKebabCase,
+  toNumber,
+  toNumericArray,
+  toPascalCase,
+  toSnakeCase,
+  toString,
+  toUppercase,
+  trim,
+  trimEnd,
+  trimLeft,
+  trimRight,
+  trimStart,
+  truncate,
+  tuple,
+  twColor,
+  unbox,
+  uncapitalize,
+  union,
+  unionize,
+  unique,
+  uniqueKeys,
+  uppercase,
+  urlMeta,
+  valuesOf,
+  widen,
+  withDefaults,
+  withKeys,
+  withoutKeys,
+  withoutValue,
+  wrapFn,
+  youtubeEmbed,
+  youtubeMeta
+};