@bytebury/toolkit 1.9.0 → 2.0.0

package/script/src/numbers.js

@@ -8,6 +8,11 @@ exports.min = min;
 exports.round = round;
 exports.sum = sum;
 exports.average = average;
+exports.clamp = clamp;
+exports.median = median;
+exports.roundTo = roundTo;
+exports.random = random;
+exports.inRange = inRange;
 const core_js_1 = require("./core.js");
 /**
  * Determines if a number is even.
@@ -187,3 +192,83 @@ function average(nums) {
         return 0;
     return sum(nums) / nums.length;
 }
+/**
+ * Clamps a number between a minimum and maximum value.
+ *
+ * @example
+ * ```ts
+ * clamp(5, 0, 10); // 5
+ * clamp(-1, 0, 10); // 0
+ * clamp(15, 0, 10); // 10
+ * ```
+ */
+function clamp(num, min, max) {
+    return Math.min(Math.max(num, min), max);
+}
+/**
+ * Returns the median value from a list of numbers.
+ *
+ * @remarks
+ * If you pass an empty list, this will return `0`.
+ *
+ * @example
+ * ```ts
+ * median([]); // 0
+ * median([1, 2, 3]); // 2
+ * median([1, 2, 3, 4]); // 2.5
+ * ```
+ */
+function median(nums) {
+    if ((0, core_js_1.isEmpty)(nums))
+        return 0;
+    const sorted = [...nums].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 === 0
+        ? (sorted[mid - 1] + sorted[mid]) / 2
+        : sorted[mid];
+}
+/**
+ * Rounds a number to the given number of decimal places.
+ *
+ * @remarks
+ * This is `null | undefined` safe. If you pass `null | undefined` this will return `0`.
+ *
+ * @example
+ * ```ts
+ * roundTo(1.235, 2); // 1.24
+ * roundTo(1.5, 0); // 2
+ * roundTo(1234.5, -2); // 1200
+ * ```
+ */
+function roundTo(num, decimals) {
+    const factor = Math.pow(10, decimals);
+    return Math.round((num || 0) * factor) / factor;
+}
+/**
+ * Gives a random number in the given range. The first parameter is inclusive
+ * and the second one is exclusive. Therefore, it will work with lists out of
+ * the box.
+ *
+ * @example
+ * ```ts
+ * random(0, 10); // 0 -> 9
+ * random(3, 7); // 3 -> 6
+ * ```
+ */
+function random(start, end) {
+    return Math.floor(Math.random() * (end - start)) + start;
+}
+/**
+ * Returns true if the given value is within the given range (inclusive on both ends).
+ *
+ * @example
+ * ```ts
+ * inRange(5, 0, 10); // true
+ * inRange(0, 0, 10); // true
+ * inRange(10, 0, 10); // true
+ * inRange(11, 0, 10); // false
+ * ```
+ */
+function inRange(value, min, max) {
+    return value >= min && value <= max;
+}

package/script/src/objects.d.ts

