@e280/stz 0.0.0-2 → 0.0.0-20

package/{readme.md → README.md}

@@ -1,13 +1,12 @@
 
 # `@e280/stz`
 standard library of environment-agnostic typescript functions we use basically everywhere
+- zero dependencies
 
 <br/>
 
-## the tools
-stz has many more tools than documented below, see their [sourcecode here in s/](./s/)
-
-### MapG — an extension of js Map with handy methods
+## MapG
+### extended js map
 - `map.require`
   ```ts
   import {MapG} from "@e280/stz"
@@ -26,7 +25,10 @@ stz has many more tools than documented below, see their [sourcecode here in s/]
   const value = map.guarantee(3, () => "rofl")
   ```
 
-### pub and sub — minimal ergonomic event system
+<br/>
+
+## pub and sub
+### ergonomic event emitters
 - make a publisher fn
   ```ts
   import {pub} from "@e280/stz"
@@ -79,7 +81,41 @@ stz has many more tools than documented below, see their [sourcecode here in s/]
 
 <br/>
 
-## 💖 made with open source love
+## Bytename
+### friendly string encoding for binary data
+
+a bytename looks like `"midsen.picmyn.widrep.baclut dotreg.filtyp.nosnus.siptev"`. that's 16 bytes. each byte maps to a three-letter triplet
+
+the bytename parser (`Bytename.toBytes`) ignores all non-alphabetic characters. thus `midsen.picmyn`, `midsenpicmyn`, and `mid@sen$pic@myn` are all equal.
+
+```ts
+import {Bytename} from "@e280/stz"
+```
+- ```ts
+  Bytename.fromBytes(new Uint8Array([0xDE, 0xAD, 0xBE, 0xEF]))
+    // "ribmug.hilmun"
+  ```
+- ```ts
+  Bytename.toBytes("ribmug.hilmun")
+    // Uint8Array, 4 bytes
+  ```
+- ```ts
+  const bytes = new Uint8Array([
+    0xDE, 0xAD, 0xBE, 0xEF,
+    0xDE, 0xAD, 0xBE, 0xEF,
+  ])
+
+	Bytename.fromBytes(bytes, {
+		groupSize: 2, // default is 4
+		groupSeparator: " ",
+		wordSeparator: ".",
+	})
+	  // "ribmug.hilmun ribmug.hilmun"
+  ```
+
+<br/>
+
+## 💖 stz is made with open source love
 reward us with github stars  
 build with us at https://e280.org/ but only if you're cool  
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@e280/stz",
-	"version": "0.0.0-2",
+	"version": "0.0.0-20",
 	"description": "everyday ts fns for everything",
 	"license": "MIT",
 	"author": "Chase Moskal <chasemoskal@gmail.com>",
@@ -12,15 +12,18 @@
 	],
 	"scripts": {
 		"build": "run-s _clean _links _tsc",
+		"test": "node x/tests.test.js",
+		"count": "find s -path '*/_archive' -prune -o -name '*.ts' -exec wc -l {} +",
+		"start": "run-p _tscw _testw",
 		"_clean": "rm -rf x && mkdir x",
 		"_links": "ln -s \"$(realpath node_modules)\" x/node_modules",
 		"_tsc": "tsc",
-		"start": "exit 0",
-		"count": "find s -path '*/_archive' -prune -o -name '*.ts' -exec wc -l {} +",
-		"test": "exit 0"
+		"_tscw": "tsc -w",
+		"_testw": "node --watch x/tests.test.js"
 	},
 	"devDependencies": {
-		"@types/node": "^22.14.1",
+		"@e280/science": "^0.0.4",
+		"@types/node": "^22.15.21",
 		"npm-run-all": "^4.1.5",
 		"typescript": "^5.8.3"
 	},

package/s/clone/clone.test.ts

@@ -1,124 +1,124 @@
-//
-// import {Suite, expect} from "cynic"
-// import {clone} from "./clone.js"
-//
-// function checkMapOrSetEquality(original: any, cloned: any) {
-// 	const originalEntries = JSON.stringify(Array.from(original))
-// 	const clonedEntries = JSON.stringify(Array.from(cloned))
-// 	expect(clonedEntries).equals(originalEntries)
-// 	expect(cloned).not.equals(original) // check for deep cloning
-// }
-//
-// export default <Suite>{
-//
-// 	async "clone primitive types"() {
-// 		expect(clone(123)).equals(123)
-// 		expect(clone("abc")).equals("abc")
-// 		expect(clone(true)).equals(true)
-// 	},
-//
-// 	async "clone arrays"() {
-// 		const array = [1, 2, 3]
-// 		const clonedArray = clone(array)
-// 		expect(JSON.stringify(clonedArray)).equals(JSON.stringify(array))
-// 		expect(clonedArray).not.equals(array) // check for deep cloning
-// 	},
-//
-// 	async "clone plain objects"() {
-// 		const object = {foo: "bar", baz: 123}
-// 		const clonedObject = clone(object)
-// 		expect(JSON.stringify(clonedObject)).equals(JSON.stringify(object))
-// 		expect(clonedObject).not.equals(object) // check for deep cloning
-// 	},
-//
-// 	async "clone Map"() {
-// 		const map = new Map()
-// 		map.set("key", "value")
-// 		const clonedMap = clone(map)
-// 		expect(map.get("key")).equals("value")
-// 		expect(clonedMap).not.equals(map)
-// 	},
-//
-// 	async "clone Set"() {
-// 		const set = new Set()
-// 		set.add("value")
-// 		const clonedSet = clone(set)
-// 		expect(clonedSet.has("value")).ok()
-// 		expect(clonedSet).not.equals(set)
-// 	},
-//
-// 	async "clone Date"() {
-// 		const date = new Date()
-// 		const clonedDate = clone(date)
-// 		expect(clonedDate.getTime()).equals(date.getTime())
-// 		expect(clonedDate).not.equals(date) // check for deep cloning
-// 	},
-//
-// 	async "clone objects with circular reference"() {
-// 		const object: any = {foo: "bar"}
-// 		object.self = object // create circular reference
-// 		let error: any
-// 		try {
-// 			clone(object)
-// 		} catch (e) {
-// 			error = e
-// 		}
-// 		expect(error).not.equals(undefined)
-// 		expect(error instanceof Error).ok()
-// 	},
-//
-// 	async "clone nested objects"() {
-// 		const object = {foo: "bar", inner: {baz: 123, deeper: {qux: true}}}
-// 		const clonedObject = clone(object)
-// 		expect(JSON.stringify(clonedObject)).equals(JSON.stringify(object))
-// 		expect(clonedObject).not.equals(object) // check for deep cloning
-// 		expect(clonedObject.inner).not.equals(object.inner) // check for deep cloning
-// 		expect(clonedObject.inner.deeper).not.equals(object.inner.deeper) // check for deep cloning
-// 	},
-//
-// 	async "clone array of objects"() {
-// 		const array = [{foo: "bar"}, {baz: 123}, {qux: true}]
-// 		const clonedArray = clone(array)
-// 		expect(JSON.stringify(clonedArray)).equals(JSON.stringify(array))
-// 		expect(clonedArray).not.equals(array) // check for deep cloning
-// 	},
-//
-// 	async "clone object with array"() {
-// 		const object = {foo: "bar", array: [1, 2, 3]}
-// 		const clonedObject = clone(object)
-// 		expect(JSON.stringify(clonedObject)).equals(JSON.stringify(object))
-// 		expect(clonedObject).not.equals(object) // check for deep cloning
-// 	},
-//
-// 	async "clone object with Map"() {
-// 		const map = new Map()
-// 		map.set("key", "value")
-// 		const object = {foo: "bar", map}
-// 		const clonedObject = clone(object)
-// 		expect(JSON.stringify(clonedObject.foo)).equals(JSON.stringify(object.foo))
-// 		checkMapOrSetEquality(object.map, clonedObject.map)
-// 	},
-//
-// 	async "clone object with duplicate sibling references"() {
-// 		const dupeObject = { id: 1, name: "H4CK3RM4N" }
-// 		const data = { obj1: dupeObject, obj2: dupeObject }
-//
-// 		let didThrow = false
-// 		let clonedData: typeof data = {} as typeof data
-//
-// 		try {
-// 			clonedData = clone(data)
-// 		}
-// 		catch (error) {
-// 			didThrow = true
-// 		}
-//
-// 		expect(didThrow).not.equals(true)
-// 		expect(clonedData.obj1).not.equals(clonedData.obj2)
-// 		expect(clonedData.obj1.id).equals(1)
-// 		expect(clonedData.obj1.name).equals("H4CK3RM4N")
-// 		expect(clonedData.obj2.id).equals(1)
-// 		expect(clonedData.obj2.name).equals("H4CK3RM4N")
-// 	},
-// }
+
+import {clone} from "./clone.js"
+import {Science, expect} from "@e280/science"
+
+function checkMapOrSetEquality(original: any, cloned: any) {
+	const originalEntries = JSON.stringify(Array.from(original))
+	const clonedEntries = JSON.stringify(Array.from(cloned))
+	expect(clonedEntries).is(originalEntries)
+	expect(cloned).not.is(original) // check for deep cloning
+}
+
+export default Science.suite({
+
+	async "clone primitive types"() {
+		expect(clone(123)).is(123)
+		expect(clone("abc")).is("abc")
+		expect(clone(true)).is(true)
+	},
+
+	async "clone arrays"() {
+		const array = [1, 2, 3]
+		const clonedArray = clone(array)
+		expect(JSON.stringify(clonedArray)).is(JSON.stringify(array))
+		expect(clonedArray).not.is(array) // check for deep cloning
+	},
+
+	async "clone plain objects"() {
+		const object = {foo: "bar", baz: 123}
+		const clonedObject = clone(object)
+		expect(JSON.stringify(clonedObject)).is(JSON.stringify(object))
+		expect(clonedObject).not.is(object) // check for deep cloning
+	},
+
+	async "clone Map"() {
+		const map = new Map()
+		map.set("key", "value")
+		const clonedMap = clone(map)
+		expect(map.get("key")).is("value")
+		expect(clonedMap).not.is(map)
+	},
+
+	async "clone Set"() {
+		const set = new Set()
+		set.add("value")
+		const clonedSet = clone(set)
+		expect(clonedSet.has("value")).ok()
+		expect(clonedSet).not.is(set)
+	},
+
+	async "clone Date"() {
+		const date = new Date()
+		const clonedDate = clone(date)
+		expect(clonedDate.getTime()).is(date.getTime())
+		expect(clonedDate).not.is(date) // check for deep cloning
+	},
+
+	async "clone objects with circular reference"() {
+		const object: any = {foo: "bar"}
+		object.self = object // create circular reference
+		let error: any
+		try {
+			clone(object)
+		} catch (e) {
+			error = e
+		}
+		expect(error).not.is(undefined)
+		expect(error instanceof Error).ok()
+	},
+
+	async "clone nested objects"() {
+		const object = {foo: "bar", inner: {baz: 123, deeper: {qux: true}}}
+		const clonedObject = clone(object)
+		expect(JSON.stringify(clonedObject)).is(JSON.stringify(object))
+		expect(clonedObject).not.is(object) // check for deep cloning
+		expect(clonedObject.inner).not.is(object.inner) // check for deep cloning
+		expect(clonedObject.inner.deeper).not.is(object.inner.deeper) // check for deep cloning
+	},
+
+	async "clone array of objects"() {
+		const array = [{foo: "bar"}, {baz: 123}, {qux: true}]
+		const clonedArray = clone(array)
+		expect(JSON.stringify(clonedArray)).is(JSON.stringify(array))
+		expect(clonedArray).not.is(array) // check for deep cloning
+	},
+
+	async "clone object with array"() {
+		const object = {foo: "bar", array: [1, 2, 3]}
+		const clonedObject = clone(object)
+		expect(JSON.stringify(clonedObject)).is(JSON.stringify(object))
+		expect(clonedObject).not.is(object) // check for deep cloning
+	},
+
+	async "clone object with Map"() {
+		const map = new Map()
+		map.set("key", "value")
+		const object = {foo: "bar", map}
+		const clonedObject = clone(object)
+		expect(JSON.stringify(clonedObject.foo)).is(JSON.stringify(object.foo))
+		checkMapOrSetEquality(object.map, clonedObject.map)
+	},
+
+	async "clone object with duplicate sibling references"() {
+		const dupeObject = { id: 1, name: "H4CK3RM4N" }
+		const data = { obj1: dupeObject, obj2: dupeObject }
+
+		let didThrow = false
+		let clonedData: typeof data = {} as typeof data
+
+		try {
+			clonedData = clone(data)
+		}
+		catch (error) {
+			didThrow = true
+		}
+
+		expect(didThrow).not.is(true)
+		expect(clonedData.obj1).not.is(clonedData.obj2)
+		expect(clonedData.obj1.id).is(1)
+		expect(clonedData.obj1.name).is("H4CK3RM4N")
+		expect(clonedData.obj2.id).is(1)
+		expect(clonedData.obj2.name).is("H4CK3RM4N")
+	},
+})
 

package/s/coalesce.ts

@@ -0,0 +1,6 @@
+
+/** return a single function that calls all the provided functions */
+export function coalesce<A extends any[] = []>(...fns: ((...a: A) => void)[]) {
+	return (...a: A) => fns.forEach(fn => fn(...a))
+}
+

package/s/data/bytename/bytename.test.ts

@@ -0,0 +1,49 @@
+
+import {Bytes} from "../bytes.js"
+import {Bytename} from "./bytename.js"
+import {Science, test, expect} from "@e280/science"
+
+const deadbeef = new Uint8Array([0xDE, 0xAD, 0xBE, 0xEF])
+
+function good(bytes: Uint8Array) {
+	expect(Bytes.eq(bytes, deadbeef)).ok()
+}
+
+export default Science.suite({
+	"bytes->string->bytes": test(async() => {
+		const text = Bytename.fromBytes(deadbeef)
+		expect(text).is("ribmug.hilmun")
+		good(Bytename.toBytes(text))
+	}),
+
+	"zero bytes": test(async() => {
+		const text = Bytename.fromBytes(new Uint8Array([]))
+		expect(text).is("")
+	}),
+
+	"one byte": test(async() => {
+		const text = Bytename.fromBytes(new Uint8Array([0x00]))
+		expect(text).is("doz")
+	}),
+
+	"groupings": test(async() => {
+		const bytes = new Uint8Array([...deadbeef, ...deadbeef])
+		const text = Bytename.fromBytes(bytes, {
+			groupSize: 2,
+			groupSeparator: " ",
+			wordSeparator: ".",
+		})
+		expect(text).is("ribmug.hilmun ribmug.hilmun")
+	}),
+
+	"wordsep": Science.suite({
+		"underscore": test(async() => good(Bytename.toBytes("ribmug_hilmun"))),
+		"uppercase": test(async() => good(Bytename.toBytes("RIBMUG_HILMUN"))),
+		"dots": test(async() => good(Bytename.toBytes("ribmug.hilmun"))),
+		"crushed": test(async() => good(Bytename.toBytes("ribmughilmun"))),
+		"space": test(async() => good(Bytename.toBytes("ribmug hilmun"))),
+		"spaces": test(async() => good(Bytename.toBytes("ribmug  hilmun"))),
+		"whitespace": test(async() => good(Bytename.toBytes("\n ribmug \n \t \n hilmun \n"))),
+	}),
+})
+

package/s/data/{barname/barname.ts → bytename/bytename.ts}

@@ -1,19 +1,39 @@
 
+import {Hex} from "../hex.js"
 import {Bytes} from "../bytes.js"
 import {prefixes} from "./utils/prefixes.js"
 import {suffixes} from "./utils/suffixes.js"
 
-const wordSeparator = "_"
-const groupSeparator = " "
-const defaultWordsPerGroup = 4
+export type BytenameOptions = {
+	groupSize: number
+	wordSeparator: string
+	groupSeparator: string
+}
+
+/**
+ * Bytename is a friendly presentation format for arbitrary binary data.
+ *  - looks like "midsen.picmyn.widrep.baclut dotreg.filtyp.nosnus.siptev"
+ *  - each byte maps to a three-letter triplet
+ *  - all delimiters are just sugar, parser doesn't care
+ */
+export const Bytename = {
+	defaults: (<BytenameOptions>{
+		groupSize: 4,
+		wordSeparator: ".",
+		groupSeparator: " ",
+	}),
 
-export const Barname = {
-	random(byteCount: number) {
-		return this.string(Bytes.random(byteCount))
+	random(byteCount: number, options?: Partial<BytenameOptions>) {
+		const bytes = Bytes.random(byteCount)
+		return this.fromBytes(bytes, options)
 	},
 
-	string(bytes: Uint8Array, options?: {wordsPerGroup?: number}) {
-		const groupSize = options?.wordsPerGroup ?? defaultWordsPerGroup
+	fromBytes(bytes: Uint8Array, options: Partial<BytenameOptions> = {}) {
+		const {
+			groupSize = Bytename.defaults.groupSize,
+			wordSeparator = Bytename.defaults.wordSeparator,
+			groupSeparator = Bytename.defaults.groupSeparator,
+		} = options
 
 		const words: string[] = []
 		let currentWord: string[] = []
@@ -37,8 +57,8 @@ export const Barname = {
 		return grouped.join(groupSeparator)
 	},
 
-	bytes(string: string) {
-		const letters = string
+	toBytes(bytename: string) {
+		const letters = bytename
 			.toLowerCase()
 			.replace(/[^a-z]/g, "") // strip everything except letters
 
@@ -58,5 +78,13 @@ export const Barname = {
 			return number
 		}))
 	},
+
+	toHex(bytename: string) {
+		return Hex.string(Bytename.toBytes(bytename))
+	},
+
+	fromHex(hex: string, options?: Partial<BytenameOptions>) {
+		return Bytename.fromBytes(Hex.bytes(hex), options)
+	},
 }
 

package/s/data/bytename/index.ts

@@ -0,0 +1,4 @@
+
+export * from "./bytename.js"
+export * from "./thumbprint.js"
+

package/s/data/bytename/thumbprint.test.ts

@@ -0,0 +1,53 @@
+
+import {Science, test, expect} from "@e280/science"
+import {Hex} from "../hex.js"
+import {Bytes} from "../bytes.js"
+import {Thumbprint} from "./thumbprint.js"
+
+const sampleThumbprint = "nodlyn.fasrep.habbud.ralwel.Avo7gFmdWMRHkwsD149mcaBoZdS69iXuJ"
+const sampleHex = "88e8c3fad1028fcf6ce5ac491578850f4d833336feca03b608265501c3019d59"
+const sampleBytes = Hex.bytes(sampleHex)
+
+function good(bytes: Uint8Array) {
+	expect(Bytes.eq(bytes, sampleBytes)).ok()
+}
+
+export default Science.suite({
+	"bytes->string->bytes": test(async() => {
+		const text = Thumbprint.fromBytes(sampleBytes)
+		expect(text).is(sampleThumbprint)
+		good(Thumbprint.toBytes(text))
+	}),
+
+	"zero bytes": test(async() => {
+		const text = Thumbprint.fromBytes(new Uint8Array([]))
+		expect(text).is("")
+		expect(Bytes.eq(Thumbprint.toBytes(text), new Uint8Array([]))).ok()
+	}),
+
+	"one byte": test(async() => {
+		const text = Thumbprint.fromBytes(new Uint8Array([0x00]))
+		expect(text).is("doz")
+		expect(Bytes.eq(Thumbprint.toBytes(text), new Uint8Array([0x00]))).ok()
+	}),
+
+	"partially": Science.suite({
+		"normal": test(async() => expect(Thumbprint.toBytes(sampleThumbprint).length).ok()),
+		"nothing": test(async() => expect(Thumbprint.toBytes("").length).is(0)),
+		"no-bulk": test(async() => expect(Thumbprint.toBytes("nodlyn.fasrep").length).ok()),
+		"one-byte": test(async() => expect(Thumbprint.toBytes("nod").length).is(1)),
+		"three-byte": test(async() => expect(Thumbprint.toBytes("nodlynfas").length).is(3)),
+		"one-byte-sigil": test(async() => expect(Thumbprint.toBytes("nod::39gfeGFAAnBzH5pkT7EdoETMUMAekG9h1iymk6k").length).ok()),
+	}),
+
+	"tolerance": Science.suite({
+		"normal": test(async() => good(Thumbprint.toBytes("nodlyn.fasrep::39gfeGFAAnBzH5pkT7EdoETMUMAekG9h1iymk6k"))),
+		"coolio": test(async() => good(Thumbprint.toBytes("nodlyn.fasrep..39gfeGFAAnBzH5pkT7EdoETMUMAekG9h1iymk6k"))),
+		"spaces": test(async() => good(Thumbprint.toBytes("nodlyn fasrep 39gfeGFAAnBzH5pkT7EdoETMUMAekG9h1iymk6k"))),
+		"dots": test(async() => good(Thumbprint.toBytes("nodlyn.fasrep.39gfeGFAAnBzH5pkT7EdoETMUMAekG9h1iymk6k"))),
+		"one-space": test(async() => good(Thumbprint.toBytes("nodlynfasrep 39gfeGFAAnBzH5pkT7EdoETMUMAekG9h1iymk6k"))),
+		"one-newline": test(async() => good(Thumbprint.toBytes("nodlynfasrep\n39gfeGFAAnBzH5pkT7EdoETMUMAekG9h1iymk6k"))),
+		"whitespace": test(async() => good(Thumbprint.toBytes("\t\n nodlyn\n fasrep \n\n\t\n 39gfeGFAAnBzH5pkT7EdoETMUMAekG9h1iymk6k\n\t"))),
+	}),
+})
+

package/s/data/bytename/thumbprint.ts

@@ -0,0 +1,112 @@
+
+import {Hex} from "../hex.js"
+import {Base58} from "../base58.js"
+import {Bytename} from "./bytename.js"
+
+export type ThumbprintOptions = {
+	delimiter: string
+	sigilBytes: number
+	previewBytes: number
+}
+
+export type ThumbprintData = {
+	bytes: Uint8Array
+	thumbprint: string
+	preview: string
+	bulk: string
+	sigil: string
+}
+
+/**
+ * Thumbprint is a friendly presentation format for arbitrary binary data.
+ *  - looks like "nodlyn.fasrep.habbud.ralwel.Avo7gFmdWMRHkwsD149mcaBoZdS69iXuJ"
+ *  - the preview: "nodlyn.fasrep.habbud.ralwel" (bytename format)
+ *  - the bulk: "Avo7gFmdWMRHkwsD149mcaBoZdS69iXuJ" (base58 format)
+ *  - the sigil: "nodlyn.fasrep" (shorter part of the bytename)
+ *  - originally designed to be a nice way to present 256-bit ids, but can actually represent any number of bytes
+ */
+export const Thumbprint = {
+	defaults: (<ThumbprintOptions>{
+		delimiter: ".",
+		sigilBytes: 4,
+		previewBytes: 8,
+	}),
+
+	toBytes(thumbprint: string) {
+		thumbprint = thumbprint.trim()
+		const beans = thumbprint.split(/[^a-zA-Z0-9]+/m)
+			.filter(Boolean)
+			.map(s => s.trim())
+
+		if (beans.length < 2)
+			return Bytename.toBytes(beans.join(""))
+
+		const bulk = beans.pop()!
+		const preview = beans.join("")
+
+		return new Uint8Array([
+			...Bytename.toBytes(preview),
+			...Base58.bytes(bulk),
+		])
+	},
+
+	parse(thumbprint: string, options?: Partial<ThumbprintOptions>): ThumbprintData {
+		const bytes = Thumbprint.toBytes(thumbprint)
+		return Thumbprint.build.fromBytes(bytes, options)
+	},
+
+	build: {
+		fromBytes(bytes: Uint8Array, options: Partial<ThumbprintOptions> = {}): ThumbprintData {
+			const {delimiter, previewBytes, sigilBytes}
+				= {...Thumbprint.defaults, ...options}
+
+			const yoink = (b: number) => (bytes.length > 0)
+				? Bytename.fromBytes(bytes.slice(0, b), {
+					wordSeparator: delimiter,
+					groupSeparator: delimiter,
+				})
+				: ""
+
+			const sigil = yoink(sigilBytes)
+			const preview = yoink(previewBytes)
+
+			const bulk = (bytes.length > previewBytes)
+				? Base58.string(bytes.slice(previewBytes))
+				: ""
+
+			const thumbprint = [preview, bulk]
+				.filter(s => s.length > 0)
+				.join(delimiter)
+
+			return {bytes, thumbprint, preview, bulk, sigil}
+		},
+
+		fromHex(hex: string, options?: Partial<ThumbprintOptions>) {
+			const bytes = Hex.bytes(hex)
+			return Thumbprint.build.fromBytes(bytes, options)
+		},
+	},
+
+	toHex(thumbprint: string) {
+		const bytes = Thumbprint.toBytes(thumbprint)
+		return Hex.string(bytes)
+	},
+
+	fromBytes(bytes: Uint8Array, options?: Partial<ThumbprintOptions>) {
+		return Thumbprint.build.fromBytes(bytes, options).thumbprint
+	},
+
+	fromHex(hex: string, options?: Partial<ThumbprintOptions>) {
+		return Thumbprint.fromBytes(Hex.bytes(hex), options)
+	},
+
+	sigil: {
+		fromHex(hex: string, options?: Partial<ThumbprintOptions>) {
+			return Thumbprint.build.fromHex(hex, options).sigil
+		},
+		fromBytes(bytes: Uint8Array, options?: Partial<ThumbprintOptions>) {
+			return Thumbprint.build.fromBytes(bytes, options).sigil
+		},
+	},
+}
+

package/s/data/bytes.ts

@@ -1,5 +1,15 @@
 
 export const Bytes = {
+	eq(a: Uint8Array, b: Uint8Array) {
+		if (a.length !== b.length)
+			return false
+		for (let i = 0; i <= a.length; i++) {
+			if (a.at(i) !== b.at(i))
+				return false
+		}
+		return true
+	},
+
 	random(count: number) {
 		return crypto.getRandomValues(new Uint8Array(count))
 	},