@oscarpalmer/atoms 0.71.0 → 0.73.0

package/dist/css/flex.css

@@ -2,21 +2,16 @@
   flex: 1;
 }
 
-:where(.flow, .flow-large, .flow-small, .flow-text,
-.stack,
-.stack-large,
-.stack-small,
-.stack-text) {
+:where(.flow, .stack) {
   display: flex;
 }
 
-:where(.flow, .flow-large, .flow-small, .flow-text) {
+:where(.flow) {
   flex-flow: row wrap;
   align-items: center;
-}
-:where(.flow) {
   gap: var(--flow-gap, 1rem);
 }
+
 :where(.flow-large) {
   gap: var(--flow-gap-large, calc(2 * var(--flow-gap, 1rem)));
 }
@@ -30,12 +25,11 @@
   gap: var(--flow-gap-text, 1em);
 }
 
-:where(.stack, .stack-large, .stack-small, .stack-text) {
-  flex-flow: column nowrap;
-}
 :where(.stack) {
+  flex-flow: column nowrap;
   gap: var(--stack-gap, 1rem);
 }
+
 :where(.stack-large) {
   gap: var(--stack-gap-large, calc(2 * var(--stack-gap, 1rem)));
 }

package/dist/js/array/chunk.mjs

@@ -1,7 +1,7 @@
 // src/js/array/chunk.ts
 function chunk(array, size) {
   const { length } = array;
-  const chunkSize = typeof size === "number" && size > 0 ? size : 32000;
+  const chunkSize = typeof size === "number" && size > 0 ? size : 64000;
   if (length <= chunkSize) {
     return [array];
   }

package/dist/js/array/count.mjs

@@ -1,5 +1,5 @@
 // src/js/array/count.ts
-import {findValues} from "../internal/array-find";
+import { findValues } from "../internal/array-find";
 function count(array, value, key) {
   return findValues("all", array, value, key).length;
 }

package/dist/js/array/exists.mjs

@@ -1,5 +1,5 @@
 // src/js/array/exists.ts
-import {findValue} from "../internal/array-find";
+import { findValue } from "../internal/array-find";
 function exists(array, value, key) {
   return findValue("index", array, value, key) > -1;
 }

package/dist/js/array/filter.mjs

@@ -1,5 +1,5 @@
 // src/js/array/filter.ts
-import {findValues} from "../internal/array-find";
+import { findValues } from "../internal/array-find";
 function filter(array, value, key) {
   return findValues("all", array, value, key);
 }

package/dist/js/array/find.mjs

@@ -1,5 +1,5 @@
 // src/js/array/find.ts
-import {findValue} from "../internal/array-find";
+import { findValue } from "../internal/array-find";
 function find(array, value, key) {
   return findValue("value", array, value, key);
 }

package/dist/js/array/group-by.mjs

@@ -1,5 +1,5 @@
 // src/js/array/group-by.ts
-import {getCallbacks} from "../internal/array-callbacks";
+import { getCallbacks } from "../internal/array-callbacks";
 function groupBy(array, key) {
   return groupValues(array, key, true, false);
 }

package/dist/js/array/index-of.mjs

@@ -1,5 +1,5 @@
 // src/js/array/index-of.ts
-import {findValue} from "../internal/array-find";
+import { findValue } from "../internal/array-find";
 function indexOf(array, value, key) {
   return findValue("index", array, value, key);
 }

package/dist/js/array/index.js

@@ -1,7 +1,7 @@
 // src/js/array/chunk.ts
 function chunk(array, size) {
   const { length } = array;
-  const chunkSize = typeof size === "number" && size > 0 ? size : 32000;
+  const chunkSize = typeof size === "number" && size > 0 ? size : 64000;
   if (length <= chunkSize) {
     return [array];
   }
@@ -33,11 +33,11 @@ function insertValues(type, array, values, start, deleteCount) {
 }
 
 // src/js/array/index.ts
-function flatten(array2) {
-  return array2.flat(Number.POSITIVE_INFINITY);
+function flatten(array) {
+  return array.flat(Number.POSITIVE_INFINITY);
 }
-function push(array2, values) {
-  return insertValues("push", array2, values, array2.length, 0);
+function push(array, values) {
+  return insertValues("push", array, values, array.length, 0);
 }
 
 // src/js/array/compact.ts
@@ -166,35 +166,134 @@ function getRandomInteger(min, max) {
 }
 
 // src/js/array/shuffle.ts
-function shuffle2(array) {
+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]];
+    const random = getRandomInteger(0, length);
+    [shuffled[index], shuffled[random]] = [shuffled[random], shuffled[index]];
   }
   return shuffled;
 }
-// src/js/is.ts
-function isKey(value2) {
-  return typeof value2 === "number" || typeof value2 === "string";
+// src/js/string/index.ts
+function getString(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value !== "object" || value == null) {
+    return String(value);
+  }
+  const valueOff = value.valueOf?.() ?? value;
+  const asString = valueOff?.toString?.() ?? String(valueOff);
+  return asString.startsWith("[object ") ? JSON.stringify(value) : asString;
+}
+function join(value, delimiter) {
+  return compact(value).map(getString).filter((value2) => value2.trim().length > 0).join(typeof delimiter === "string" ? delimiter : "");
+}
+function words(value) {
+  return value.match(/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g) ?? [];
+}
+// src/js/math.ts
+function max(values) {
+  return values.length > 0 ? Math.max(...values) : Number.NaN;
 }
 
-// src/js/array/sort.ts
-function comparison(first, second) {
-  if (typeof first === "number" && typeof second === "number") {
-    return first - second;
+// src/js/number.ts
+function getNumber(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "symbol") {
+    return Number.NaN;
+  }
+  let parsed = value?.valueOf?.() ?? value;
+  if (typeof parsed === "object") {
+    parsed = parsed?.toString() ?? parsed;
+  }
+  if (typeof parsed !== "string") {
+    return parsed == null ? Number.NaN : typeof parsed === "number" ? parsed : +parsed;
+  }
+  if (/^\s*0+\s*$/.test(parsed)) {
+    return 0;
+  }
+  const trimmed = parsed.trim();
+  if (trimmed.length === 0) {
+    return Number.NaN;
+  }
+  const isBinary = /^0b[01]+$/i.test(trimmed);
+  if (isBinary || /^0o[0-7]+$/i.test(trimmed)) {
+    return Number.parseInt(trimmed.slice(2), isBinary ? 2 : 8);
+  }
+  return +(/^0x[0-9a-f]+$/i.test(trimmed) ? trimmed : trimmed.replace(/_/g, ""));
+}
+
+// src/js/value/compare.ts
+function compare(first, second) {
+  const firstParts = getParts(first);
+  const secondParts = getParts(second);
+  const length = max([firstParts.length, secondParts.length]);
+  const lastIndex = length - 1;
+  for (let index = 0;index < length; index += 1) {
+    const firstPart = firstParts[index];
+    const secondPart = secondParts[index];
+    if (firstPart === secondPart) {
+      if (index === lastIndex) {
+        return 0;
+      }
+      continue;
+    }
+    if (firstPart == null || typeof firstPart === "string" && firstPart.length === 0) {
+      return -1;
+    }
+    if (secondPart == null || typeof secondPart === "string" && secondPart.length === 0) {
+      return 1;
+    }
+    const firstNumber = getNumber(firstPart);
+    const secondNumber = getNumber(secondPart);
+    const firstIsNaN = Number.isNaN(firstNumber);
+    const secondIsNaN = Number.isNaN(secondNumber);
+    if (firstIsNaN || secondIsNaN) {
+      if (firstIsNaN && secondIsNaN) {
+        return getString(firstPart).localeCompare(getString(secondPart));
+      }
+      if (firstIsNaN) {
+        return 1;
+      }
+      if (secondIsNaN) {
+        return -1;
+      }
+    }
+    if (firstNumber === secondNumber) {
+      if (index === lastIndex) {
+        return 0;
+      }
+      continue;
+    }
+    return firstNumber - secondNumber;
   }
-  const firstAsNumber = Number(first);
-  const secondAsNumber = Number(second);
-  return Number.isNaN(firstAsNumber) || Number.isNaN(secondAsNumber) ? String(first).localeCompare(String(second)) : firstAsNumber - secondAsNumber;
+  return join(firstParts).localeCompare(join(secondParts));
 }
-function sort(array2, first, second) {
-  if (array2.length < 2) {
-    return array2;
+function getParts(value) {
+  if (value == null) {
+    return [""];
+  }
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return typeof value === "object" ? [value] : words(getString(value));
+}
+// src/js/is.ts
+function isKey(value) {
+  return typeof value === "number" || typeof value === "string";
+}
+
+// src/js/array/sort.ts
+function sort(array, first, second) {
+  if (array.length < 2) {
+    return array;
   }
   if (first == null || typeof first === "boolean") {
-    return first === true ? array2.sort((first2, second2) => second2 - first2) : array2.sort();
+    return first === true ? array.sort((first2, second2) => second2 - first2) : array.sort();
   }
   const direction = second === true ? "desc" : "asc";
   const keys = (Array.isArray(first) ? first : [first]).map((key) => {
@@ -203,27 +302,27 @@ function sort(array2, first, second) {
       callback: undefined
     };
     if (isKey(key)) {
-      returned.callback = (value2) => value2[key];
+      returned.callback = (value) => value[key];
     } else if (typeof key === "function") {
       returned.callback = key;
     } else if (typeof key?.value === "function" || isKey(key?.value)) {
       returned.direction = key?.direction ?? direction;
-      returned.callback = typeof key.value === "function" ? key.value : (value2) => value2[key.value];
+      returned.callback = typeof key.value === "function" ? key.value : (value) => value[key.value];
     }
     return returned;
   }).filter((key) => typeof key.callback === "function");
   const { length } = keys;
   if (length === 0) {
-    return direction === "asc" ? array2.sort() : array2.sort((first2, second2) => second2 - first2);
+    return direction === "asc" ? array.sort() : array.sort((first2, second2) => second2 - first2);
   }
   if (length === 1) {
-    return array2.sort((first2, second2) => comparison(keys[0].callback(first2), keys[0].callback(second2)) * (keys[0].direction === "asc" ? 1 : -1));
+    return array.sort((first2, second2) => compare(keys[0].callback(first2), keys[0].callback(second2)) * (keys[0].direction === "asc" ? 1 : -1));
   }
-  const sorted = array2.sort((first2, second2) => {
+  const sorted = array.sort((first2, second2) => {
     for (let index = 0;index < length; index += 1) {
       const { callback, direction: direction2 } = keys[index];
       const descending = direction2 === "desc";
-      const compared = comparison(callback(descending ? second2 : first2), callback(descending ? first2 : second2));
+      const compared = compare(callback(descending ? second2 : first2), callback(descending ? first2 : second2));
       if (compared !== 0) {
         return compared;
       }
@@ -233,40 +332,40 @@ function sort(array2, first, second) {
   return sorted;
 }
 // src/js/array/splice.ts
-function splice(array2, start, amountOrValues, values) {
+function splice(array, start, amountOrValues, values) {
   const amoutOrValuesIsArray = Array.isArray(amountOrValues);
-  return insertValues("splice", array2, amoutOrValuesIsArray ? amountOrValues : values ?? [], start, amoutOrValuesIsArray ? array2.length : typeof amountOrValues === "number" && amountOrValues > 0 ? amountOrValues : 0);
+  return insertValues("splice", array, amoutOrValuesIsArray ? amountOrValues : values ?? [], start, amoutOrValuesIsArray ? array.length : typeof amountOrValues === "number" && amountOrValues > 0 ? amountOrValues : 0);
 }
 // src/js/array/to-map.ts
-function toMap(array2, first, second) {
+function toMap(array, first, second) {
   const asArrays = first === true || second === true;
   const callbacks = getCallbacks(undefined, first);
   const hasCallback = typeof callbacks?.key === "function";
   const map = new Map;
-  const { length } = array2;
+  const { length } = array;
   for (let index = 0;index < length; index += 1) {
-    const value2 = array2[index];
-    const key = hasCallback ? callbacks?.key?.(value2, index, array2) ?? index : index;
+    const value = array[index];
+    const key = hasCallback ? callbacks?.key?.(value, index, array) ?? index : index;
     if (asArrays) {
       const existing = map.get(key);
       if (Array.isArray(existing)) {
-        existing.push(value2);
+        existing.push(value);
       } else {
-        map.set(key, [value2]);
+        map.set(key, [value]);
       }
     } else {
-      map.set(key, value2);
+      map.set(key, value);
     }
   }
   return map;
 }
 // src/js/array/to-record.ts
-function toRecord(array2, first, second) {
-  return groupValues(array2, first, first === true || second === true, true);
+function toRecord(array, first, second) {
+  return groupValues(array, first, first === true || second === true, true);
 }
 // src/js/array/unique.ts
-function unique(array2, key) {
-  return findValues("unique", array2, undefined, key);
+function unique(array, key) {
+  return findValues("unique", array, undefined, key);
 }
 export {
   unique,
@@ -274,7 +373,7 @@ export {
   toMap,
   splice,
   sort,
-  shuffle2 as shuffle,
+  shuffle,
   push,
   insert,
   indexOf,

package/dist/js/array/index.mjs

@@ -1,5 +1,5 @@
 // src/js/array/index.ts
-import {insertValues} from "./insert";
+import { insertValues } from "./insert";
 function flatten(array) {
   return array.flat(Number.POSITIVE_INFINITY);
 }
@@ -13,13 +13,13 @@ export * from "./count";
 export * from "./exists";
 export * from "./filter";
 export * from "./find";
-import {groupBy} from "./group-by";
+import { groupBy } from "./group-by";
 
 export * from "./index-of";
-import {insert as insert2} from "./insert";
+import { insert } from "./insert";
 
 export * from "./shuffle";
-import {sort} from "./sort";
+import { sort } from "./sort";
 
 export * from "./splice";
 export * from "./to-map";
@@ -28,7 +28,7 @@ export * from "./unique";
 export {
   sort,
   push,
-  insert2 as insert,
+  insert,
   groupBy,
   flatten
 };

package/dist/js/array/insert.mjs

@@ -1,10 +1,10 @@
 // src/js/array/insert.ts
-import {chunk as chunk2} from "./chunk";
+import { chunk } from "./chunk";
 function insert(array, index, values) {
   insertValues("splice", array, values, index, 0);
 }
 function insertValues(type, array, values, start, deleteCount) {
-  const chunked = chunk2(values);
+  const chunked = chunk(values);
   const lastIndex = chunked.length - 1;
   let index = Number(chunked.length);
   let returned;

package/dist/js/array/shuffle.mjs

@@ -1,11 +1,11 @@
 // src/js/array/shuffle.ts
-import {getRandomInteger} from "../random";
+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]];
+    const random = getRandomInteger(0, length);
+    [shuffled[index], shuffled[random]] = [shuffled[random], shuffled[index]];
   }
   return shuffled;
 }

package/dist/js/array/sort.mjs

@@ -1,13 +1,6 @@
 // src/js/array/sort.ts
-import {isKey} from "../is";
-function comparison(first, second) {
-  if (typeof first === "number" && typeof second === "number") {
-    return first - second;
-  }
-  const firstAsNumber = Number(first);
-  const secondAsNumber = Number(second);
-  return Number.isNaN(firstAsNumber) || Number.isNaN(secondAsNumber) ? String(first).localeCompare(String(second)) : firstAsNumber - secondAsNumber;
-}
+import { isKey } from "../is";
+import { compare } from "../value/compare";
 function sort(array, first, second) {
   if (array.length < 2) {
     return array;
@@ -36,13 +29,13 @@ function sort(array, first, second) {
     return direction === "asc" ? array.sort() : array.sort((first2, second2) => second2 - first2);
   }
   if (length === 1) {
-    return array.sort((first2, second2) => comparison(keys[0].callback(first2), keys[0].callback(second2)) * (keys[0].direction === "asc" ? 1 : -1));
+    return array.sort((first2, second2) => compare(keys[0].callback(first2), keys[0].callback(second2)) * (keys[0].direction === "asc" ? 1 : -1));
   }
   const sorted = array.sort((first2, second2) => {
     for (let index = 0;index < length; index += 1) {
       const { callback, direction: direction2 } = keys[index];
       const descending = direction2 === "desc";
-      const compared = comparison(callback(descending ? second2 : first2), callback(descending ? first2 : second2));
+      const compared = compare(callback(descending ? second2 : first2), callback(descending ? first2 : second2));
       if (compared !== 0) {
         return compared;
       }

package/dist/js/array/splice.mjs

@@ -1,5 +1,5 @@
 // src/js/array/splice.ts
-import {insertValues} from "./insert";
+import { insertValues } from "./insert";
 function splice(array, start, amountOrValues, values) {
   const amoutOrValuesIsArray = Array.isArray(amountOrValues);
   return insertValues("splice", array, amoutOrValuesIsArray ? amountOrValues : values ?? [], start, amoutOrValuesIsArray ? array.length : typeof amountOrValues === "number" && amountOrValues > 0 ? amountOrValues : 0);

package/dist/js/array/to-map.mjs

@@ -1,5 +1,5 @@
 // src/js/array/to-map.ts
-import {getCallbacks} from "../internal/array-callbacks";
+import { getCallbacks } from "../internal/array-callbacks";
 function toMap(array, first, second) {
   const asArrays = first === true || second === true;
   const callbacks = getCallbacks(undefined, first);

package/dist/js/array/to-record.mjs

@@ -1,5 +1,5 @@
 // src/js/array/to-record.ts
-import {groupValues} from "./group-by";
+import { groupValues } from "./group-by";
 function toRecord(array, first, second) {
   return groupValues(array, first, first === true || second === true, true);
 }

package/dist/js/array/unique.mjs

@@ -1,5 +1,5 @@
 // src/js/array/unique.ts
-import {findValues} from "../internal/array-find";
+import { findValues } from "../internal/array-find";
 function unique(array, key) {
   return findValues("unique", array, undefined, key);
 }

package/dist/js/colour/base.mjs

@@ -1,5 +1,5 @@
 // src/js/colour/base.ts
-import {isColourValue} from "./is";
+import { isColourValue } from "./is";
 
 class Colour {
   get value() {

package/dist/js/colour/functions.mjs

@@ -1,24 +1,24 @@
 // src/js/colour/functions.ts
-import {clamp} from "../number";
-import {HexColour} from "./hex";
-import {HSLColour} from "./hsl";
-import {RGBColour} from "./rgb";
+import { clamp } from "../number";
+import { HexColour } from "./hex";
+import { HSLColour } from "./hsl";
+import { RGBColour } from "./rgb";
 function getNormalisedHex(value) {
   const normalised = value.replace(/^#/, "");
   return normalised.length === 3 ? normalised.split("").map((character) => character.repeat(2)).join("") : normalised;
 }
 function hexToRgb(value) {
-  const hex2 = anyPattern.test(value) ? getNormalisedHex(value) : "";
-  const pairs = groupedPattern.exec(hex2) ?? [];
-  const rgb2 = [];
+  const hex = anyPattern.test(value) ? getNormalisedHex(value) : "";
+  const pairs = groupedPattern.exec(hex) ?? [];
+  const rgb = [];
   const { length } = pairs;
   for (let index = 1;index < length; index += 1) {
-    rgb2.push(Number.parseInt(pairs[index], 16));
+    rgb.push(Number.parseInt(pairs[index], 16));
   }
   return new RGBColour({
-    blue: rgb2[2] ?? 0,
-    green: rgb2[1] ?? 0,
-    red: rgb2[0] ?? 0
+    blue: rgb[2] ?? 0,
+    green: rgb[1] ?? 0,
+    red: rgb[0] ?? 0
   });
 }
 function hslToRgb(value) {
@@ -41,14 +41,14 @@ function hslToRgb(value) {
 }
 function rgbToHex(value) {
   return new HexColour(`${[value.red, value.green, value.blue].map((colour) => {
-    const hex2 = colour.toString(16);
-    return hex2.length === 1 ? `0${hex2}` : hex2;
+    const hex = colour.toString(16);
+    return hex.length === 1 ? `0${hex}` : hex;
   }).join("")}`);
 }
-function rgbToHsl(rgb2) {
-  const blue = rgb2.blue / 255;
-  const green = rgb2.green / 255;
-  const red = rgb2.red / 255;
+function rgbToHsl(rgb) {
+  const blue = rgb.blue / 255;
+  const green = rgb.green / 255;
+  const red = rgb.red / 255;
   const max = Math.max(blue, green, red);
   const min = Math.min(blue, green, red);
   const delta = max - min;

package/dist/js/colour/hex.mjs

@@ -1,5 +1,5 @@
 // src/js/colour/hex.ts
-import {anyPattern, getNormalisedHex, hexToRgb} from "./functions";
+import { anyPattern, getNormalisedHex, hexToRgb } from "./functions";
 function getHexColour(value) {
   return new HexColour(value);
 }

package/dist/js/colour/hsl.mjs

@@ -1,7 +1,7 @@
 // src/js/colour/hsl.ts
-import {clamp} from "../number";
-import {Colour} from "./base";
-import {hslToRgb} from "./functions";
+import { clamp } from "../number";
+import { Colour } from "./base";
+import { hslToRgb } from "./functions";
 function getHSLColour(value) {
   return new HSLColour(value);
 }

package/dist/js/colour/index.js

@@ -160,17 +160,17 @@ function getNormalisedHex(value) {
   return normalised.length === 3 ? normalised.split("").map((character) => character.repeat(2)).join("") : normalised;
 }
 function hexToRgb(value) {
-  const hex2 = anyPattern.test(value) ? getNormalisedHex(value) : "";
-  const pairs = groupedPattern.exec(hex2) ?? [];
-  const rgb2 = [];
+  const hex = anyPattern.test(value) ? getNormalisedHex(value) : "";
+  const pairs = groupedPattern.exec(hex) ?? [];
+  const rgb = [];
   const { length } = pairs;
   for (let index = 1;index < length; index += 1) {
-    rgb2.push(Number.parseInt(pairs[index], 16));
+    rgb.push(Number.parseInt(pairs[index], 16));
   }
   return new RGBColour({
-    blue: rgb2[2] ?? 0,
-    green: rgb2[1] ?? 0,
-    red: rgb2[0] ?? 0
+    blue: rgb[2] ?? 0,
+    green: rgb[1] ?? 0,
+    red: rgb[0] ?? 0
   });
 }
 function hslToRgb(value) {
@@ -193,14 +193,14 @@ function hslToRgb(value) {
 }
 function rgbToHex(value) {
   return new HexColour(`${[value.red, value.green, value.blue].map((colour) => {
-    const hex2 = colour.toString(16);
-    return hex2.length === 1 ? `0${hex2}` : hex2;
+    const hex = colour.toString(16);
+    return hex.length === 1 ? `0${hex}` : hex;
   }).join("")}`);
 }
-function rgbToHsl(rgb2) {
-  const blue = rgb2.blue / 255;
-  const green = rgb2.green / 255;
-  const red = rgb2.red / 255;
+function rgbToHsl(rgb) {
+  const blue = rgb.blue / 255;
+  const green = rgb.green / 255;
+  const red = rgb.red / 255;
   const max = Math.max(blue, green, red);
   const min = Math.min(blue, green, red);
   const delta = max - min;

package/dist/js/colour/index.mjs

@@ -11,10 +11,10 @@ function getForegroundColour(value) {
   const luminance = 0.2126 * values[2] + 0.7152 * values[1] + 0.0722 * values[0];
   return luminance > 0.625 ? "black" : "white";
 }
-import {getHexColour, HexColour} from "./hex";
-import {getHSLColour, HSLColour} from "./hsl";
-import {isColour, isHexColour, isHSLColour, isRGBColour} from "./is";
-import {getRGBColour, RGBColour} from "./rgb";
+import { getHexColour, HexColour } from "./hex";
+import { getHSLColour, HSLColour } from "./hsl";
+import { isColour, isHexColour, isHSLColour, isRGBColour } from "./is";
+import { getRGBColour, RGBColour } from "./rgb";
 export {
   isRGBColour,
   isHexColour,

package/dist/js/colour/rgb.mjs

@@ -1,7 +1,7 @@
 // src/js/colour/rgb.ts
-import {clamp} from "../number";
-import {Colour} from "./base";
-import {rgbToHex, rgbToHsl} from "./functions";
+import { clamp } from "../number";
+import { Colour } from "./base";
+import { rgbToHex, rgbToHsl } from "./functions";
 function getRGBColour(value) {
   return new RGBColour(value);
 }