@edgeandnode/eds-utils 1.0.0

package/dist/loremIpsum.js

@@ -0,0 +1,136 @@
+import { sliceWrap } from './sliceWrap.js';
+/**
+ * Generates lorem ipsum text.
+ *
+ * @param {number} [count=4] - The number of words, sentences, or paragraphs to generate. Default is
+ *   `4`
+ * @param {'words' | 'sentences' | 'paragraphs'} [units='sentences'] - The units to generate.
+ *   Default is `'sentences'`
+ * @returns {string} The generated text.
+ */
+export function loremIpsum(count = 4, units = 'sentences') {
+    switch (units) {
+        case 'words':
+            return wordsToSentence(sliceWrap(WORDS, 0, count));
+        case 'sentences':
+            return sliceWrap(SENTENCES, 0, count)
+                .map((sentence) => wordsToSentence(sentence.words))
+                .join(' ');
+        case 'paragraphs':
+            return sliceWrap(PARAGRAPHS, 0, count)
+                .map((paragraph) => paragraph.sentences.map((sentence) => wordsToSentence(sentence.words)).join(' '))
+                .join('\n');
+    }
+}
+function wordsToSentence(words) {
+    let sentence = '';
+    for (const word of words) {
+        if (sentence.length > 0)
+            sentence += ' ';
+        sentence += word;
+    }
+    if (sentence.endsWith(',')) {
+        sentence = sentence.slice(0, -1);
+    }
+    if (sentence.length > 0 && !sentence.endsWith('.')) {
+        sentence += '.';
+    }
+    return sentence;
+}
+const LOREM_IPSUM = {
+    paragraphs: [
+        {
+            sentences: [
+                {
+                    words: [
+                        'Lorem',
+                        'ipsum',
+                        'dolor',
+                        'sit',
+                        'amet,',
+                        'consectetur',
+                        'adipiscing',
+                        'elit,',
+                        'sed',
+                        'do',
+                        'eiusmod',
+                        'tempor',
+                        'incididunt',
+                        'ut',
+                        'labore',
+                        'et',
+                        'dolore',
+                        'magna',
+                        'aliqua.',
+                    ],
+                },
+                {
+                    words: [
+                        'Ut',
+                        'enim',
+                        'ad',
+                        'minim',
+                        'veniam,',
+                        'quis',
+                        'nostrud',
+                        'exercitation',
+                        'ullamco',
+                        'laboris',
+                        'nisi',
+                        'ut',
+                        'aliquip',
+                        'ex',
+                        'ea',
+                        'commodo',
+                        'consequat.',
+                    ],
+                },
+                {
+                    words: [
+                        'Duis',
+                        'aute',
+                        'irure',
+                        'dolor',
+                        'in',
+                        'reprehenderit',
+                        'in',
+                        'voluptate',
+                        'velit',
+                        'esse',
+                        'cillum',
+                        'dolore',
+                        'eu',
+                        'fugiat',
+                        'nulla',
+                        'pariatur.',
+                    ],
+                },
+                {
+                    words: [
+                        'Excepteur',
+                        'sint',
+                        'occaecat',
+                        'cupidatat',
+                        'non',
+                        'proident,',
+                        'sunt',
+                        'in',
+                        'culpa',
+                        'qui',
+                        'officia',
+                        'deserunt',
+                        'mollit',
+                        'anim',
+                        'id',
+                        'est',
+                        'laborum.',
+                    ],
+                },
+            ],
+        },
+    ],
+};
+const PARAGRAPHS = LOREM_IPSUM.paragraphs;
+const SENTENCES = PARAGRAPHS.flatMap((paragraph) => paragraph.sentences);
+const WORDS = SENTENCES.flatMap((sentence) => sentence.words);
+//# sourceMappingURL=loremIpsum.js.map

package/dist/loremIpsum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loremIpsum.js","sourceRoot":"","sources":["../src/loremIpsum.ts"],"names":[],"mappings":"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"}