@@ -0,0 +1,90 @@
+import type { None } from "./utility_types.js";
+/**
+ * Returns a strongly-typed array of an object's own enumerable keys.
+ *
+ * @remarks
+ * This is `None` safe. If you pass `null | undefined` then this will return an empty array.
+ *
+ * @example
+ * ```ts
+ * keys({ a: 1, b: 2 }); // ["a", "b"]
+ * keys({}); // []
+ * keys(null); // []
+ * ```
+ */
+export declare function keys<T extends Record<string, unknown>>(obj: T | None): (keyof T)[];
+/**
+ * Returns a strongly-typed array of an object's own enumerable `[key, value]` pairs.
+ *
+ * @remarks
+ * This is `None` safe. If you pass `null | undefined` then this will return an empty array.
+ *
+ * @example
+ * ```ts
+ * entries({ a: 1, b: 2 }); // [["a", 1], ["b", 2]]
+ * entries({}); // []
+ * entries(null); // []
+ * ```
+ */
+export declare function entries<T extends Record<string, unknown>>(obj: T | None): [keyof T, T[keyof T]][];
+/**
+ * Returns a new object containing only the specified keys. Keys that are not
+ * present on the source object are silently ignored.
+ *
+ * @remarks
+ * This is `None` safe. If you pass `null | undefined` then this will return an empty object.
+ *
+ * @example
+ * ```ts
+ * pick({ a: 1, b: 2, c: 3 }, ["a", "c"]); // { a: 1, c: 3 }
+ * pick({ a: 1, b: 2 }, []); // {}
+ * pick(null, ["a"]); // {}
+ * ```
+ */
+export declare function pick<T extends Record<string, unknown>, K extends keyof T>(obj: T | None, keys: K[]): Pick<T, K>;
+/**
+ * Returns a new object with the specified keys excluded.
+ *
+ * @remarks
+ * This is `None` safe. If you pass `null | undefined` then this will return an empty object.
+ *
+ * @example
+ * ```ts
+ * omit({ a: 1, b: 2, c: 3 }, ["a"]); // { b: 2, c: 3 }
+ * omit({ a: 1, b: 2 }, []); // { a: 1, b: 2 }
+ * omit(null, ["a"]); // {}
+ * ```
+ */
+export declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T | None, keys: K[]): Omit<T, K>;
+/**
+ * Returns a new object with the same keys, where each value is transformed by `fn`.
+ *
+ * @remarks
+ * This is `None` safe. If you pass `null | undefined` then this will return an empty object.
+ *
+ * @example
+ * ```ts
+ * mapValues({ a: 1, b: 2 }, (v) => v * 2); // { a: 2, b: 4 }
+ * mapValues({ a: 1, b: 2 }, (v, k) => `${k}=${v}`); // { a: "a=1", b: "b=2" }
+ * mapValues(null, (v) => v); // {}
+ * ```
+ */
+export declare function mapValues<T extends Record<string, unknown>, V>(obj: T | None, fn: (value: T[keyof T], key: keyof T) => V): {
+    [K in keyof T]: V;
+};
+/**
+ * Returns a new object with each key transformed by `fn`. Values are unchanged.
+ * If `fn` produces duplicate keys, later entries overwrite earlier ones.
+ *
+ * @remarks
+ * This is `None` safe. If you pass `null | undefined` then this will return an empty object.
+ *
+ * @example
+ * ```ts
+ * mapKeys({ a: 1, b: 2 }, (k) => k.toUpperCase()); // { A: 1, B: 2 }
+ * mapKeys({ first: "Bob", last: "Lee" }, (k) => `user_${k}`); // { user_first: "Bob", user_last: "Lee" }
+ * mapKeys(null, (k) => k); // {}
+ * ```
+ */
+export declare function mapKeys<T extends Record<string, unknown>>(obj: T | None, fn: (key: keyof T, value: T[keyof T]) => string): Record<string, T[keyof T]>;
+//# sourceMappingURL=objects.d.ts.map

package/script/src/objects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objects.d.ts","sourceRoot":"","sources":["../../src/src/objects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAE/C;;;;;;;;;;;;GAYG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpD,GAAG,EAAE,CAAC,GAAG,IAAI,GACZ,CAAC,MAAM,CAAC,CAAC,EAAE,CAGb;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACvD,GAAG,EAAE,CAAC,GAAG,IAAI,GACZ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAGzB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,EACvE,GAAG,EAAE,CAAC,GAAG,IAAI,EACb,IAAI,EAAE,CAAC,EAAE,GACR,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAOZ;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,EACvE,GAAG,EAAE,CAAC,GAAG,IAAI,EACb,IAAI,EAAE,CAAC,EAAE,GACR,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAQZ;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,EAC5D,GAAG,EAAE,CAAC,GAAG,IAAI,EACb,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,GACzC;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC;CAAE,CAOvB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACvD,GAAG,EAAE,CAAC,GAAG,IAAI,EACb,EAAE,EAAE,CAAC,GAAG,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,MAAM,GAC9C,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAO5B"}

