@oscarpalmer/atoms 0.59.0 → 0.60.0

package/dist/js/array/index.js

@@ -19,11 +19,12 @@ function insert(array, index, values) {
   insertValues("splice", array, values, index, 0);
 }
 function insertValues(type, array, values, start, deleteCount) {
-  const chunked = chunk(values).reverse();
-  const { length } = chunked;
+  const chunked = chunk(values);
+  const lastIndex = chunked.length - 1;
+  let index = Number(chunked.length);
   let returned;
-  for (let index = 0;index < length; index += 1) {
-    const result = array.splice(start, index === 0 ? deleteCount : 0, ...chunked[index]);
+  while (--index >= 0) {
+    const result = array.splice(start, index === lastIndex ? deleteCount : 0, ...chunked[index]);
     if (returned == null) {
       returned = result;
     }
@@ -155,6 +156,25 @@ function groupValues(array, key, arrays, indicable) {
 function indexOf(array, value, key) {
   return findValue("index", array, value, key);
 }
+// src/js/random.ts
+function getRandomFloat(min, max) {
+  const minimum = min ?? Number.MIN_SAFE_INTEGER;
+  return Math.random() * ((max ?? Number.MAX_SAFE_INTEGER) - minimum) + minimum;
+}
+function getRandomInteger(min, max) {
+  return Math.floor(getRandomFloat(min, max));
+}
+
+// src/js/array/shuffle.ts
+function shuffle2(array) {
+  const shuffled = array.slice();
+  const { length } = shuffled;
+  for (let index = 0;index < length; index += 1) {
+    const random2 = getRandomInteger(0, length);
+    [shuffled[index], shuffled[random2]] = [shuffled[random2], shuffled[index]];
+  }
+  return shuffled;
+}
 // src/js/is.ts
 function isKey(value) {
   return typeof value === "number" || typeof value === "string";
@@ -254,6 +274,7 @@ export {
   toMap,
   splice,
   sort,
+  shuffle2 as shuffle,
   push,
   insert,
   indexOf,

package/dist/js/array/index.mjs

@@ -17,6 +17,8 @@ import {groupBy} from "./group-by";
 
 export * from "./index-of";
 import {insert as insert2} from "./insert";
+
+export * from "./shuffle";
 import {sort} from "./sort";
 
 export * from "./splice";

package/dist/js/array/insert.mjs

@@ -4,11 +4,12 @@ function insert(array, index, values) {
   insertValues("splice", array, values, index, 0);
 }
 function insertValues(type, array, values, start, deleteCount) {
-  const chunked = chunk2(values).reverse();
-  const { length } = chunked;
+  const chunked = chunk2(values);
+  const lastIndex = chunked.length - 1;
+  let index = Number(chunked.length);
   let returned;
-  for (let index = 0;index < length; index += 1) {
-    const result = array.splice(start, index === 0 ? deleteCount : 0, ...chunked[index]);
+  while (--index >= 0) {
+    const result = array.splice(start, index === lastIndex ? deleteCount : 0, ...chunked[index]);
     if (returned == null) {
       returned = result;
     }

package/dist/js/array/shuffle.mjs

@@ -0,0 +1,14 @@
+// src/js/array/shuffle.ts
+import {getRandomInteger} from "../random";
+function shuffle(array) {
+  const shuffled = array.slice();
+  const { length } = shuffled;
+  for (let index = 0;index < length; index += 1) {
+    const random2 = getRandomInteger(0, length);
+    [shuffled[index], shuffled[random2]] = [shuffled[random2], shuffled[index]];
+  }
+  return shuffled;
+}
+export {
+  shuffle
+};

package/dist/js/index.js

@@ -19,11 +19,12 @@ function insert(array, index, values) {
   insertValues("splice", array, values, index, 0);
 }
 function insertValues(type, array, values, start, deleteCount) {
-  const chunked = chunk(values).reverse();
-  const { length } = chunked;
+  const chunked = chunk(values);
+  const lastIndex = chunked.length - 1;
+  let index = Number(chunked.length);
   let returned;
-  for (let index = 0;index < length; index += 1) {
-    const result = array.splice(start, index === 0 ? deleteCount : 0, ...chunked[index]);
+  while (--index >= 0) {
+    const result = array.splice(start, index === lastIndex ? deleteCount : 0, ...chunked[index]);
     if (returned == null) {
       returned = result;
     }
@@ -155,6 +156,59 @@ function groupValues(array, key, arrays, indicable) {
 function indexOf(array, value, key) {
   return findValue("index", array, value, key);
 }
+// src/js/random.ts
+function getRandomBoolean() {
+  return Math.random() > 0.5;
+}
+function getRandomCharacters(length, selection) {
+  if (length < 1) {
+    return "";
+  }
+  const actualSelection = typeof selection === "string" && selection.length > 0 ? selection : "abcdefghijklmnopqrstuvwxyz";
+  let characters = "";
+  for (let index = 0;index < length; index += 1) {
+    characters += actualSelection.charAt(getRandomInteger(0, actualSelection.length));
+  }
+  return characters;
+}
+function getRandomColour() {
+  return `#${Array.from({ length: 6 }, getRandomHex).join("")}`;
+}
+function getRandomDate(earliest, latest) {
+  const earliestTime = earliest?.getTime() ?? -8640000000000000;
+  const latestTime = latest?.getTime() ?? 8640000000000000;
+  return new Date(getRandomInteger(earliestTime, latestTime));
+}
+function getRandomFloat(min, max) {
+  const minimum = min ?? Number.MIN_SAFE_INTEGER;
+  return Math.random() * ((max ?? Number.MAX_SAFE_INTEGER) - minimum) + minimum;
+}
+function getRandomHex() {
+  return "0123456789ABCDEF"[getRandomInteger(0, 16)];
+}
+function getRandomInteger(min, max) {
+  return Math.floor(getRandomFloat(min, max));
+}
+function getRandomItem(array) {
+  return array[getRandomInteger(0, array.length)];
+}
+function getRandomItems(array, amount) {
+  if (amount === 1) {
+    return array.length === 0 ? [] : [array[getRandomInteger(0, array.length)]];
+  }
+  return amount == null || amount >= array.length ? shuffle2(array) : shuffle2(array).slice(0, amount);
+}
+
+// src/js/array/shuffle.ts
+function shuffle2(array) {
+  const shuffled = array.slice();
+  const { length } = shuffled;
+  for (let index = 0;index < length; index += 1) {
+    const random2 = getRandomInteger(0, length);
+    [shuffled[index], shuffled[random2]] = [shuffled[random2], shuffled[index]];
+  }
+  return shuffled;
+}
 // src/js/string/index.ts
 function createUuid() {
   return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (substring) => (substring ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> substring / 4).toString(16));
@@ -1065,8 +1119,10 @@ function sum(values) {
 }
 // src/js/value/index.ts
 function partial(value, keys) {
+  const { length } = keys;
   const result = {};
-  for (const key of keys) {
+  for (let index = 0;index < length; index += 1) {
+    const key = keys[index];
     result[key] = value[key];
   }
   return result;
@@ -1353,19 +1409,12 @@ function setValue(data2, path, value, ignoreCase) {
   let target = typeof data2 === "object" && data2 !== null ? data2 : {};
   for (let index = 0;index < length; index += 1) {
     const part = parts[index];
-    if (parts.indexOf(part) === lastIndex) {
+    if (index === lastIndex) {
       handleValue(target, part, value, false, shouldIgnoreCase);
       break;
     }
     let next = handleValue(target, part, null, true, shouldIgnoreCase);
     if (typeof next !== "object" || next === null) {
-      if (isNumerical(part) && previous != null) {
-        const temporary = previous[parts[index - 1]];
-        if (!Array.isArray(temporary)) {
-          previous[parts[index - 1]] = typeof temporary === "object" && temporary !== null && Object.keys(temporary).every(isNumerical) ? Object.values(temporary) : [];
-          target = previous[parts[index - 1]];
-        }
-      }
       next = {};
       target[part] = next;
     }
@@ -1374,6 +1423,59 @@ function setValue(data2, path, value, ignoreCase) {
   }
   return data2;
 }
+// src/js/value/smush.ts
+var flatten2 = function(value, prefix) {
+  const keys = Object.keys(value);
+  const { length } = keys;
+  const smushed = {};
+  for (let index = 0;index < length; index += 1) {
+    const key = keys[index];
+    const val = value[key];
+    if (isArrayOrPlainObject(val)) {
+      Object.assign(smushed, {
+        [join([prefix, key], ".")]: Array.isArray(val) ? [...val] : { ...val },
+        ...flatten2(val, join([prefix, key], "."))
+      });
+    } else {
+      smushed[join([prefix, key], ".")] = val;
+    }
+  }
+  return smushed;
+};
+function smush(value) {
+  return flatten2(value);
+}
+// src/js/value/unsmush.ts
+var getKeyGroups = function(value) {
+  const keys = Object.keys(value);
+  const { length } = keys;
+  const grouped = [];
+  for (let index = 0;index < length; index += 1) {
+    const key = keys[index];
+    const dots = key.split(".");
+    if (grouped[dots.length] == null) {
+      grouped[dots.length] = [key];
+    } else {
+      grouped[dots.length].push(key);
+    }
+  }
+  return grouped;
+};
+function unsmush(value) {
+  const groups = getKeyGroups(value);
+  const { length } = groups;
+  const unsmushed = {};
+  for (let groupIndex = 1;groupIndex < length; groupIndex += 1) {
+    const group = groups[groupIndex];
+    const groupLength = group.length;
+    for (let keyIndex = 0;keyIndex < groupLength; keyIndex += 1) {
+      const key = group[keyIndex];
+      const val = value[key];
+      setValue(unsmushed, key, isArrayOrPlainObject(val) ? Array.isArray(val) ? [...val] : { ...val } : val);
+    }
+  }
+  return unsmushed;
+}
 // src/js/query.ts
 function fromQuery(query) {
   const parts = query.split("&");
@@ -1453,42 +1555,6 @@ if (globalThis._atomic_queued == null) {
     }
   });
 }
-// src/js/random.ts
-function getRandomBoolean() {
-  return Math.random() > 0.5;
-}
-function getRandomCharacters(length, selection) {
-  if (length < 1) {
-    return "";
-  }
-  const actualSelection = typeof selection === "string" && selection.length > 0 ? selection : "abcdefghijklmnopqrstuvwxyz";
-  let characters = "";
-  for (let index = 0;index < length; index += 1) {
-    characters += actualSelection.charAt(getRandomInteger(0, actualSelection.length));
-  }
-  return characters;
-}
-function getRandomColour() {
-  return `#${Array.from({ length: 6 }, getRandomHex).join("")}`;
-}
-function getRandomDate(earliest, latest) {
-  const earliestTime = earliest?.getTime() ?? -8640000000000000;
-  const latestTime = latest?.getTime() ?? 8640000000000000;
-  return new Date(getRandomInteger(earliestTime, latestTime));
-}
-function getRandomFloat(min2, max2) {
-  const minimum = min2 ?? Number.MIN_SAFE_INTEGER;
-  return Math.random() * ((max2 ?? Number.MAX_SAFE_INTEGER) - minimum) + minimum;
-}
-function getRandomHex() {
-  return "0123456789ABCDEF"[getRandomInteger(0, 16)];
-}
-function getRandomInteger(min2, max2) {
-  return Math.floor(getRandomFloat(min2, max2));
-}
-function getRandomItem(array2) {
-  return array2[getRandomInteger(0, array2.length)];
-}
 // src/js/timer.ts
 function delay(time2, timeout) {
   return new Promise((resolve, reject) => {
@@ -1502,20 +1568,20 @@ function delay(time2, timeout) {
 var getValueOrDefault = function(value2, defaultValue) {
   return typeof value2 === "number" && value2 > 0 ? value2 : defaultValue;
 };
-var is9 = function(value2, pattern) {
+var is10 = function(value2, pattern) {
   return pattern.test(value2?.$timer);
 };
 function isRepeated(value2) {
-  return is9(value2, /^repeat$/);
+  return is10(value2, /^repeat$/);
 }
 function isTimer(value2) {
-  return is9(value2, /^repeat|wait$/);
+  return is10(value2, /^repeat|wait$/);
 }
 function isWaited(value2) {
-  return is9(value2, /^wait$/);
+  return is10(value2, /^wait$/);
 }
 function isWhen(value2) {
-  return is9(value2, /^when$/) && typeof value2.then === "function";
+  return is10(value2, /^when$/) && typeof value2.then === "function";
 }
 function repeat(callback, options) {
   return timer("repeat", callback, options ?? {}, true);
@@ -1773,6 +1839,7 @@ export {
   words,
   when,
   wait,
+  unsmush,
   unique,
   truncate,
   toRecord,
@@ -1783,6 +1850,8 @@ export {
   splice,
   sort,
   snakeCase,
+  smush,
+  shuffle2 as shuffle,
   setValue,
   setStyles,
   setData,
@@ -1829,6 +1898,7 @@ export {
   getTextDirection,
   getTabbableElements,
   getString,
+  getRandomItems,
   getRandomItem,
   getRandomInteger,
   getRandomHex,

package/dist/js/query.js

@@ -21,12 +21,6 @@ function join(value, delimiter) {
 function isNullableOrWhitespace(value) {
   return value == null || /^\s*$/.test(getString(value));
 }
-function isNumber(value) {
-  return typeof value === "number" && !Number.isNaN(value);
-}
-function isNumerical(value) {
-  return isNumber(value) || typeof value === "string" && value.trim().length > 0 && !Number.isNaN(+value);
-}
 function isPlainObject(value) {
   if (typeof value !== "object" || value === null) {
     return false;
@@ -63,19 +57,12 @@ function setValue(data, path, value, ignoreCase) {
   let target = typeof data === "object" && data !== null ? data : {};
   for (let index = 0;index < length; index += 1) {
     const part = parts[index];
-    if (parts.indexOf(part) === lastIndex) {
+    if (index === lastIndex) {
       handleValue(target, part, value, false, shouldIgnoreCase);
       break;
     }
     let next = handleValue(target, part, null, true, shouldIgnoreCase);
     if (typeof next !== "object" || next === null) {
-      if (isNumerical(part) && previous != null) {
-        const temporary = previous[parts[index - 1]];
-        if (!Array.isArray(temporary)) {
-          previous[parts[index - 1]] = typeof temporary === "object" && temporary !== null && Object.keys(temporary).every(isNumerical) ? Object.values(temporary) : [];
-          target = previous[parts[index - 1]];
-        }
-      }
       next = {};
       target[part] = next;
     }

package/dist/js/random.js

@@ -1,3 +1,14 @@
+// src/js/array/shuffle.ts
+function shuffle(array) {
+  const shuffled = array.slice();
+  const { length } = shuffled;
+  for (let index = 0;index < length; index += 1) {
+    const random2 = getRandomInteger(0, length);
+    [shuffled[index], shuffled[random2]] = [shuffled[random2], shuffled[index]];
+  }
+  return shuffled;
+}
+
 // src/js/random.ts
 function getRandomBoolean() {
   return Math.random() > 0.5;
@@ -34,7 +45,14 @@ function getRandomInteger(min, max) {
 function getRandomItem(array) {
   return array[getRandomInteger(0, array.length)];
 }
+function getRandomItems(array, amount) {
+  if (amount === 1) {
+    return array.length === 0 ? [] : [array[getRandomInteger(0, array.length)]];
+  }
+  return amount == null || amount >= array.length ? shuffle(array) : shuffle(array).slice(0, amount);
+}
 export {
+  getRandomItems,
   getRandomItem,
   getRandomInteger,
   getRandomHex,

package/dist/js/random.mjs

@@ -1,4 +1,5 @@
 // src/js/random.ts
+import {shuffle as shuffle2} from "./array/shuffle";
 function getRandomBoolean() {
   return Math.random() > 0.5;
 }
@@ -34,7 +35,14 @@ function getRandomInteger(min, max) {
 function getRandomItem(array) {
   return array[getRandomInteger(0, array.length)];
 }
+function getRandomItems(array, amount) {
+  if (amount === 1) {
+    return array.length === 0 ? [] : [array[getRandomInteger(0, array.length)]];
+  }
+  return amount == null || amount >= array.length ? shuffle2(array) : shuffle2(array).slice(0, amount);
+}
 export {
+  getRandomItems,
   getRandomItem,
   getRandomInteger,
   getRandomHex,

package/dist/js/value/index.js

@@ -1,7 +1,9 @@
 // src/js/value/index.ts
 function partial(value, keys) {
+  const { length } = keys;
   const result = {};
-  for (const key of keys) {
+  for (let index = 0;index < length; index += 1) {
+    const key = keys[index];
     result[key] = value[key];
   }
   return result;
@@ -29,12 +31,6 @@ function join(value, delimiter) {
 function isArrayOrPlainObject(value) {
   return Array.isArray(value) || isPlainObject(value);
 }
-function isNumber(value) {
-  return typeof value === "number" && !Number.isNaN(value);
-}
-function isNumerical(value) {
-  return isNumber(value) || typeof value === "string" && value.trim().length > 0 && !Number.isNaN(+value);
-}
 function isPlainObject(value) {
   if (typeof value !== "object" || value === null) {
     return false;
@@ -324,19 +320,12 @@ function setValue(data, path, value, ignoreCase) {
   let target = typeof data === "object" && data !== null ? data : {};
   for (let index = 0;index < length; index += 1) {
     const part = parts[index];
-    if (parts.indexOf(part) === lastIndex) {
+    if (index === lastIndex) {
       handleValue(target, part, value, false, shouldIgnoreCase);
       break;
     }
     let next = handleValue(target, part, null, true, shouldIgnoreCase);
     if (typeof next !== "object" || next === null) {
-      if (isNumerical(part) && previous != null) {
-        const temporary = previous[parts[index - 1]];
-        if (!Array.isArray(temporary)) {
-          previous[parts[index - 1]] = typeof temporary === "object" && temporary !== null && Object.keys(temporary).every(isNumerical) ? Object.values(temporary) : [];
-          target = previous[parts[index - 1]];
-        }
-      }
       next = {};
       target[part] = next;
     }
@@ -345,7 +334,62 @@ function setValue(data, path, value, ignoreCase) {
   }
   return data;
 }
+// src/js/value/smush.ts
+var flatten = function(value, prefix) {
+  const keys = Object.keys(value);
+  const { length } = keys;
+  const smushed = {};
+  for (let index = 0;index < length; index += 1) {
+    const key = keys[index];
+    const val = value[key];
+    if (isArrayOrPlainObject(val)) {
+      Object.assign(smushed, {
+        [join([prefix, key], ".")]: Array.isArray(val) ? [...val] : { ...val },
+        ...flatten(val, join([prefix, key], "."))
+      });
+    } else {
+      smushed[join([prefix, key], ".")] = val;
+    }
+  }
+  return smushed;
+};
+function smush(value) {
+  return flatten(value);
+}
+// src/js/value/unsmush.ts
+var getKeyGroups = function(value) {
+  const keys = Object.keys(value);
+  const { length } = keys;
+  const grouped = [];
+  for (let index = 0;index < length; index += 1) {
+    const key = keys[index];
+    const dots = key.split(".");
+    if (grouped[dots.length] == null) {
+      grouped[dots.length] = [key];
+    } else {
+      grouped[dots.length].push(key);
+    }
+  }
+  return grouped;
+};
+function unsmush(value) {
+  const groups = getKeyGroups(value);
+  const { length } = groups;
+  const unsmushed = {};
+  for (let groupIndex = 1;groupIndex < length; groupIndex += 1) {
+    const group = groups[groupIndex];
+    const groupLength = group.length;
+    for (let keyIndex = 0;keyIndex < groupLength; keyIndex += 1) {
+      const key = group[keyIndex];
+      const val = value[key];
+      setValue(unsmushed, key, isArrayOrPlainObject(val) ? Array.isArray(val) ? [...val] : { ...val } : val);
+    }
+  }
+  return unsmushed;
+}
 export {
+  unsmush,
+  smush,
   setValue,
   partial,
   merge,

package/dist/js/value/index.mjs

@@ -1,7 +1,9 @@
 // src/js/value/index.ts
 function partial(value, keys) {
+  const { length } = keys;
   const result = {};
-  for (const key of keys) {
+  for (let index = 0;index < length; index += 1) {
+    const key = keys[index];
     result[key] = value[key];
   }
   return result;
@@ -13,6 +15,8 @@ export * from "./equal";
 export * from "./get";
 export * from "./merge";
 export * from "./set";
+export * from "./smush";
+export * from "./unsmush";
 export {
   partial
 };

package/dist/js/value/set.mjs

@@ -1,6 +1,5 @@
 // src/js/value/set.ts
 import {handleValue} from "../internal/value-handle";
-import {isNumerical} from "../is";
 function setValue(data, path, value, ignoreCase) {
   const shouldIgnoreCase = ignoreCase === true;
   const parts = (shouldIgnoreCase ? path.toLowerCase() : path).split(".");
@@ -10,19 +9,12 @@ function setValue(data, path, value, ignoreCase) {
   let target = typeof data === "object" && data !== null ? data : {};
   for (let index = 0;index < length; index += 1) {
     const part = parts[index];
-    if (parts.indexOf(part) === lastIndex) {
+    if (index === lastIndex) {
       handleValue(target, part, value, false, shouldIgnoreCase);
       break;
     }
     let next = handleValue(target, part, null, true, shouldIgnoreCase);
     if (typeof next !== "object" || next === null) {
-      if (isNumerical(part) && previous != null) {
-        const temporary = previous[parts[index - 1]];
-        if (!Array.isArray(temporary)) {
-          previous[parts[index - 1]] = typeof temporary === "object" && temporary !== null && Object.keys(temporary).every(isNumerical) ? Object.values(temporary) : [];
-          target = previous[parts[index - 1]];
-        }
-      }
       next = {};
       target[part] = next;
     }

package/dist/js/value/smush.mjs

@@ -0,0 +1,27 @@
+// src/js/value/smush.ts
+import {isArrayOrPlainObject} from "../is";
+import {join} from "../string";
+var flatten = function(value, prefix) {
+  const keys = Object.keys(value);
+  const { length } = keys;
+  const smushed = {};
+  for (let index = 0;index < length; index += 1) {
+    const key = keys[index];
+    const val = value[key];
+    if (isArrayOrPlainObject(val)) {
+      Object.assign(smushed, {
+        [join([prefix, key], ".")]: Array.isArray(val) ? [...val] : { ...val },
+        ...flatten(val, join([prefix, key], "."))
+      });
+    } else {
+      smushed[join([prefix, key], ".")] = val;
+    }
+  }
+  return smushed;
+};
+function smush(value) {
+  return flatten(value);
+}
+export {
+  smush
+};

package/dist/js/value/unsmush.mjs

@@ -0,0 +1,36 @@
+// src/js/value/unsmush.ts
+import {isArrayOrPlainObject} from "../is";
+import {setValue} from "./set";
+var getKeyGroups = function(value) {
+  const keys = Object.keys(value);
+  const { length } = keys;
+  const grouped = [];
+  for (let index = 0;index < length; index += 1) {
+    const key = keys[index];
+    const dots = key.split(".");
+    if (grouped[dots.length] == null) {
+      grouped[dots.length] = [key];
+    } else {
+      grouped[dots.length].push(key);
+    }
+  }
+  return grouped;
+};
+function unsmush(value) {
+  const groups = getKeyGroups(value);
+  const { length } = groups;
+  const unsmushed = {};
+  for (let groupIndex = 1;groupIndex < length; groupIndex += 1) {
+    const group = groups[groupIndex];
+    const groupLength = group.length;
+    for (let keyIndex = 0;keyIndex < groupLength; keyIndex += 1) {
+      const key = group[keyIndex];
+      const val = value[key];
+      setValue(unsmushed, key, isArrayOrPlainObject(val) ? Array.isArray(val) ? [...val] : { ...val } : val);
+    }
+  }
+  return unsmushed;
+}
+export {
+  unsmush
+};

package/package.json

@@ -4,7 +4,7 @@
 		"url": "https://oscarpalmer.se"
 	},
 	"dependencies": {
-		"type-fest": "^4.21.0"
+		"type-fest": "^4.22.1"
 	},
 	"description": "Sweet little atomic goodies…",
 	"devDependencies": {
@@ -178,5 +178,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.59.0"
+	"version": "0.60.0"
 }

package/src/js/array/index.ts

@@ -25,6 +25,7 @@ export * from './find';
 export {groupBy} from './group-by';
 export * from './index-of';
 export {insert} from './insert';
+export * from './shuffle';
 export {sort} from './sort';
 export * from './splice';
 export * from './to-map';

package/src/js/array/insert.ts

@@ -20,15 +20,16 @@ export function insertValues<Value>(
 	start: number,
 	deleteCount: number,
 ): unknown {
-	const chunked = chunk(values).reverse();
-	const {length} = chunked;
+	const chunked = chunk(values);
+	const lastIndex = chunked.length - 1;
 
+	let index = Number(chunked.length);
 	let returned: Value[] | undefined;
 
-	for (let index = 0; index < length; index += 1) {
+	while (--index >= 0) {
 		const result = array.splice(
 			start,
-			index === 0 ? deleteCount : 0,
+			index === lastIndex ? deleteCount : 0,
 			...chunked[index],
 		);
 

package/src/js/array/shuffle.ts

@@ -0,0 +1,17 @@
+import {getRandomInteger} from '../random';
+
+/**
+ * Shuffles an array
+ */
+export function shuffle<Value>(array: Value[]): Value[] {
+	const shuffled = array.slice();
+	const {length} = shuffled;
+
+	for (let index = 0; index < length; index += 1) {
+		const random = getRandomInteger(0, length);
+
+		[shuffled[index], shuffled[random]] = [shuffled[random], shuffled[index]];
+	}
+
+	return shuffled;
+}

package/src/js/random.ts

@@ -1,3 +1,5 @@
+import {shuffle} from './array/shuffle';
+
 /**
  * Returns a random boolean
  */
@@ -79,3 +81,20 @@ export function getRandomInteger(min?: number, max?: number): number {
 export function getRandomItem<Value>(array: Value[]): Value {
 	return array[getRandomInteger(0, array.length)];
 }
+
+/**
+ * - Returns an amount of random items from an array
+ * - If `amount` is not specified, a shuffled array will be returned instead
+ */
+export function getRandomItems<Value>(
+	array: Value[],
+	amount?: number,
+): Value[] {
+	if (amount === 1) {
+		return array.length === 0 ? [] : [array[getRandomInteger(0, array.length)]];
+	}
+
+	return amount == null || amount >= array.length
+		? shuffle(array)
+		: shuffle(array).slice(0, amount);
+}

package/src/js/value/diff.ts

@@ -28,7 +28,7 @@ type KeyedDiffValue = {
  * 		- `full` if the values are completely different
  * 		- `none` if the values are the same
  * 		- `partial` if the values are partially different
- * 	- `values` holds the differences with dot-notation keys
+ * 	- `values` holds the differences with dot notation keys
  */
 export function diff<First, Second = First>(
 	first: First,

package/src/js/value/index.ts

@@ -7,9 +7,12 @@ export function partial<Value extends PlainObject, Key extends keyof Value>(
 	value: Value,
 	keys: Key[],
 ): Pick<Value, Key> {
+	const {length} = keys;
 	const result = {} as Pick<Value, Key>;
 
-	for (const key of keys) {
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+
 		result[key] = value[key];
 	}
 
@@ -22,3 +25,5 @@ export * from './equal';
 export * from './get';
 export * from './merge';
 export * from './set';
+export * from './smush';
+export * from './unsmush';

package/src/js/value/set.ts

@@ -1,5 +1,4 @@
 import {handleValue} from '../internal/value-handle';
-import {isNumerical} from '../is';
 import type {Paths, PlainObject} from '../models';
 
 /**
@@ -46,7 +45,7 @@ export function setValue<Data extends PlainObject>(
 	for (let index = 0; index < length; index += 1) {
 		const part = parts[index];
 
-		if (parts.indexOf(part) === lastIndex) {
+		if (index === lastIndex) {
 			handleValue(target, part, value, false, shouldIgnoreCase);
 
 			break;
@@ -55,21 +54,6 @@ export function setValue<Data extends PlainObject>(
 		let next = handleValue(target, part, null, true, shouldIgnoreCase);
 
 		if (typeof next !== 'object' || next === null) {
-			if (isNumerical(part) && previous != null) {
-				const temporary = previous[parts[index - 1]];
-
-				if (!Array.isArray(temporary)) {
-					previous[parts[index - 1]] =
-						typeof temporary === 'object' &&
-						temporary !== null &&
-						Object.keys(temporary).every(isNumerical)
-							? Object.values(temporary)
-							: [];
-
-					target = previous[parts[index - 1]] as PlainObject;
-				}
-			}
-
 			next = {};
 
 			target[part] = next;

package/src/js/value/smush.ts

@@ -0,0 +1,38 @@
+import type {Get, Paths, Simplify} from 'type-fest';
+import type {ToString} from 'type-fest/source/internal';
+import {isArrayOrPlainObject} from '../is';
+import type {ArrayOrPlainObject, PlainObject} from '../models';
+import {join} from '../string';
+
+type Smushed<Value> = Simplify<{
+	[Key in Paths<Value>]: Get<Value, ToString<Key>>;
+}>;
+
+function flatten(value: ArrayOrPlainObject, prefix?: string): PlainObject {
+	const keys = Object.keys(value);
+	const {length} = keys;
+	const smushed = {} as Record<string, unknown>;
+
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		const val = value[key as never];
+
+		if (isArrayOrPlainObject(val)) {
+			Object.assign(smushed, {
+				[join([prefix, key], '.')]: Array.isArray(val) ? [...val] : {...val},
+				...flatten(val, join([prefix, key], '.')),
+			});
+		} else {
+			smushed[join([prefix, key], '.')] = val;
+		}
+	}
+
+	return smushed as never;
+}
+
+/**
+ * Smushes an object into a flat object with dot notation keys
+ */
+export function smush<Value extends PlainObject>(value: Value): Smushed<Value> {
+	return flatten(value) as never;
+}

package/src/js/value/unsmush.ts

@@ -0,0 +1,65 @@
+import type {KeysOfUnion, Simplify} from 'type-fest';
+import {isArrayOrPlainObject} from '../is';
+import type {PlainObject} from '../models';
+import {setValue} from './set';
+
+type Unsmushed<Value extends PlainObject> = Simplify<
+	Omit<
+		{
+			[Key in KeysOfUnion<Value>]: Value[Key];
+		},
+		`${string}.${string}`
+	>
+>;
+
+function getKeyGroups(value: PlainObject): string[][] {
+	const keys = Object.keys(value);
+	const {length} = keys;
+	const grouped: string[][] = [];
+
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		const dots = key.split('.');
+
+		if (grouped[dots.length] == null) {
+			grouped[dots.length] = [key];
+		} else {
+			grouped[dots.length].push(key);
+		}
+	}
+
+	return grouped;
+}
+
+/**
+ * Unsmushes a smushed object _(turning dot notation keys into nested keys)_
+ */
+export function unsmush<Value extends PlainObject>(
+	value: Value,
+): Unsmushed<Value> {
+	const groups = getKeyGroups(value);
+	const {length} = groups;
+	const unsmushed: PlainObject = {};
+
+	for (let groupIndex = 1; groupIndex < length; groupIndex += 1) {
+		const group = groups[groupIndex];
+		const groupLength = group.length;
+
+		for (let keyIndex = 0; keyIndex < groupLength; keyIndex += 1) {
+			const key = group[keyIndex];
+			const val = value[key as never];
+
+			setValue(
+				unsmushed,
+				key,
+				isArrayOrPlainObject(val)
+					? Array.isArray(val)
+						? [...val]
+						: {...val}
+					: val,
+			);
+		}
+	}
+
+	return unsmushed as never;
+}

package/types/array/index.d.ts

@@ -17,6 +17,7 @@ export * from './find';
 export { groupBy } from './group-by';
 export * from './index-of';
 export { insert } from './insert';
+export * from './shuffle';
 export { sort } from './sort';
 export * from './splice';
 export * from './to-map';

package/types/array/shuffle.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Shuffles an array
+ */
+export declare function shuffle<Value>(array: Value[]): Value[];

package/types/index.d.cts

@@ -1,6 +1,6 @@
 // Generated by dts-bundle-generator v9.5.1
 
-import { Get, Paths, Primitive, UnknownArray, UnknownRecord } from 'type-fest';
+import { Get, KeysOfUnion, Paths, Primitive, Simplify, UnknownArray, UnknownRecord } from 'type-fest';
 import { ToString } from 'type-fest/source/internal';
 
 export type ArrayOrPlainObject = UnknownArray | UnknownRecord;
@@ -91,6 +91,10 @@ export declare function indexOf<Model, Value = Model>(array: Model[], value: Val
  * - Uses chunking to avoid stack overflow
  */
 export declare function insert<Value>(array: Value[], index: number, values: Value[]): void;
+/**
+ * Shuffles an array
+ */
+export declare function shuffle<Value>(array: Value[]): Value[];
 /**
  * Sorts an array of items _(ascending by default)_
  */
@@ -657,6 +661,11 @@ export declare function getRandomInteger(min?: number, max?: number): number;
  * Returns a random item from an array
  */
 export declare function getRandomItem<Value>(array: Value[]): Value;
+/**
+ * - Returns an amount of random items from an array
+ * - If `amount` is not specified, a shuffled array will be returned instead
+ */
+export declare function getRandomItems<Value>(array: Value[], amount?: number): Value[];
 /**
  * Convert a string to camel case _(thisIsCamelCase)_
  */
@@ -869,7 +878,7 @@ export type DiffValue<First = unknown, Second = First> = {
  * 		- `full` if the values are completely different
  * 		- `none` if the values are the same
  * 		- `partial` if the values are partially different
- * 	- `values` holds the differences with dot-notation keys
+ * 	- `values` holds the differences with dot notation keys
  */
 export declare function diff<First, Second = First>(first: First, second: Second): DiffResult<First, Second>;
 /**
@@ -912,6 +921,20 @@ export declare function setValue<Data extends PlainObject, Path extends Paths<Da
  * - Returns the original object
  */
 export declare function setValue<Data extends PlainObject>(data: Data, path: string, value: unknown, ignoreCase?: boolean): Data;
+export type Smushed<Value> = Simplify<{
+	[Key in Paths<Value>]: Get<Value, ToString<Key>>;
+}>;
+/**
+ * Smushes an object into a flat object with dot notation keys
+ */
+export declare function smush<Value extends PlainObject>(value: Value): Smushed<Value>;
+export type Unsmushed<Value extends PlainObject> = Simplify<Omit<{
+	[Key in KeysOfUnion<Value>]: Value[Key];
+}, `${string}.${string}`>>;
+/**
+ * Unsmushes a smushed object _(turning dot notation keys into nested keys)_
+ */
+export declare function unsmush<Value extends PlainObject>(value: Value): Unsmushed<Value>;
 /**
  * Creates a new object with only the specified keys
  */

package/types/random.d.ts

@@ -31,3 +31,8 @@ export declare function getRandomInteger(min?: number, max?: number): number;
  * Returns a random item from an array
  */
 export declare function getRandomItem<Value>(array: Value[]): Value;
+/**
+ * - Returns an amount of random items from an array
+ * - If `amount` is not specified, a shuffled array will be returned instead
+ */
+export declare function getRandomItems<Value>(array: Value[], amount?: number): Value[];

package/types/value/diff.d.ts

@@ -16,6 +16,6 @@ export type DiffValue<First = unknown, Second = First> = {
  * 		- `full` if the values are completely different
  * 		- `none` if the values are the same
  * 		- `partial` if the values are partially different
- * 	- `values` holds the differences with dot-notation keys
+ * 	- `values` holds the differences with dot notation keys
  */
 export declare function diff<First, Second = First>(first: First, second: Second): DiffResult<First, Second>;

package/types/value/index.d.ts

@@ -9,3 +9,5 @@ export * from './equal';
 export * from './get';
 export * from './merge';
 export * from './set';
+export * from './smush';
+export * from './unsmush';

package/types/value/smush.d.ts

@@ -0,0 +1,11 @@
+import type { Get, Paths, Simplify } from 'type-fest';
+import type { ToString } from 'type-fest/source/internal';
+import type { PlainObject } from '../models';
+type Smushed<Value> = Simplify<{
+    [Key in Paths<Value>]: Get<Value, ToString<Key>>;
+}>;
+/**
+ * Smushes an object into a flat object with dot notation keys
+ */
+export declare function smush<Value extends PlainObject>(value: Value): Smushed<Value>;
+export {};

package/types/value/unsmush.d.ts

@@ -0,0 +1,10 @@
+import type { KeysOfUnion, Simplify } from 'type-fest';
+import type { PlainObject } from '../models';
+type Unsmushed<Value extends PlainObject> = Simplify<Omit<{
+    [Key in KeysOfUnion<Value>]: Value[Key];
+}, `${string}.${string}`>>;
+/**
+ * Unsmushes a smushed object _(turning dot notation keys into nested keys)_
+ */
+export declare function unsmush<Value extends PlainObject>(value: Value): Unsmushed<Value>;
+export {};