package/dist/numberToBigInt.d.ts

@@ -0,0 +1,18 @@
+export interface NumberToBigIntOptions {
+    /**
+     * The number of digits starting from the right of the returned bigint to consider as decimal
+     * places.
+     *
+     * @default 18n
+     */
+    precision?: bigint | undefined;
+}
+/**
+ * Converts a number to a bigint. Decimals to the right of `precision` are truncated.
+ *
+ * @param value - The number to convert to a bigint.
+ * @param options - Conversion options.
+ * @returns The bigint representation of `value`
+ */
+export declare function numberToBigInt(value: number, options?: NumberToBigIntOptions): bigint;
+//# sourceMappingURL=numberToBigInt.d.ts.map

package/dist/numberToBigInt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numberToBigInt.d.ts","sourceRoot":"","sources":["../src/numberToBigInt.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,qBAAqB;IACpC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAC/B;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,qBAAqB,GAAG,MAAM,CAkBrF"}

package/dist/numberToBigInt.js

@@ -0,0 +1,27 @@
+import { parseBigInt } from './parseBigInt.js';
+/**
+ * Converts a number to a bigint. Decimals to the right of `precision` are truncated.
+ *
+ * @param value - The number to convert to a bigint.
+ * @param options - Conversion options.
+ * @returns The bigint representation of `value`
+ */
+export function numberToBigInt(value, options) {
+    const { precision = 18n } = options ?? {};
+    if (precision < 0n) {
+        throw new Error(`[numberToBigInt] \`precision\` must be positive, got ${precision}`);
+    }
+    // If `value` has decimals and `precision` is at least 1, parse it as a string
+    if (value % 1 !== 0 && precision >= 1n) {
+        const parsedValue = parseBigInt(String(value), { precision });
+        if (parsedValue === null) {
+            throw new Error(`[numberToBigInt] Failed to parse ${value} as a bigint with precision ${precision}`);
+        }
+        return parsedValue;
+    }
+    else {
+        const precisionFactor = 10n ** precision;
+        return BigInt(Math.trunc(value)) * precisionFactor;
+    }
+}
+//# sourceMappingURL=numberToBigInt.js.map

package/dist/numberToBigInt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"numberToBigInt.js","sourceRoot":"","sources":["../src/numberToBigInt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAY9C;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,KAAa,EAAE,OAA+B;IAC3E,MAAM,EAAE,SAAS,GAAG,GAAG,EAAE,GAAG,OAAO,IAAI,EAAE,CAAA;IACzC,IAAI,SAAS,GAAG,EAAE,EAAE,CAAC;QACnB,MAAM,IAAI,KAAK,CAAC,wDAAwD,SAAS,EAAE,CAAC,CAAA;IACtF,CAAC;IACD,8EAA8E;IAC9E,IAAI,KAAK,GAAG,CAAC,KAAK,CAAC,IAAI,SAAS,IAAI,EAAE,EAAE,CAAC;QACvC,MAAM,WAAW,GAAG,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,CAAA;QAC7D,IAAI,WAAW,KAAK,IAAI,EAAE,CAAC;YACzB,MAAM,IAAI,KAAK,CACb,oCAAoC,KAAK,+BAA+B,SAAS,EAAE,CACpF,CAAA;QACH,CAAC;QACD,OAAO,WAAW,CAAA;IACpB,CAAC;SAAM,CAAC;QACN,MAAM,eAAe,GAAG,GAAG,IAAI,SAAS,CAAA;QACxC,OAAO,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,GAAG,eAAe,CAAA;IACpD,CAAC;AACH,CAAC"}

package/dist/parseBigInt.d.ts