package/script/src/objects.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keys = keys;
+exports.entries = entries;
+exports.pick = pick;
+exports.omit = omit;
+exports.mapValues = mapValues;
+exports.mapKeys = mapKeys;
+/**
+ * Returns a strongly-typed array of an object's own enumerable keys.
+ *
+ * @remarks
+ * This is `None` safe. If you pass `null | undefined` then this will return an empty array.
+ *
+ * @example
+ * ```ts
+ * keys({ a: 1, b: 2 }); // ["a", "b"]
+ * keys({}); // []
+ * keys(null); // []
+ * ```
+ */
+function keys(obj) {
+    if (obj == null)
+        return [];
+    return Object.keys(obj);
+}
+/**
+ * Returns a strongly-typed array of an object's own enumerable `[key, value]` pairs.
+ *
+ * @remarks
+ * This is `None` safe. If you pass `null | undefined` then this will return an empty array.
+ *
+ * @example
+ * ```ts
+ * entries({ a: 1, b: 2 }); // [["a", 1], ["b", 2]]
+ * entries({}); // []
+ * entries(null); // []
+ * ```
+ */
+function entries(obj) {
+    if (obj == null)
+        return [];
+    return Object.entries(obj);
+}
+/**
+ * Returns a new object containing only the specified keys. Keys that are not
+ * present on the source object are silently ignored.
+ *
+ * @remarks
+ * This is `None` safe. If you pass `null | undefined` then this will return an empty object.
+ *
+ * @example
+ * ```ts
+ * pick({ a: 1, b: 2, c: 3 }, ["a", "c"]); // { a: 1, c: 3 }
+ * pick({ a: 1, b: 2 }, []); // {}
+ * pick(null, ["a"]); // {}
+ * ```
+ */
+function pick(obj, keys) {
+    if (obj == null)
+        return {};
+    const result = {};
+    for (const key of keys) {
+        if (key in obj)
+            result[key] = obj[key];
+    }
+    return result;
+}
+/**
+ * Returns a new object with the specified keys excluded.
+ *
+ * @remarks
+ * This is `None` safe. If you pass `null | undefined` then this will return an empty object.
+ *
+ * @example
+ * ```ts
+ * omit({ a: 1, b: 2, c: 3 }, ["a"]); // { b: 2, c: 3 }
+ * omit({ a: 1, b: 2 }, []); // { a: 1, b: 2 }
+ * omit(null, ["a"]); // {}
+ * ```
+ */
+function omit(obj, keys) {
+    if (obj == null)
+        return {};
+    const excluded = new Set(keys);
+    const result = {};
+    for (const key of Object.keys(obj)) {
+        if (!excluded.has(key))
+            result[key] = obj[key];
+    }
+    return result;
+}
+/**
+ * Returns a new object with the same keys, where each value is transformed by `fn`.
+ *
+ * @remarks
+ * This is `None` safe. If you pass `null | undefined` then this will return an empty object.
+ *
+ * @example
+ * ```ts
+ * mapValues({ a: 1, b: 2 }, (v) => v * 2); // { a: 2, b: 4 }
+ * mapValues({ a: 1, b: 2 }, (v, k) => `${k}=${v}`); // { a: "a=1", b: "b=2" }
+ * mapValues(null, (v) => v); // {}
+ * ```
+ */
+function mapValues(obj, fn) {
+    if (obj == null)
+        return {};
+    const result = {};
+    for (const key of Object.keys(obj)) {
+        result[key] = fn(obj[key], key);
+    }
+    return result;
+}
+/**
+ * Returns a new object with each key transformed by `fn`. Values are unchanged.
+ * If `fn` produces duplicate keys, later entries overwrite earlier ones.
+ *
+ * @remarks
+ * This is `None` safe. If you pass `null | undefined` then this will return an empty object.
+ *
+ * @example
+ * ```ts
+ * mapKeys({ a: 1, b: 2 }, (k) => k.toUpperCase()); // { A: 1, B: 2 }
+ * mapKeys({ first: "Bob", last: "Lee" }, (k) => `user_${k}`); // { user_first: "Bob", user_last: "Lee" }
+ * mapKeys(null, (k) => k); // {}
+ * ```
+ */
+function mapKeys(obj, fn) {
+    if (obj == null)
+        return {};
+    const result = {};
+    for (const key of Object.keys(obj)) {
+        result[fn(key, obj[key])] = obj[key];
+    }
+    return result;
+}

package/script/src/objects_test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objects_test.d.ts","sourceRoot":"","sources":["../../src/src/objects_test.ts"],"names":[],"mappings":"AAAA,OAAO,2BAA2B,CAAC"}

package/script/src/strings.d.ts

