@e280/stz 0.2.10 → 0.2.11

package/s/data/bytename/thumbprint.ts

@@ -1,7 +1,6 @@
 
-import {Hex} from "../hex.js"
-import {Base58} from "../base58.js"
-import {Bytename} from "./bytename.js"
+import {bytename} from "./bytename.js"
+import {base58, hex} from "../base-x-codecs.js"
 
 export type ThumbprintOptions = {
 	delimiter: string
@@ -10,11 +9,17 @@ export type ThumbprintOptions = {
 }
 
 export type ThumbprintData = {
-	bytes: Uint8Array
-	thumbprint: string
+	raw: Uint8Array
+	full: string
 	preview: string
 	bulk: string
 	sigil: string
+
+	/** @deprecated renamed to `raw` */
+	readonly bytes: Uint8Array
+
+	/** @deprecated renamed to `full` */
+	readonly thumbprint: string
 }
 
 /**
@@ -25,43 +30,43 @@ export type ThumbprintData = {
  *  - 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 = {
+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)
+	toBytes(tstring: string) {
+		tstring = tstring.trim()
+		const beans = tstring.split(/[^a-zA-Z0-9]+/m)
 			.filter(Boolean)
 			.map(s => s.trim())
 
 		if (beans.length < 2)
-			return Bytename.toBytes(beans.join(""))
+			return bytename.toBytes(beans.join(""))
 
 		const bulk = beans.pop()!
 		const preview = beans.join("")
 
 		return new Uint8Array([
-			...Bytename.toBytes(preview),
-			...Base58.toBytes(bulk),
+			...bytename.toBytes(preview),
+			...base58.toBytes(bulk),
 		])
 	},
 
-	parse(thumbprint: string, options?: Partial<ThumbprintOptions>): ThumbprintData {
-		const bytes = Thumbprint.toBytes(thumbprint)
-		return Thumbprint.build.fromBytes(bytes, options)
+	parse(tstring: string, options?: Partial<ThumbprintOptions>): ThumbprintData {
+		const bytes = thumbprint.toBytes(tstring)
+		return thumbprint.build.fromBytes(bytes, options)
 	},
 
 	build: {
-		fromBytes(bytes: Uint8Array, options: Partial<ThumbprintOptions> = {}): ThumbprintData {
+		fromBytes(raw: Uint8Array, options: Partial<ThumbprintOptions> = {}): ThumbprintData {
 			const {delimiter, previewBytes, sigilBytes}
-				= {...Thumbprint.defaults, ...options}
+				= {...thumbprint.defaults, ...options}
 
-			const yoink = (b: number) => (bytes.length > 0)
-				? Bytename.fromBytes(bytes.slice(0, b), {
+			const yoink = (len: number) => (raw.length > 0)
+				? bytename.fromBytes(raw.slice(0, len), {
 					wordSeparator: delimiter,
 					groupSeparator: delimiter,
 				})
@@ -70,43 +75,55 @@ export const Thumbprint = {
 			const sigil = yoink(sigilBytes)
 			const preview = yoink(previewBytes)
 
-			const bulk = (bytes.length > previewBytes)
-				? Base58.fromBytes(bytes.slice(previewBytes))
+			const bulk = (raw.length > previewBytes)
+				? base58.fromBytes(raw.slice(previewBytes))
 				: ""
 
-			const thumbprint = [preview, bulk]
+			const full = [preview, bulk]
 				.filter(s => s.length > 0)
 				.join(delimiter)
 
-			return {bytes, thumbprint, preview, bulk, sigil}
+			return {
+				raw,
+				full,
+				preview,
+				bulk,
+				sigil,
+
+				bytes: raw,
+				thumbprint: full,
+			}
 		},
 
-		fromHex(hex: string, options?: Partial<ThumbprintOptions>) {
-			const bytes = Hex.toBytes(hex)
-			return Thumbprint.build.fromBytes(bytes, options)
+		fromHex(hstring: string, options?: Partial<ThumbprintOptions>) {
+			const bytes = hex.toBytes(hstring)
+			return thumbprint.build.fromBytes(bytes, options)
 		},
 	},
 
-	toHex(thumbprint: string) {
-		const bytes = Thumbprint.toBytes(thumbprint)
-		return Hex.fromBytes(bytes)
+	toHex(tstring: string) {
+		const bytes = thumbprint.toBytes(tstring)
+		return hex.fromBytes(bytes)
 	},
 
-	fromBytes(bytes: Uint8Array, options?: Partial<ThumbprintOptions>) {
-		return Thumbprint.build.fromBytes(bytes, options).thumbprint
+	fromBytes(b: Uint8Array, options?: Partial<ThumbprintOptions>) {
+		return thumbprint.build.fromBytes(b, options).full
 	},
 
-	fromHex(hex: string, options?: Partial<ThumbprintOptions>) {
-		return Thumbprint.fromBytes(Hex.toBytes(hex), options)
+	fromHex(h: string, options?: Partial<ThumbprintOptions>) {
+		return thumbprint.fromBytes(hex.toBytes(h), options)
 	},
 
 	sigil: {
-		fromHex(hex: string, options?: Partial<ThumbprintOptions>) {
-			return Thumbprint.build.fromHex(hex, options).sigil
+		fromHex(h: string, options?: Partial<ThumbprintOptions>) {
+			return thumbprint.build.fromHex(h, options).sigil
 		},
-		fromBytes(bytes: Uint8Array, options?: Partial<ThumbprintOptions>) {
-			return Thumbprint.build.fromBytes(bytes, options).sigil
+		fromBytes(b: Uint8Array, options?: Partial<ThumbprintOptions>) {
+			return thumbprint.build.fromBytes(b, options).sigil
 		},
 	},
 }
 
+/** @deprecated renamed to `thumbprint` */
+export const Thumbprint = thumbprint
+

package/s/data/bytes.ts

@@ -1,5 +1,5 @@
 
-export const Bytes = Object.freeze({
+export const bytes = Object.freeze({
 	eq(a: Uint8Array, b: Uint8Array) {
 		if (a.length !== b.length)
 			return false
@@ -15,3 +15,6 @@ export const Bytes = Object.freeze({
 	},
 })
 
+/** @deprecated renamed to `bytes` */
+export const Bytes = bytes
+

package/s/data/data.test.ts

@@ -1,15 +1,14 @@
 
 import {Science, test, expect} from "@e280/science"
 import {ob} from "../ob.js"
-import {Txt} from "./txt.js"
-import {Hex} from "./hex.js"
-import {Bytes} from "./bytes.js"
+import {txt} from "./txt.js"
+import {bytes} from "./bytes.js"
 import {BaseX} from "./base-x.js"
-import {Base58} from "./base58.js"
-import {Base64} from "./base64.js"
-import {Base64url} from "./base64url.js"
+import {base58, base64, base64url, hex} from "./base-x-codecs.js"
+import bytename from "./bytename/bytename.test.js"
+import thumbprint from "./bytename/thumbprint.test.js"
 
-const sampleBytes = Hex.toBytes("9960cd633a46acfe8307d8a400e842da0d930a75fb8188e0f5da264e4b6b4e5b")
+const sampleBytes = hex.toBytes("9960cd633a46acfe8307d8a400e842da0d930a75fb8188e0f5da264e4b6b4e5b")
 
 type ByteUtil = {
 	toBytes: (string: string) => Uint8Array
@@ -25,7 +24,7 @@ function testBytes(util: ByteUtil) {
 	return async() => {
 		const string = util.fromBytes(sampleBytes)
 		const recreated = util.toBytes(string)
-		expect(Bytes.eq(sampleBytes, recreated)).ok()
+		expect(bytes.eq(sampleBytes, recreated)).ok()
 	}
 }
 
@@ -63,15 +62,18 @@ function testCompat(alpha: ByteUtil, bravo: ByteUtil) {
 }
 
 export default Science.suite({
-	"Base58": testBytes(Base58),
-	"Base64": testBytes(Base64),
-	"Base64url": testBytes(Base64url),
-	"Hex": testBytes(Hex),
+	bytename,
+	thumbprint,
+
+	"Base58": testBytes(base58),
+	"Base64": testBytes(base64),
+	"Base64url": testBytes(base64url),
+	"Hex": testBytes(hex),
 
 	"Txt": test(async() => {
 		const original = `build or die. 💻>☠️ 命火工`
-		const bytes = Txt.toBytes(original)
-		const recreated = Txt.fromBytes(bytes)
+		const bytes = txt.toBytes(original)
+		const recreated = txt.fromBytes(bytes)
 		expect(original).is(recreated)
 	}),
 
@@ -80,9 +82,9 @@ export default Science.suite({
 			ob(BaseX.lexicons).map(lex => testBoth(new BaseX(lex)))
 		),
 		compat: Science.suite({
-			"Hex": testCompat(Hex, new BaseX(BaseX.lexicons.hex)),
-			"Base64": testCompat(Base64, new BaseX(BaseX.lexicons.base64)),
-			"Base64url": testCompat(Base64url, new BaseX(BaseX.lexicons.base64url)),
+			"Hex": testCompat(hex, new BaseX(BaseX.lexicons.hex)),
+			"Base64": testCompat(base64, new BaseX(BaseX.lexicons.base64)),
+			"Base64url": testCompat(base64url, new BaseX(BaseX.lexicons.base64url)),
 		}),
 		"base64 has padding": test(async() => {
 			const s = new BaseX(BaseX.lexicons.base64).fromBytes(sampleBytes)

package/s/data/{base58.ts → legacy/base58.ts}

@@ -10,11 +10,12 @@
 */
 
 import {Hex} from "./hex.js"
-import {Bytes} from "./bytes.js"
+import {bytes} from "../bytes.js"
 
 const base = 58
 const characters = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
 
+/** @deprecated use `base58` instead */
 export const Base58 = Object.freeze({
 	fromBytes(bytes: Uint8Array) {
 		let intVal = BigInt("0x" + Hex.fromBytes(bytes))
@@ -59,7 +60,7 @@ export const Base58 = Object.freeze({
 	},
 
 	random(count = 32) {
-		return this.fromBytes(Bytes.random(count))
+		return this.fromBytes(bytes.random(count))
 	},
 
 	/** @deprecated renamed to `fromBytes` */

package/s/data/{base64.ts → legacy/base64.ts}

@@ -1,6 +1,7 @@
 
-import {Bytes} from "./bytes.js"
+import {bytes} from "../bytes.js"
 
+/** @deprecated use `base64` instead */
 export const Base64 = Object.freeze({
 	fromBytes(bytes: Uint8Array) {
 		return (typeof btoa === "function")
@@ -15,7 +16,7 @@ export const Base64 = Object.freeze({
 	},
 
 	random(count = 32) {
-		return this.fromBytes(Bytes.random(count))
+		return this.fromBytes(bytes.random(count))
 	},
 
 	/** @deprecated rename to "fromBytes" */

package/s/data/{base64url.ts → legacy/base64url.ts}

@@ -1,7 +1,8 @@
 
-import {Bytes} from "./bytes.js"
+import {bytes} from "../bytes.js"
 import {Base64} from "./base64.js"
 
+/** @deprecated use `base64url` instead */
 export const Base64url = {
 	fromBytes(bytes: Uint8Array) {
 		return Base64.fromBytes(bytes)
@@ -20,7 +21,7 @@ export const Base64url = {
 	},
 
 	random(count = 32) {
-		return this.fromBytes(Bytes.random(count))
+		return this.fromBytes(bytes.random(count))
 	},
 
 	/** @deprecated renamed to "fromBytes" */

package/s/data/{hex.ts → legacy/hex.ts}

@@ -9,8 +9,9 @@
 
 */
 
-import {Bytes} from "./bytes.js"
+import {bytes} from "../bytes.js"
 
+/** @deprecated use `hex` instead */
 export const Hex = Object.freeze({
 	fromBytes(bytes: Uint8Array) {
 		return [...bytes]
@@ -29,7 +30,7 @@ export const Hex = Object.freeze({
 
 	/** generate a random hex string. byteCount defaults to 32. */
 	random(byteCount = 32) {
-		return this.fromBytes(Bytes.random(byteCount))
+		return this.fromBytes(bytes.random(byteCount))
 	},
 
 	/** @deprecated renamed to `fromBytes` */

package/s/data/nomen/grammar.ts

@@ -1,6 +1,6 @@
 
 import {ob} from "../../ob.js"
-import {Bytes} from "../bytes.js"
+import {bytes} from "../bytes.js"
 import {GrammarTemplate, PhraseFns} from "./types.js"
 
 export class Grammar<P extends PhraseFns> {
@@ -34,7 +34,7 @@ export class Grammar<P extends PhraseFns> {
 	}
 
 	random() {
-		const buffer = Bytes.random(32)
+		const buffer = bytes.random(32)
 		return this.generate(buffer)
 	}
 }

package/s/data/nomen/nomen.ts

@@ -1,5 +1,5 @@
 
-import {Bytes} from "../bytes.js"
+import {bytes} from "../bytes.js"
 import {Dictionary, Pattern} from "./types.js"
 
 export class Nomen<D extends Dictionary> {
@@ -27,7 +27,7 @@ export class Nomen<D extends Dictionary> {
 	}
 
 	random() {
-		const buffer = Bytes.random(32)
+		const buffer = bytes.random(32)
 		return this.generate(buffer)
 	}
 }

package/s/data/txt.ts

@@ -1,5 +1,5 @@
 
-export const Txt = Object.freeze({
+export const txt = Object.freeze({
 	fromBytes(bytes: Uint8Array) {
 		return new TextDecoder().decode(bytes)
 	},
@@ -10,12 +10,15 @@ export const Txt = Object.freeze({
 
 	/** @deprecated renamed to `fromBytes` */
 	string(bytes: Uint8Array) {
-		return Txt.fromBytes(bytes)
+		return txt.fromBytes(bytes)
 	},
 
 	/** @deprecated renamed to `toBytes` */
 	bytes(string: string) {
-		return Txt.toBytes(string)
+		return txt.toBytes(string)
 	},
 })
 
+/** @deprecated renamed to `txt` */
+export const Txt = txt
+

package/s/deep/{parts/equal.test.ts → equal.test.ts}

@@ -1,60 +1,60 @@
 
-import {deepEqual} from "./equal.js"
+import {equal} from "./equal.js"
 import {Science, expect} from "@e280/science"
 
 export default Science.suite({
 	async "compare primitive types"() {
-		expect(deepEqual(123, 123)).is(true)
-		expect(deepEqual("abc", "abc")).is(true)
-		expect(deepEqual(true, true)).is(true)
-		expect(deepEqual(123, "123")).is(false)
-		expect(deepEqual(true, 1)).is(false)
+		expect(equal(123, 123)).is(true)
+		expect(equal("abc", "abc")).is(true)
+		expect(equal(true, true)).is(true)
+		expect(equal(123, "123")).is(false)
+		expect(equal(true, 1)).is(false)
 	},
 
 	async "compare arrays"() {
 		const array1 = [1, 2, 3]
 		const array2 = [1, 2, 3]
 		const array3 = [1, 2, 4]
-		expect(deepEqual(array1, array2)).is(true)
-		expect(deepEqual(array1, array3)).is(false)
+		expect(equal(array1, array2)).is(true)
+		expect(equal(array1, array3)).is(false)
 	},
 
 	async "compare plain objects"() {
 		const obj1 = { foo: "bar", baz: 123 }
 		const obj2 = { foo: "bar", baz: 123 }
 		const obj3 = { foo: "bar", baz: 124 }
-		expect(deepEqual(obj1, obj2)).is(true)
-		expect(deepEqual(obj1, obj3)).is(false)
+		expect(equal(obj1, obj2)).is(true)
+		expect(equal(obj1, obj3)).is(false)
 	},
 
 	async "compare nested objects"() {
 		const obj1 = { foo: "bar", inner: { baz: 123, deeper: { qux: true }}}
 		const obj2 = { foo: "bar", inner: { baz: 123, deeper: { qux: true }}}
 		const obj3 = { foo: "bar", inner: { baz: 124, deeper: { qux: true }}}
-		expect(deepEqual(obj1, obj2)).is(true)
-		expect(deepEqual(obj1, obj3)).is(false)
+		expect(equal(obj1, obj2)).is(true)
+		expect(equal(obj1, obj3)).is(false)
 	},
 
 	async "compare array of objects"() {
 		const arr1 = [{ foo: "bar" }, { baz: 123 }, { qux: true }]
 		const arr2 = [{ foo: "bar" }, { baz: 123 }, { qux: true }]
 		const arr3 = [{ foo: "bar" }, { baz: 123 }, { qux: false }]
-		expect(deepEqual(arr1, arr2)).is(true)
-		expect(deepEqual(arr1, arr3)).is(false)
+		expect(equal(arr1, arr2)).is(true)
+		expect(equal(arr1, arr3)).is(false)
 	},
 
 	async "compare null and undefined"() {
-		expect(deepEqual(null, null)).is(true)
-		expect(deepEqual(undefined, undefined)).is(true)
-		expect(deepEqual(null, undefined)).is(false)
+		expect(equal(null, null)).is(true)
+		expect(equal(undefined, undefined)).is(true)
+		expect(equal(null, undefined)).is(false)
 	},
 
 	async "compare with nested arrays"() {
 		const obj1 = { foo: "bar", array: [1, 2, [3, 4]] }
 		const obj2 = { foo: "bar", array: [1, 2, [3, 4]] }
 		const obj3 = { foo: "bar", array: [1, 2, [3, 5]] }
-		expect(deepEqual(obj1, obj2)).is(true)
-		expect(deepEqual(obj1, obj3)).is(false)
+		expect(equal(obj1, obj2)).is(true)
+		expect(equal(obj1, obj3)).is(false)
 	},
 
 	async "circularity is forbidden"() {
@@ -62,7 +62,7 @@ export default Science.suite({
 		const obj2 = {alpha: 1} as any
 		obj1.bravo = obj1
 		obj2.bravo = obj2
-		expect(() => deepEqual(obj1, obj2)).throws()
+		expect(() => equal(obj1, obj2)).throws()
 	},
 
 	async "duplicate references are allowed"() {
@@ -70,8 +70,8 @@ export default Science.suite({
 		const obj1 = {alpha: 1, dupe}
 		const obj2 = {alpha: 1, dupe}
 		const obj3 = {alpha: 1, dupe: {a: 0}}
-		expect(deepEqual(obj1, obj2)).is(true)
-		expect(deepEqual(obj1, obj3)).is(false)
+		expect(equal(obj1, obj2)).is(true)
+		expect(equal(obj1, obj3)).is(false)
 	},
 
 	"maps and sets": {
@@ -79,32 +79,32 @@ export default Science.suite({
 			const map1 = new Map([['key1', 'value1'], ['key2', 'value2']])
 			const map2 = new Map([['key1', 'value1'], ['key2', 'value2']])
 			const map3 = new Map([['key1', 'value1'], ['key2', 'value3']])
-			expect(deepEqual(map1, map2)).is(true)
-			expect(deepEqual(map1, map3)).is(false)
+			expect(equal(map1, map2)).is(true)
+			expect(equal(map1, map3)).is(false)
 		},
 
 		async "compare sets"() {
 			const set1 = new Set([1, 2, 3])
 			const set2 = new Set([1, 2, 3])
 			const set3 = new Set([1, 2, 4])
-			expect(deepEqual(set1, set2)).is(true)
-			expect(deepEqual(set1, set3)).is(false)
+			expect(equal(set1, set2)).is(true)
+			expect(equal(set1, set3)).is(false)
 		},
 
 		async "compare nested maps and sets"() {
 			const obj1 = { map: new Map([['key', new Set([1, 2, 3])]]) }
 			const obj2 = { map: new Map([['key', new Set([1, 2, 3])]]) }
 			const obj3 = { map: new Map([['key', new Set([1, 2, 4])]]) }
-			expect(deepEqual(obj1, obj2)).is(true)
-			expect(deepEqual(obj1, obj3)).is(false)
+			expect(equal(obj1, obj2)).is(true)
+			expect(equal(obj1, obj3)).is(false)
 		},
 
 		async "compare complex structures"() {
 			const map1 = new Map([['set', new Set([{ a: 1 }, { b: 2 }])]])
 			const map2 = new Map([['set', new Set([{ a: 1 }, { b: 2 }])]])
 			const map3 = new Map([['set', new Set([{ a: 1 }, { b: 3 }])]])
-			expect(deepEqual(map1, map2)).is(true)
-			expect(deepEqual(map1, map3)).is(false)
+			expect(equal(map1, map2)).is(true)
+			expect(equal(map1, map3)).is(false)
 		},
 
 		async "compare edge cases"() {
@@ -114,9 +114,9 @@ export default Science.suite({
 			const emptySet2 = new Set()
 			const mixedMap1 = new Map([['b', 2], ['a', 1]])
 			const mixedMap2 = new Map([['a', 1], ['b', 2]])
-			expect(deepEqual(emptyMap1, emptyMap2)).is(true)
-			expect(deepEqual(emptySet1, emptySet2)).is(true)
-			expect(deepEqual(mixedMap1, mixedMap2)).is(true)
+			expect(equal(emptyMap1, emptyMap2)).is(true)
+			expect(equal(emptySet1, emptySet2)).is(true)
+			expect(equal(mixedMap1, mixedMap2)).is(true)
 		},
 	},
 })

package/s/deep/{parts/equal.ts → equal.ts}

@@ -1,7 +1,7 @@
 
-import {is} from "../../is.js"
+import {is} from "../is.js"
 
-export const deepEqual = (alpha: any, bravo: any): boolean => {
+export const equal = (alpha: any, bravo: any): boolean => {
 
 	function recurse(alpha: any, bravo: any, parents: object[]) {
 		if (!is.object(alpha) || !is.object(bravo))

package/s/deep/{parts/freeze.ts → freeze.ts}

@@ -1,8 +1,7 @@
 
-import {is} from "../../is.js"
-
-export function deepFreeze<X>(item: X): X {
+import {is} from "../is.js"
 
+export function freeze<X>(item: X): X {
 	function recurse(x: X, parents: object[]) {
 		if (!is.object(x) || parents.includes(x))
 			return x

package/s/deep/index.barrel.ts

@@ -0,0 +1,5 @@
+
+export * from "./clone.js"
+export * from "./equal.js"
+export * from "./freeze.js"
+

package/s/deep/index.test.ts

@@ -0,0 +1,10 @@
+
+import {Science} from "@e280/science"
+import clone from "./clone.test.js"
+import equal from "./equal.test.js"
+
+export default Science.suite({
+	clone,
+	equal,
+})
+

package/s/deep/index.ts

@@ -0,0 +1,3 @@
+
+export * as deep from "./index.barrel.js"
+

package/s/g/map.ts

@@ -0,0 +1,36 @@
+
+/** extended js map with handy methods like `require` and `guarantee` */
+export class GMap<K, V> extends Map<K, V> {
+	static require<K, V>(map: Map<K, V>, key: K) {
+		if (map.has(key))
+			return map.get(key) as V
+		else
+			throw new Error(`required key not found: "${key}"`)
+	}
+
+	static guarantee<K, V>(map: Map<K, V>, key: K, make: () => V) {
+		if (map.has(key))
+			return map.get(key)!
+		else {
+			const value = make()
+			map.set(key, value)
+			return value
+		}
+	}
+
+	array() {
+		return [...this]
+	}
+
+	require(key: K) {
+		return GMap.require(this, key)
+	}
+
+	guarantee(key: K, make: () => V) {
+		return GMap.guarantee(this, key, make)
+	}
+}
+
+/** @deprecated renamed to `GMap` */
+export const MapG = GMap
+

package/s/g/pool.ts

@@ -0,0 +1,24 @@
+
+import {GMap} from "./map.js"
+
+export type Identifiable<Id = any> = {id: Id}
+
+/** js map but for things that have an `id` field */
+export class GPool<V extends Identifiable> extends GMap<V["id"], V> {
+	got(value: V) {
+		return this.has(value.id)
+	}
+
+	add(value: V) {
+		this.set(value.id, value)
+		return value
+	}
+
+	remove(value: V) {
+		return this.delete(value.id)
+	}
+}
+
+/** @deprecated renamed to `GPool` */
+export const PoolG = GPool
+

package/s/{set-g.ts → g/set.ts}

@@ -1,5 +1,5 @@
 
-export class SetG<T> extends Set<T> {
+export class GSet<T> extends Set<T> {
 	array() {
 		return [...this]
 	}
@@ -24,3 +24,6 @@ export class SetG<T> extends Set<T> {
 	}
 }
 
+/** @deprecated renamed to `GSet` */
+export const SetG = GSet
+