@@ -0,0 +1,25 @@
+export interface ParseBigIntOptions {
+    /**
+     * The number of digits starting from the right of the returned bigint to consider as decimal
+     * places.
+     *
+     * @default 18n
+     */
+    precision?: bigint | undefined;
+    /**
+     * If true, requires exact match (no commas, no extra whitespace)
+     *
+     * @default false
+     */
+    strict?: boolean | undefined;
+}
+/**
+ * Like `parseNumber()`, but returns a bigint instead of a number. Decimals to the right of
+ * `precision` are truncated.
+ *
+ * @param value - The string to parse as a bigint.
+ * @param options - Parsing options.
+ * @returns The bigint representation of `value`, or `null` if we failed to parse it.
+ */
+export declare function parseBigInt(value: string, options?: ParseBigIntOptions): bigint | null;
+//# sourceMappingURL=parseBigInt.d.ts.map

package/dist/parseBigInt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseBigInt.d.ts","sourceRoot":"","sources":["../src/parseBigInt.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,kBAAkB;IACjC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC9B;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CAC7B;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,kBAAkB,iBA0BtE"}

package/dist/parseBigInt.js

@@ -0,0 +1,35 @@
+/**
+ * Like `parseNumber()`, but returns a bigint instead of a number. Decimals to the right of
+ * `precision` are truncated.
+ *
+ * @param value - The string to parse as a bigint.
+ * @param options - Parsing options.
+ * @returns The bigint representation of `value`, or `null` if we failed to parse it.
+ */
+export function parseBigInt(value, options) {
+    const { precision = 18n, strict = false } = options ?? {};
+    if (precision < 0n) {
+        throw new Error(`[parseBigInt] \`precision\` must be positive, got ${precision}`);
+    }
+    const originalValue = value;
+    const cleanedValue = value.replace(/,/g, '').trim();
+    if (strict && cleanedValue !== originalValue)
+        return null;
+    if (cleanedValue === '' || cleanedValue === '-' || cleanedValue === '.' || cleanedValue === '-.')
+        return null;
+    const [integerPart, decimalPart = '', somethingAfterDecimalPart] = cleanedValue.split('.');
+    if (integerPart.trim() !== integerPart)
+        return null;
+    if (decimalPart.trim() !== decimalPart)
+        return null;
+    if (somethingAfterDecimalPart !== undefined)
+        return null;
+    try {
+        const precisionNumber = Number(precision);
+        return BigInt(`${integerPart}${decimalPart.slice(0, precisionNumber).padEnd(precisionNumber, '0')}`);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=parseBigInt.js.map

package/dist/parseBigInt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseBigInt.js","sourceRoot":"","sources":["../src/parseBigInt.ts"],"names":[],"mappings":"AAgBA;;;;;;;GAOG;AACH,MAAM,UAAU,WAAW,CAAC,KAAa,EAAE,OAA4B;IACrE,MAAM,EAAE,SAAS,GAAG,GAAG,EAAE,MAAM,GAAG,KAAK,EAAE,GAAG,OAAO,IAAI,EAAE,CAAA;IACzD,IAAI,SAAS,GAAG,EAAE,EAAE,CAAC;QACnB,MAAM,IAAI,KAAK,CAAC,qDAAqD,SAAS,EAAE,CAAC,CAAA;IACnF,CAAC;IAED,MAAM,aAAa,GAAG,KAAK,CAAA;IAC3B,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAA;IAEnD,IAAI,MAAM,IAAI,YAAY,KAAK,aAAa;QAAE,OAAO,IAAI,CAAA;IACzD,IAAI,YAAY,KAAK,EAAE,IAAI,YAAY,KAAK,GAAG,IAAI,YAAY,KAAK,GAAG,IAAI,YAAY,KAAK,IAAI;QAC9F,OAAO,IAAI,CAAA;IAEb,MAAM,CAAC,WAAW,EAAE,WAAW,GAAG,EAAE,EAAE,yBAAyB,CAAC,GAAG,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;IAC1F,IAAI,WAAY,CAAC,IAAI,EAAE,KAAK,WAAW;QAAE,OAAO,IAAI,CAAA;IACpD,IAAI,WAAW,CAAC,IAAI,EAAE,KAAK,WAAW;QAAE,OAAO,IAAI,CAAA;IACnD,IAAI,yBAAyB,KAAK,SAAS;QAAE,OAAO,IAAI,CAAA;IAExD,IAAI,CAAC;QACH,MAAM,eAAe,GAAG,MAAM,CAAC,SAAS,CAAC,CAAA;QACzC,OAAO,MAAM,CACX,GAAG,WAAW,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,MAAM,CAAC,eAAe,EAAE,GAAG,CAAC,EAAE,CACtF,CAAA;IACH,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAA;IACb,CAAC;AACH,CAAC"}

package/dist/parseNumber.d.ts

@@ -0,0 +1,17 @@
+export interface ParseNumberOptions {
+    /**
+     * If true, requires exact match (no commas, no extra whitespace)
+     *
+     * @default false
+     */
+    strict?: boolean | undefined;
+}
+/**
+ * Parses a string value into a number, with optional strict mode.
+ *
+ * @param value - The string value to parse.
+ * @param options - Parsing options.
+ * @returns The parsed number, or null if parsing fails.
+ */
+export declare function parseNumber(value: string, options?: ParseNumberOptions): number | null;
+//# sourceMappingURL=parseNumber.d.ts.map

package/dist/parseNumber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseNumber.d.ts","sourceRoot":"","sources":["../src/parseNumber.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CAC7B;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,kBAAkB,iBAOtE"}

package/dist/parseNumber.js

@@ -0,0 +1,18 @@
+/**
+ * Parses a string value into a number, with optional strict mode.
+ *
+ * @param value - The string value to parse.
+ * @param options - Parsing options.
+ * @returns The parsed number, or null if parsing fails.
+ */
+export function parseNumber(value, options) {
+    const { strict = false } = options ?? {};
+    const cleanedValue = value.replace(/,/g, '').trim();
+    if (cleanedValue === '' || (cleanedValue !== value && strict))
+        return null;
+    const number = Number(cleanedValue);
+    if (!Number.isFinite(number) || (String(number) !== cleanedValue && strict))
+        return null;
+    return number;
+}
+//# sourceMappingURL=parseNumber.js.map

package/dist/parseNumber.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseNumber.js","sourceRoot":"","sources":["../src/parseNumber.ts"],"names":[],"mappings":"AASA;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CAAC,KAAa,EAAE,OAA4B;IACrE,MAAM,EAAE,MAAM,GAAG,KAAK,EAAE,GAAG,OAAO,IAAI,EAAE,CAAA;IACxC,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAA;IACnD,IAAI,YAAY,KAAK,EAAE,IAAI,CAAC,YAAY,KAAK,KAAK,IAAI,MAAM,CAAC;QAAE,OAAO,IAAI,CAAA;IAC1E,MAAM,MAAM,GAAG,MAAM,CAAC,YAAY,CAAC,CAAA;IACnC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,YAAY,IAAI,MAAM,CAAC;QAAE,OAAO,IAAI,CAAA;IACxF,OAAO,MAAM,CAAA;AACf,CAAC"}

package/dist/sliceWrap.d.ts

@@ -0,0 +1,3 @@
+/** Same as `array.slice(start, end)`, but wraps around the end of the array. */
+export declare function sliceWrap<T>(array: T[], start: number, end: number): T[];
+//# sourceMappingURL=sliceWrap.d.ts.map

package/dist/sliceWrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sliceWrap.d.ts","sourceRoot":"","sources":["../src/sliceWrap.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,OAOlE"}

package/dist/sliceWrap.js

@@ -0,0 +1,11 @@
+/** Same as `array.slice(start, end)`, but wraps around the end of the array. */
+export function sliceWrap(array, start, end) {
+    if (array.length === 0)
+        return [];
+    const result = [];
+    for (let i = start; i < end; i++) {
+        result.push(array[i % array.length]);
+    }
+    return result;
+}
+//# sourceMappingURL=sliceWrap.js.map

package/dist/sliceWrap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sliceWrap.js","sourceRoot":"","sources":["../src/sliceWrap.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,MAAM,UAAU,SAAS,CAAI,KAAU,EAAE,KAAa,EAAE,GAAW;IACjE,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAA;IACjC,MAAM,MAAM,GAAiB,EAAE,CAAA;IAC/B,KAAK,IAAI,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;QACjC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,KAAK,CAAC,MAAM,CAAE,CAAC,CAAA;IACvC,CAAC;IACD,OAAO,MAAM,CAAA;AACf,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,6 @@
+import type { SetNonNullable, SetRequired } from 'type-fest';
+export type DeepRecord<Value> = {
+    [key: string]: Value | DeepRecord<Value>;
+};
+export type SetRequiredNonNullable<T, K extends keyof T> = SetRequired<SetNonNullable<T, K>, K>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5D,MAAM,MAAM,UAAU,CAAC,KAAK,IAAI;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,CAAA;CAAE,CAAA;AAC5E,MAAM,MAAM,sBAAsB,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,WAAW,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@edgeandnode/eds-utils",
+  "version": "1.0.0",
+  "description": "General utility functions for The Edge Design System",
+  "author": "Edge & Node and contributors",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/edgeandnode/eds.git",
+    "directory": "packages/utils"
+  },
+  "homepage": "https://github.com/edgeandnode/eds/tree/main/packages/utils",
+  "bugs": "https://github.com/edgeandnode/eds/issues",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "src",
+    "!src/**/*.test.*"
+  ],
+  "dependencies": {
+    "md5": "^2.3.0",
+    "viem": "^2.56.8"
+  },
+  "devDependencies": {
+    "@types/md5": "^2.3.6"
+  },
+  "scripts": {
+    "build": "tsc --build tsconfig.build.json",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}