@@ -163,4 +163,66 @@ export declare function keepAlphanumeric(text: string): string;
  * ```
  */
 export declare function keepNumeric(text: string): string;
+/**
+ * Converts the string to `camelCase` by removing punctuation, trimming extra
+ * spaces, and lowercasing the first word with subsequent words capitalized.
+ *
+ * @remarks
+ * This is `None` safe. If you pass `null | undefined` then this will return an Empty String.
+ *
+ * @example
+ * ```ts
+ * camel(null); // ""
+ * camel("Hello World"); // "helloWorld"
+ * camel("user_profile_page"); // "userProfilePage"
+ * camel("HELLO-WORLD"); // "helloWorld"
+ * ```
+ */
+export declare function camel(text: string): string;
+/**
+ * Converts the string to `PascalCase` by removing punctuation, trimming extra
+ * spaces, and capitalizing every word.
+ *
+ * @remarks
+ * This is `None` safe. If you pass `null | undefined` then this will return an Empty String.
+ *
+ * @example
+ * ```ts
+ * pascal(null); // ""
+ * pascal("hello world"); // "HelloWorld"
+ * pascal("user_profile_page"); // "UserProfilePage"
+ * ```
+ */
+export declare function pascal(text: string): string;
+/**
+ * Truncates a string to the given length. If truncation occurs, the suffix is
+ * appended and counted toward the total length.
+ *
+ * @remarks
+ * This is `None` safe. If you pass `null | undefined` then this will return an Empty String.
+ *
+ * @example
+ * ```ts
+ * truncate(null, 10); // ""
+ * truncate("Hello World", 5); // "He..."
+ * truncate("Hello World", 20); // "Hello World"
+ * truncate("Hello World", 8, "…"); // "Hello W…"
+ * ```
+ */
+export declare function truncate(text: string, length: number, suffix?: string): string;
+/**
+ * Converts a string to a URL-safe slug. Diacritics are stripped, punctuation is
+ * removed, and whitespace is replaced with hyphens.
+ *
+ * @remarks
+ * This is `None` safe. If you pass `null | undefined` then this will return an Empty String.
+ *
+ * @example
+ * ```ts
+ * slugify(null); // ""
+ * slugify("Hello World!"); // "hello-world"
+ * slugify("Café à la Carte"); // "cafe-a-la-carte"
+ * ```
+ */
+export declare function slugify(text: string): string;
 //# sourceMappingURL=strings.d.ts.map

package/script/src/strings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../../src/src/strings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAM1C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC,CAErD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC,CAErD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC,CAIrD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC,CAErD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEhD"}
+{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../../src/src/strings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAM1C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC,CAErD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC,CAErD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC,CAIrD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC,CAErD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAK1C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAM3C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,SAAQ,GAAG,MAAM,CAI7E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE5C"}

package/script/src/strings.js

@@ -11,6 +11,10 @@ exports.snake = snake;
 exports.keepAlphabetical = keepAlphabetical;
 exports.keepAlphanumeric = keepAlphanumeric;
 exports.keepNumeric = keepNumeric;
+exports.camel = camel;
+exports.pascal = pascal;
+exports.truncate = truncate;
+exports.slugify = slugify;
 /**
  * Determines if the given text is only comprised of whitespace.
  *
@@ -202,6 +206,87 @@ function keepAlphanumeric(text) {
 function keepNumeric(text) {
     return (text || "").replace(/[^\d]/g, "");
 }
+/**
+ * Converts the string to `camelCase` by removing punctuation, trimming extra
+ * spaces, and lowercasing the first word with subsequent words capitalized.
+ *
+ * @remarks
+ * This is `None` safe. If you pass `null | undefined` then this will return an Empty String.
+ *
+ * @example
+ * ```ts
+ * camel(null); // ""
+ * camel("Hello World"); // "helloWorld"
+ * camel("user_profile_page"); // "userProfilePage"
+ * camel("HELLO-WORLD"); // "helloWorld"
+ * ```
+ */
+function camel(text) {
+    const parts = kebab(text).split("-").filter(Boolean);
+    if (parts.length === 0)
+        return "";
+    return parts[0] +
+        parts.slice(1).map((p) => upper(p[0]) + p.slice(1)).join("");
+}
+/**
+ * Converts the string to `PascalCase` by removing punctuation, trimming extra
+ * spaces, and capitalizing every word.
+ *
+ * @remarks
+ * This is `None` safe. If you pass `null | undefined` then this will return an Empty String.
+ *
+ * @example
+ * ```ts
+ * pascal(null); // ""
+ * pascal("hello world"); // "HelloWorld"
+ * pascal("user_profile_page"); // "UserProfilePage"
+ * ```
+ */
+function pascal(text) {
+    return kebab(text)
+        .split("-")
+        .filter(Boolean)
+        .map((p) => upper(p[0]) + p.slice(1))
+        .join("");
+}
+/**
+ * Truncates a string to the given length. If truncation occurs, the suffix is
+ * appended and counted toward the total length.
+ *
+ * @remarks
+ * This is `None` safe. If you pass `null | undefined` then this will return an Empty String.
+ *
+ * @example
+ * ```ts
+ * truncate(null, 10); // ""
+ * truncate("Hello World", 5); // "He..."
+ * truncate("Hello World", 20); // "Hello World"
+ * truncate("Hello World", 8, "…"); // "Hello W…"
+ * ```
+ */
+function truncate(text, length, suffix = "...") {
+    const t = text || "";
+    if (t.length <= length)
+        return t;
+    return t.slice(0, Math.max(0, length - suffix.length)) + suffix;
+}
+/**
+ * Converts a string to a URL-safe slug. Diacritics are stripped, punctuation is
+ * removed, and whitespace is replaced with hyphens.
+ *
+ * @remarks
+ * This is `None` safe. If you pass `null | undefined` then this will return an Empty String.
+ *
+ * @example
+ * ```ts
+ * slugify(null); // ""
+ * slugify("Hello World!"); // "hello-world"
+ * slugify("Café à la Carte"); // "cafe-a-la-carte"
+ * ```
+ */
+function slugify(text) {
+    return kebab(text);
+}
 function removePunctuation(text) {
     return text
         .normalize("NFKD")