@splendidlabz/utils 1.12.0 → 1.13.0

package/dist/cjs/lib/index.cjs

@@ -38,10 +38,13 @@ __export(lib_exports, {
   composeAsync: () => composeAsync,
   concatMix: () => concatMix,
   createMix: () => createMix,
+  createPluralize: () => createPluralize,
   createSSE: () => createSSE,
   curry: () => curry,
   debounce: () => debounce,
   delay: () => delay,
+  displacePresets: () => displacePresets,
+  displaceSettings: () => displaceSettings,
   extendObject: () => extendObject,
   flattenArrayFields: () => flattenArrayFields,
   flattenObject: () => flattenObject,
@@ -54,6 +57,7 @@ __export(lib_exports, {
   getSymbolValue: () => getSymbolValue,
   getTimeInMs: () => getTimeInMs,
   getType: () => getType,
+  hexToRgb: () => hexToRgb,
   isArray: () => isArray,
   isEmpty: () => isEmpty,
   isEqual: () => isEqual,
@@ -61,12 +65,16 @@ __export(lib_exports, {
   isHashedValue: () => isHashedValue,
   isLastItem: () => isLastItem,
   isObject: () => isObject,
+  isPlural: () => isPlural,
+  isSingular: () => isSingular,
   joinWithConjunction: () => joinWithConjunction,
   last: () => last,
   lastArrayItem: () => lastArrayItem,
   markdown: () => markdown,
   mix: () => mix,
   ms: () => ms,
+  noiseColorMatrix: () => noiseColorMatrix,
+  noisePresets: () => noisePresets,
   normalizeObject: () => normalizeObject,
   notEmpty: () => notEmpty,
   notEqual: () => notEqual,
@@ -86,12 +94,17 @@ __export(lib_exports, {
   sanitize: () => sanitize,
   sanitizeArray: () => sanitizeArray,
   sanitizeObject: () => sanitizeObject,
+  scatter: () => scatter,
+  seededRandom: () => seededRandom,
   shuffle: () => shuffle,
+  singular: () => singular,
   sizeOf: () => sizeOf,
   sort: () => sort,
   splitArray: () => splitArray,
   splitObject: () => splitObject,
   splitUnit: () => splitUnit,
+  statusText: () => statusText,
+  statusTexts: () => statusTexts,
   stripNumbers: () => stripNumbers,
   throttle: () => throttle,
   timeout: () => timeout,
@@ -279,6 +292,19 @@ function isFunction(x) {
   return typeof x === "function";
 }
 
+// src/lib/colors.js
+function hexToRgb(hex) {
+  let h = hex.replace("#", "");
+  if (h.length === 3)
+    h = h.split("").map((c) => c + c).join("");
+  const int = parseInt(h, 16);
+  return {
+    r: +((int >> 16 & 255) / 255).toFixed(3),
+    g: +((int >> 8 & 255) / 255).toFixed(3),
+    b: +((int & 255) / 255).toFixed(3)
+  };
+}
+
 // src/lib/date/days.js
 var DAYS = [
   { short: "Sun", long: "Sunday", numeric: 1 },
@@ -374,7 +400,16 @@ function toRadians(angle) {
   return angle * (Math.PI / 180);
 }
 
-// src/lib/numbers/index.js
+// src/lib/numbers/random.js
+function seededRandom(seed = 1) {
+  let state = seed >>> 0;
+  return () => {
+    state = state * 1664525 + 1013904223 >>> 0;
+    return state / 4294967296;
+  };
+}
+
+// src/lib/numbers/split-unit.js
 function splitUnit(string) {
   if (typeof string === "number") return [string, null];
   const regex = /(-?\d*\.?\d+)\s*([a-z]+)/i;
@@ -644,6 +679,76 @@ function isHashedValue(value, type = "sha256") {
   return null;
 }
 
+// src/lib/http/status-text.js
+var statusTexts = {
+  100: "Continue",
+  101: "Switching Protocols",
+  102: "Processing",
+  103: "Early Hints",
+  200: "OK",
+  201: "Created",
+  202: "Accepted",
+  203: "Non-Authoritative Information",
+  204: "No Content",
+  205: "Reset Content",
+  206: "Partial Content",
+  207: "Multi-Status",
+  208: "Already Reported",
+  226: "IM Used",
+  300: "Multiple Choices",
+  301: "Moved Permanently",
+  302: "Found",
+  303: "See Other",
+  304: "Not Modified",
+  305: "Use Proxy",
+  307: "Temporary Redirect",
+  308: "Permanent Redirect",
+  400: "Bad Request",
+  401: "Unauthorized",
+  402: "Payment Required",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  406: "Not Acceptable",
+  407: "Proxy Authentication Required",
+  408: "Request Timeout",
+  409: "Conflict",
+  410: "Gone",
+  411: "Length Required",
+  412: "Precondition Failed",
+  413: "Payload Too Large",
+  414: "URI Too Long",
+  415: "Unsupported Media Type",
+  416: "Range Not Satisfiable",
+  417: "Expectation Failed",
+  418: "I'm a Teapot",
+  421: "Misdirected Request",
+  422: "Unprocessable Entity",
+  423: "Locked",
+  424: "Failed Dependency",
+  425: "Too Early",
+  426: "Upgrade Required",
+  428: "Precondition Required",
+  429: "Too Many Requests",
+  431: "Request Header Fields Too Large",
+  451: "Unavailable For Legal Reasons",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout",
+  505: "HTTP Version Not Supported",
+  506: "Variant Also Negotiates",
+  507: "Insufficient Storage",
+  508: "Loop Detected",
+  509: "Bandwidth Limit Exceeded",
+  510: "Not Extended",
+  511: "Network Authentication Required"
+};
+function statusText(code) {
+  return statusTexts[code];
+}
+
 // src/lib/objects/loop.js
 function objectForEach(object, callback) {
   Object.entries(object).forEach(([key, value]) => {
@@ -936,13 +1041,12 @@ function splitObject(obj, keys) {
 }
 
 // src/lib/promises/reject.js
-var import_statuses = __toESM(require("statuses"), 1);
 function reject(props, { includeStack = true } = {}) {
-  const { status, statusText, body, message } = props;
+  const { status, statusText: statusText2, body, message } = props;
   const e = new Error();
   const err = {
     status,
-    statusText: statusText || status && (0, import_statuses.default)(status),
+    statusText: statusText2 || status && statusText(status),
     body,
     message,
     stack: includeStack && e.stack
@@ -1055,8 +1159,366 @@ function parseFullName(name) {
 }
 
 // src/lib/strings/pluralize.js
-var import_pluralize = __toESM(require("pluralize"), 1);
-var pluralize = import_pluralize.default;
+function sanitizeRule(rule) {
+  if (typeof rule === "string") return new RegExp("^" + rule + "$", "i");
+  return rule;
+}
+function restoreCase(word, token) {
+  if (word === token) return token;
+  if (word === word.toLowerCase()) return token.toLowerCase();
+  if (word === word.toUpperCase()) return token.toUpperCase();
+  if (word[0] === word[0].toUpperCase()) {
+    return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
+  }
+  return token.toLowerCase();
+}
+function interpolate(str, args) {
+  return str.replace(/\$(\d{1,2})/g, (match, index) => args[index] || "");
+}
+function replace(word, rule) {
+  return word.replace(rule[0], function(match, index) {
+    const result = interpolate(rule[1], arguments);
+    if (match === "") return restoreCase(word[index - 1], result);
+    return restoreCase(match, result);
+  });
+}
+function sanitizeWord(token, word, rules, uncountables) {
+  if (!token.length || uncountables.hasOwnProperty(token)) return word;
+  let len = rules.length;
+  while (len--) {
+    const rule = rules[len];
+    if (rule[0].test(word)) return replace(word, rule);
+  }
+  return word;
+}
+function replaceWord(replaceMap, keepMap, rules, uncountables) {
+  return function(word) {
+    const token = word.toLowerCase();
+    if (keepMap.hasOwnProperty(token)) return restoreCase(word, token);
+    if (replaceMap.hasOwnProperty(token)) {
+      return restoreCase(word, replaceMap[token]);
+    }
+    return sanitizeWord(token, word, rules, uncountables);
+  };
+}
+function checkWord(replaceMap, keepMap, rules, uncountables) {
+  return function(word) {
+    const token = word.toLowerCase();
+    if (keepMap.hasOwnProperty(token)) return true;
+    if (replaceMap.hasOwnProperty(token)) return false;
+    return sanitizeWord(token, token, rules, uncountables) === token;
+  };
+}
+var BASE_IRREGULAR = [
+  // Pronouns.
+  ["I", "we"],
+  ["me", "us"],
+  ["he", "they"],
+  ["she", "they"],
+  ["them", "them"],
+  ["myself", "ourselves"],
+  ["yourself", "yourselves"],
+  ["itself", "themselves"],
+  ["herself", "themselves"],
+  ["himself", "themselves"],
+  ["themself", "themselves"],
+  ["is", "are"],
+  ["was", "were"],
+  ["has", "have"],
+  ["this", "these"],
+  ["that", "those"],
+  // Words ending with a consonant and `o`.
+  ["echo", "echoes"],
+  ["dingo", "dingoes"],
+  ["volcano", "volcanoes"],
+  ["tornado", "tornadoes"],
+  ["torpedo", "torpedoes"],
+  // Ends with `us`.
+  ["genus", "genera"],
+  ["viscus", "viscera"],
+  // Ends with `ma`.
+  ["stigma", "stigmata"],
+  ["stoma", "stomata"],
+  ["dogma", "dogmata"],
+  ["lemma", "lemmata"],
+  ["schema", "schemata"],
+  ["anathema", "anathemata"],
+  // Other irregular rules.
+  ["ox", "oxen"],
+  ["axe", "axes"],
+  ["die", "dice"],
+  ["yes", "yeses"],
+  ["foot", "feet"],
+  ["eave", "eaves"],
+  ["goose", "geese"],
+  ["tooth", "teeth"],
+  ["quiz", "quizzes"],
+  ["human", "humans"],
+  ["proof", "proofs"],
+  ["carve", "carves"],
+  ["valve", "valves"],
+  ["looey", "looies"],
+  ["thief", "thieves"],
+  ["groove", "grooves"],
+  ["pickaxe", "pickaxes"],
+  ["passerby", "passersby"]
+];
+var BASE_PLURAL = [
+  [/s?$/i, "s"],
+  // eslint-disable-next-line no-control-regex
+  [/[^\u0000-\u007F]$/i, "$0"],
+  [/([^aeiou]ese)$/i, "$1"],
+  [/(ax|test)is$/i, "$1es"],
+  [/(alias|[^aou]us|t[lm]as|gas|ris)$/i, "$1es"],
+  [/(e[mn]u)s?$/i, "$1s"],
+  [/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, "$1"],
+  [
+    /(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i,
+    "$1i"
+  ],
+  [/(alumn|alg|vertebr)(?:a|ae)$/i, "$1ae"],
+  [/(seraph|cherub)(?:im)?$/i, "$1im"],
+  [/(her|at|gr)o$/i, "$1oes"],
+  [
+    /(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i,
+    "$1a"
+  ],
+  [
+    /(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i,
+    "$1a"
+  ],
+  [/sis$/i, "ses"],
+  [/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, "$1$2ves"],
+  [/([^aeiouy]|qu)y$/i, "$1ies"],
+  [/([^ch][ieo][ln])ey$/i, "$1ies"],
+  [/(x|ch|ss|sh|zz)$/i, "$1es"],
+  [/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, "$1ices"],
+  [/\b((?:tit)?m|l)(?:ice|ouse)$/i, "$1ice"],
+  [/(pe)(?:rson|ople)$/i, "$1ople"],
+  [/(child)(?:ren)?$/i, "$1ren"],
+  [/eaux$/i, "$0"],
+  [/m[ae]n$/i, "men"],
+  ["thou", "you"]
+];
+var BASE_SINGULAR = [
+  [/s$/i, ""],
+  [/(ss)$/i, "$1"],
+  [/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i, "$1fe"],
+  [/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, "$1f"],
+  [/ies$/i, "y"],
+  [
+    /\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i,
+    "$1ie"
+  ],
+  [/\b(mon|smil)ies$/i, "$1ey"],
+  [/\b((?:tit)?m|l)ice$/i, "$1ouse"],
+  [/(seraph|cherub)im$/i, "$1"],
+  [
+    /(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i,
+    "$1"
+  ],
+  [
+    /(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i,
+    "$1sis"
+  ],
+  [/(movie|twelve|abuse|e[mn]u)s$/i, "$1"],
+  [/(test)(?:is|es)$/i, "$1is"],
+  [
+    /(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i,
+    "$1us"
+  ],
+  [
+    /(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i,
+    "$1um"
+  ],
+  [
+    /(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i,
+    "$1on"
+  ],
+  [/(alumn|alg|vertebr)ae$/i, "$1a"],
+  [/(cod|mur|sil|vert|ind)ices$/i, "$1ex"],
+  [/(matr|append)ices$/i, "$1ix"],
+  [/(pe)(rson|ople)$/i, "$1rson"],
+  [/(child)ren$/i, "$1"],
+  [/(eau)x?$/i, "$1"],
+  [/men$/i, "man"]
+];
+var BASE_UNCOUNTABLE = [
+  // Singular words with no plurals.
+  "adulthood",
+  "advice",
+  "agenda",
+  "aid",
+  "aircraft",
+  "alcohol",
+  "ammo",
+  "analytics",
+  "anime",
+  "athletics",
+  "audio",
+  "bison",
+  "blood",
+  "bream",
+  "buffalo",
+  "butter",
+  "carp",
+  "cash",
+  "chassis",
+  "chess",
+  "clothing",
+  "cod",
+  "commerce",
+  "cooperation",
+  "corps",
+  "debris",
+  "diabetes",
+  "digestion",
+  "elk",
+  "energy",
+  "equipment",
+  "excretion",
+  "expertise",
+  "firmware",
+  "flounder",
+  "fun",
+  "gallows",
+  "garbage",
+  "graffiti",
+  "hardware",
+  "headquarters",
+  "health",
+  "herpes",
+  "highjinks",
+  "homework",
+  "housework",
+  "information",
+  "jeans",
+  "justice",
+  "kudos",
+  "labour",
+  "literature",
+  "machinery",
+  "mackerel",
+  "mail",
+  "media",
+  "mews",
+  "moose",
+  "music",
+  "mud",
+  "manga",
+  "news",
+  "only",
+  "personnel",
+  "pike",
+  "plankton",
+  "pliers",
+  "police",
+  "pollution",
+  "premises",
+  "rain",
+  "research",
+  "rice",
+  "salmon",
+  "scissors",
+  "series",
+  "sewage",
+  "shambles",
+  "shrimp",
+  "software",
+  "species",
+  "staff",
+  "swine",
+  "tennis",
+  "traffic",
+  "transportation",
+  "trout",
+  "tuna",
+  "wealth",
+  "welfare",
+  "whiting",
+  "wildebeest",
+  "wildlife",
+  "you",
+  /pok[eé]mon$/i,
+  // Regexes.
+  /[^aeiou]ese$/i,
+  // "chinese", "japanese"
+  /deer$/i,
+  // "deer", "reindeer"
+  /fish$/i,
+  // "fish", "blowfish", "angelfish"
+  /measles$/i,
+  /o[iu]s$/i,
+  // "carnivorous"
+  /pox$/i,
+  // "chickpox", "smallpox"
+  /sheep$/i
+];
+function createPluralize(config = {}) {
+  const pluralRules = [];
+  const singularRules = [];
+  const uncountables = {};
+  const irregularPlurals = {};
+  const irregularSingles = {};
+  for (const [single, plur] of [
+    ...BASE_IRREGULAR,
+    ...config.irregular || []
+  ]) {
+    irregularSingles[single.toLowerCase()] = plur.toLowerCase();
+    irregularPlurals[plur.toLowerCase()] = single.toLowerCase();
+  }
+  for (const [rule, replacement] of [...BASE_PLURAL, ...config.plural || []]) {
+    pluralRules.push([sanitizeRule(rule), replacement]);
+  }
+  for (const [rule, replacement] of [
+    ...BASE_SINGULAR,
+    ...config.singular || []
+  ]) {
+    singularRules.push([sanitizeRule(rule), replacement]);
+  }
+  for (const word of [...BASE_UNCOUNTABLE, ...config.uncountable || []]) {
+    if (typeof word === "string") {
+      uncountables[word.toLowerCase()] = true;
+    } else {
+      pluralRules.push([sanitizeRule(word), "$0"]);
+      singularRules.push([sanitizeRule(word), "$0"]);
+    }
+  }
+  const plural2 = replaceWord(
+    irregularSingles,
+    irregularPlurals,
+    pluralRules,
+    uncountables
+  );
+  const singular2 = replaceWord(
+    irregularPlurals,
+    irregularSingles,
+    singularRules,
+    uncountables
+  );
+  const isPlural2 = checkWord(
+    irregularSingles,
+    irregularPlurals,
+    pluralRules,
+    uncountables
+  );
+  const isSingular2 = checkWord(
+    irregularPlurals,
+    irregularSingles,
+    singularRules,
+    uncountables
+  );
+  function pluralize2(word, count, inclusive) {
+    const out = count === 1 ? singular2(word) : plural2(word);
+    return (inclusive ? count + " " : "") + out;
+  }
+  return Object.assign(pluralize2, { plural: plural2, singular: singular2, isPlural: isPlural2, isSingular: isSingular2 });
+}
+var pluralize = createPluralize();
+var plural = pluralize.plural;
+var singular = pluralize.singular;
+var isPlural = pluralize.isPlural;
+var isSingular = pluralize.isSingular;
 
 // src/lib/strings/query-string.js
 function toQueryString(object) {
@@ -1090,15 +1552,34 @@ function parseQueryString(string = "") {
   }
   return result;
 }
-function plural(count, noun, suffix = "s") {
-  console.warn("plural is deprecated. Use pluralize instead");
-  return `${count} ${noun}${count !== 1 ? suffix : ""}`;
-}
 function stripNumbers(string) {
   return string.replace(/\d*/, "");
 }
 
-// src/lib/style/index.js
+// src/lib/style/scatter.js
+var round = (n) => {
+  const value = Math.round(n * 100) / 100;
+  return value === 0 ? 0 : value;
+};
+function scatter(count, options = {}) {
+  const { seed = 1, spread = 20, rotation = 6, amount = 1 } = options;
+  const random = seededRandom(seed);
+  const items = [];
+  for (let i = 0; i < count; i++) {
+    const x = round((random() - 0.5) * 2 * spread * amount);
+    const y = round((random() - 0.5) * 2 * spread * amount);
+    const r = round((random() - 0.5) * 2 * rotation * amount);
+    items.push({
+      x,
+      y,
+      rotation: r,
+      transform: `translate(${x}%, ${y}%) rotate(${r}deg)`
+    });
+  }
+  return items;
+}
+
+// src/lib/style/to-style-string.js
 function toStyleString(style) {
   if (!style) return null;
   if (typeof style === "string") return style;
@@ -1108,6 +1589,85 @@ function toStyleString(style) {
   }).join("; ").concat(";");
 }
 
+// src/lib/svg/displace.js
+var displacePresets = {
+  // Ink bleeding into absorbent paper. Long wavelength, small push.
+  "wet-ink": {
+    type: "fractalNoise",
+    frequency: 0.015,
+    octaves: 3,
+    scale: 9,
+    seed: 2
+  },
+  // Ink bitten into paper tooth. The edge roughens without the letterform
+  // moving, so this is the only preset that survives at body sizes.
+  letterpress: {
+    type: "fractalNoise",
+    frequency: 0.09,
+    octaves: 1,
+    scale: 2,
+    seed: 5
+  },
+  // Air over heat. Anisotropic so the shimmer rises instead of swimming.
+  // Reads as nothing unless animated.
+  "heat-haze": {
+    type: "fractalNoise",
+    frequency: [4e-3, 0.02],
+    animateTo: [6e-3, 0.03],
+    duration: 8,
+    octaves: 2,
+    scale: 7,
+    seed: 11
+  },
+  // Tracking error on worn tape. A near-infinite horizontal wavelength against
+  // a very short vertical one is what tears rather than blobs.
+  "bad-tape": {
+    type: "turbulence",
+    frequency: [8e-4, 0.06],
+    animateTo: [8e-4, 0.09],
+    duration: 2.5,
+    octaves: 1,
+    scale: 14,
+    seed: 3
+  },
+  // Past the shred threshold on purpose.
+  shred: {
+    type: "turbulence",
+    frequency: 0.055,
+    octaves: 2,
+    scale: 32,
+    seed: 7
+  }
+};
+var format = (f) => Array.isArray(f) ? f.join(" ") : String(f);
+function displaceSettings(opts = {}) {
+  const base = opts.preset && displacePresets[opts.preset] || displacePresets["wet-ink"];
+  const frequency = opts.frequency ?? base.frequency;
+  const animateTo = opts.animateTo ?? base.animateTo;
+  return {
+    type: opts.type ?? base.type,
+    frequency: format(frequency),
+    animateTo: animateTo ? format(animateTo) : null,
+    duration: opts.duration ?? base.duration ?? 6,
+    octaves: opts.octaves ?? base.octaves,
+    scale: opts.scale ?? base.scale,
+    seed: opts.seed ?? base.seed
+  };
+}
+
+// src/lib/svg/noise.js
+var noisePresets = {
+  black: "#000000",
+  sepia: "#a67c52",
+  synthwave: "#ff2bd6"
+};
+function noiseColorMatrix(color, strength) {
+  if (!color || color === "rainbow")
+    return `1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 ${strength} 0`;
+  const { r, g, b } = hexToRgb(noisePresets[color] ?? color);
+  return `0 0 0 0 ${r} 0 0 0 0 ${g} 0 0 0 0 ${b} 0 0 0 ${strength} 0`;
+}
+
 // src/lib/symbols/symbols.js
 function getSymbol(object, description) {
   return Object.getOwnPropertySymbols(object).find(
@@ -1128,10 +1688,13 @@ function getSymbolValue(object, description) {
   composeAsync,
   concatMix,
   createMix,
+  createPluralize,
   createSSE,
   curry,
   debounce,
   delay,
+  displacePresets,
+  displaceSettings,
   extendObject,
   flattenArrayFields,
   flattenObject,
@@ -1144,6 +1707,7 @@ function getSymbolValue(object, description) {
   getSymbolValue,
   getTimeInMs,
   getType,
+  hexToRgb,
   isArray,
   isEmpty,
   isEqual,
@@ -1151,12 +1715,16 @@ function getSymbolValue(object, description) {
   isHashedValue,
   isLastItem,
   isObject,
+  isPlural,
+  isSingular,
   joinWithConjunction,
   last,
   lastArrayItem,
   markdown,
   mix,
   ms,
+  noiseColorMatrix,
+  noisePresets,
   normalizeObject,
   notEmpty,
   notEqual,
@@ -1176,12 +1744,17 @@ function getSymbolValue(object, description) {
   sanitize,
   sanitizeArray,
   sanitizeObject,
+  scatter,
+  seededRandom,
   shuffle,
+  singular,
   sizeOf,
   sort,
   splitArray,
   splitObject,
   splitUnit,
+  statusText,
+  statusTexts,
   stripNumbers,
   throttle,
   timeout,