package/src/bigIntToNumber.ts

@@ -0,0 +1,34 @@
+export interface BigIntToNumberOptions {
+  /**
+   * The number of digits starting from the right of `value` to consider as decimal places.
+   *
+   * @default 18n
+   */
+  precision?: bigint | undefined
+}
+
+/**
+ * Converts a bigint to a number.
+ *
+ * @param value - The bigint to convert to a number.
+ * @param options - Conversion options.
+ * @returns The number representation of `value`
+ */
+export function bigIntToNumber(value: bigint, options?: BigIntToNumberOptions): number {
+  const { precision = 18n } = options ?? {}
+  if (precision < 0n) {
+    throw new Error(`[bigIntToNumber] \`precision\` must be positive, got ${precision}`)
+  }
+  if (precision === 0n) {
+    return Number(value)
+  } else {
+    const valueString = String(value)
+    const decimalPointIndex = valueString.length - Number(precision)
+    if (decimalPointIndex <= 0) {
+      return Number(`0.${'0'.repeat(Math.abs(decimalPointIndex))}${valueString}`)
+    }
+    return Number(
+      `${valueString.slice(0, decimalPointIndex)}.${valueString.slice(decimalPointIndex)}`,
+    )
+  }
+}

package/src/camelToKebab.ts

@@ -0,0 +1,16 @@
+/** Converts a camelCase string to kebab-case. */
+export function camelToKebab(string: string) {
+  return (
+    string
+      // Insert dash between a group of uppercase letters and an uppercase letter followed by lowercase (`HTTPSEncryptionMethod200Success` => `HTTPS-EncryptionMethod200Success`)
+      .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
+      // Insert dash between a lowercase letter and an uppercase letter (`HTTPS-EncryptionMethod200Success` => `HTTPS-Encryption-Method200Success`)
+      .replace(/([a-z])([A-Z])/g, '$1-$2')
+      // Insert dash between a letter and a digit (`HTTPS-Encryption-Method200Success` => `HTTPS-Encryption-Method-200Success`)
+      .replace(/([A-Za-z])(\d)/g, '$1-$2')
+      // Insert dash between a digit and a letter (`HTTPS-Encryption-Method-200Success` => `HTTPS-Encryption-Method-200-Success`)
+      .replace(/(\d)([A-Za-z])/g, '$1-$2')
+      // Convert to lowercase (`HTTPS-Encryption-Method-200-Success` => `https-encryption-method-200-success`)
+      .toLowerCase()
+  )
+}

package/src/constants.ts

@@ -0,0 +1,2 @@
+export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'
+export const PLACEHOLDER_ADDRESS = '0x646563656E7472616c697a656420646174612121' // "decentralized data!!" in HEX format

package/src/createIdenticon.ts

@@ -0,0 +1,84 @@
+import md5 from 'md5'
+
+import { sliceWrap } from './sliceWrap.ts'
+
+const identiconCache = new Map<string, string>()
+
+export function createIdenticon(address: string) {
+  const lowercasedAddress = address.toLowerCase()
+
+  // Check the cache first
+  const cachedIdenticon = identiconCache.get(lowercasedAddress)
+  if (cachedIdenticon) {
+    return cachedIdenticon
+  }
+
+  const hash = md5(lowercasedAddress)
+  const bytesPerPixel = 3
+  const pixels = 5
+  const rowPadding = (4 - ((pixels * bytesPerPixel) % 4)) % 4
+  const pixelArraySize = pixels * (pixels * bytesPerPixel + rowPadding)
+  const fileHeaderSize = 14
+  const dibHeaderSize = 40
+  const totalHeaderSize = fileHeaderSize + dibHeaderSize
+  const bufferSize = totalHeaderSize + pixelArraySize
+  const buffer = new Uint8Array(bufferSize)
+
+  // Set up the bitmap headers
+  buffer[0] = 0x42 // 'B'
+  buffer[1] = 0x4d // 'M'
+  buffer[2] = bufferSize & 0xff
+  buffer[3] = (bufferSize >> 8) & 0xff
+  buffer[4] = (bufferSize >> 16) & 0xff
+  buffer[5] = (bufferSize >> 24) & 0xff
+  buffer[10] = totalHeaderSize // Pixel data offset
+  buffer[14] = dibHeaderSize
+  buffer[18] = pixels & 0xff
+  buffer[19] = (pixels >> 8) & 0xff
+  buffer[22] = pixels & 0xff
+  buffer[23] = (pixels >> 8) & 0xff
+  buffer[26] = 1 // Planes
+  buffer[28] = 24 // Bits per pixel
+
+  // Determine the primary color based on the hash
+  const match = /#(..)(..)(..)/.exec(`#${hash.slice(0, 6)}`)
+  if (!match) throw new Error('[createIdenticon] Invalid color format')
+  const [r, g, b] = match.slice(1).map((hex) => parseInt(hex, 16)) as [number, number, number]
+  type BGR = [number, number, number]
+  const primaryColor: BGR = [b, g, r]
+  const backgroundColor: BGR = [255, 255, 255]
+
+  // Draw the image
+  const hashBinary = hash
+    .split('')
+    .map((el) => parseInt(el, 16))
+    .map((num) => (num < 8 ? 0 : 1))
+  const hashBinaryMap: (0 | 1)[][] = []
+  const columns = Math.ceil(pixels / 2)
+  for (let x = 0; x < columns; x++) {
+    hashBinaryMap[x] = sliceWrap(hashBinary, x * pixels, (x + 1) * pixels)
+  }
+  let position = totalHeaderSize
+  for (let y = pixels - 1; y >= 0; y--) {
+    for (let x = 0; x < pixels; x++) {
+      const color: BGR = hashBinaryMap[x > columns - 1 ? pixels - 1 - x : x]?.[y]
+        ? primaryColor
+        : backgroundColor
+      buffer[position++] = color[0]
+      buffer[position++] = color[1]
+      buffer[position++] = color[2]
+    }
+    position += rowPadding
+  }
+
+  // Convert the image to a base64 string
+  let binary = ''
+  for (let i = 0; i < buffer.length; i++) {
+    binary += String.fromCharCode(buffer[i]!)
+  }
+  const identicon = `data:image/bmp;base64,${btoa(binary)}`
+
+  // Store it in the cache, then return it
+  identiconCache.set(lowercasedAddress, identicon)
+  return identicon
+}

package/src/formatAddress.ts

@@ -0,0 +1,33 @@
+import { getAddress } from 'viem'
+
+import { ZERO_ADDRESS } from './constants.ts'
+
+type FormatAddressOptions = {
+  /** @default 'short' */
+  style?: 'short' | 'full' | undefined
+}
+
+/**
+ * Formats an EVM wallet address as a string.
+ *
+ * @param address - The address to format.
+ * @param options - Formatting options.
+ * @returns The formatted address string.
+ */
+export function formatAddress(address: string, options: FormatAddressOptions = {}): string {
+  const { style = 'short' } = options
+
+  if (!address) address = ZERO_ADDRESS
+  try {
+    address = address.startsWith('0x') ? getAddress(address) : address
+  } catch {}
+
+  switch (style) {
+    case 'short':
+      const lengthOnEachSide = 6
+      if (address.length <= lengthOnEachSide * 2 + 1) return address
+      return `${address.slice(0, lengthOnEachSide)}–${address.slice(-lengthOnEachSide)}`
+    case 'full':
+      return address
+  }
+}

package/src/formatBigInt.ts

@@ -0,0 +1,60 @@
+export interface BigIntFormatOptions {
+  /**
+   * The number of digits starting from the right of `value` to consider as decimal places.
+   *
+   * @default 18n
+   */
+  precision?: bigint | undefined
+  /** @default 0 */
+  minimumFractionDigits?: number | undefined
+  /** @default 20 */
+  maximumFractionDigits?: number | undefined
+  /** @default 'auto' */
+  trailingZeroDisplay?: 'auto' | 'stripIfInteger' | undefined
+}
+
+/**
+ * Formats a bigint as a string.
+ *
+ * @param value - The bigint to format.
+ * @param options - Formatting options.
+ * @returns The string representation of `value`
+ */
+export function formatBigInt(value: bigint, options?: BigIntFormatOptions): string {
+  const {
+    precision = 18n,
+    minimumFractionDigits = 0,
+    maximumFractionDigits = 20,
+    trailingZeroDisplay = 'auto',
+  } = options ?? {}
+
+  if (precision < 0n) {
+    throw new Error(`[formatBigInt] \`precision\` must be positive, got ${precision}`)
+  }
+  if (minimumFractionDigits > maximumFractionDigits) {
+    throw new Error(
+      `[formatBigInt] \`minimumFractionDigits\` (${minimumFractionDigits}) cannot be greater than \`maximumFractionDigits\` (${maximumFractionDigits})`,
+    )
+  }
+  const isNegative = value < 0n
+  const absValue = isNegative ? value * -1n : value
+  const precisionFactor = 10n ** precision
+  const integerPart = absValue / precisionFactor
+  const integerPartString = `${isNegative ? '-' : ''}${integerPart.toLocaleString('en-US')}`
+  const decimalPart = absValue % precisionFactor
+  let decimalPartString = ''
+  if ((decimalPart > 0n || minimumFractionDigits > 0) && maximumFractionDigits > 0) {
+    decimalPartString = decimalPart
+      .toLocaleString('en-US', {
+        useGrouping: false,
+      })
+      .padStart(Number(precision), '0')
+      .replace(/0+$/, '')
+      .padEnd(minimumFractionDigits, '0')
+      .slice(0, maximumFractionDigits)
+    if (trailingZeroDisplay === 'stripIfInteger' && decimalPartString.replace(/0/g, '') === '') {
+      decimalPartString = ''
+    }
+  }
+  return `${integerPartString}${decimalPartString ? `.${decimalPartString}` : ''}`
+}