@e280/stz 0.0.0-0

package/license

@@ -0,0 +1,23 @@
+
+MIT License
+
+Copyright (c) 2025 Chase Moskal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/package.json

@@ -0,0 +1,40 @@
+{
+	"name": "@e280/stz",
+	"version": "0.0.0-0",
+	"description": "everyday ts fns for everything",
+	"license": "MIT",
+	"author": "Chase Moskal <chasemoskal@gmail.com>",
+	"type": "module",
+	"main": "x/index.js",
+	"files": [
+		"x",
+		"s"
+	],
+	"scripts": {
+		"build": "run-s _clean _links _tsc",
+		"_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"
+	},
+	"devDependencies": {
+		"@types/node": "^22.14.1",
+		"npm-run-all": "^4.1.5",
+		"typescript": "^5.8.3"
+	},
+	"keywords": [
+		"standard",
+		"std",
+		"steeze"
+	],
+	"homepage": "https://github.com/e280/stz#readme",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/e280/stz.git"
+	},
+	"bugs": {
+		"url": "https://github.com/e280/stz/issues"
+	}
+}

package/readme.md

@@ -0,0 +1,85 @@
+
+# `@e280/stz`
+standard library of environment-agnostic typescript functions we use basically everywhere
+
+<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
+- `map.require`
+  ```ts
+  import {MapG} from "@e280/stz"
+
+  const map = new MapG<number, string>([
+    [1, "hello"],
+    [2, "world"],
+  ])
+
+  // throws error if the value is undefined
+  const value = map.require(1)
+  ```
+- `map.guarantee`
+  ```ts
+  // if the value is undefined, the new value "rofl" is set and returned
+  const value = map.guarantee(3, () => "rofl")
+  ```
+
+### pub and sub — minimal ergonomic event system
+- make a publisher fn
+  ```ts
+  import {pub} from "@e280/stz"
+
+  // create a pub fn
+  const sendMessage = pub<[string]>()
+
+  // subscribe to it
+  sendMessage.sub(m => console.log(m))
+
+  // publish to it
+  sendMessage("hello")
+  ```
+- make a subscriber fn *(see how it's just the reverse of pub?)*
+  ```ts
+  import {sub} from "@e280/stz"
+
+  // create a sub fn
+  const onMessage = sub<[string]>()
+
+  // subscribe to it
+  onMessage(m => console.log(m))
+
+  // publish to it
+  onMessage.pub("hello")
+  ```
+- the pub and sub are the same, but have differing invoke signatures
+- i seem to use `sub` more often
+- both have some extra functionality
+  ```ts
+  // pub fns return a promise, to wait for all async subscribers
+  await sendMessage("hello")
+  await onMessage.pub("hello")
+
+  // sub fns return an unsub fn
+  const unsub1 = onMessage(m => console.log(m))
+  unsub1() // unsubscribe that listener
+
+  const unsub2 = sendMessage.sub(m => console.log(m))
+  unsub2() // unsubscribe that listener
+
+  // you can clear all subscribers from a pub or a sub
+  sendMessage.clear()
+  onMessage.clear()
+
+  // you can subscribe to only one next call
+  onMessage.once(m => console.log(m))
+  sendMessage.once(m => console.log(m))
+  ```
+
+<br/>
+
+## 💖 made with open source love
+reward us with github stars  
+build with us at https://e280.org/ but only if you're cool  
+

package/s/clone/clone.test.ts

@@ -0,0 +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")
+// 	},
+// }
+

package/s/clone/clone.ts

@@ -0,0 +1,41 @@
+
+export function clone<T>(data: T, refs = new Set<any>()): T {
+
+	if (refs.has(data))
+		throw new Error("cannot clone circular reference")
+
+	let copy = undefined as T
+
+	if (typeof data === "function" || (data !== null && typeof data === "object")) {
+		refs.add(data)
+
+		if (Array.isArray(data))
+			copy = data.map(d => clone(d, new Set(refs))) as T
+
+		else if (data.constructor === Object)
+			copy = Object.fromEntries(
+				Object.entries(data)
+					.map(([key, d]) => [key, clone(d, new Set(refs))])
+			) as T
+
+		else if (data instanceof Map)
+			copy = new Map(Array.from(data, ([key, val]) => [key, clone(val, new Set(refs))])) as T
+
+		else if (data instanceof Set)
+			copy = new Set(Array.from(data, val => clone(val, new Set(refs)))) as T
+
+		else if (data instanceof Date)
+			copy = new Date(data.getTime()) as T
+
+		else
+			copy = data
+
+		refs.delete(data) // Remove current data from refs once we're done with this branch of the object tree
+	}
+
+	else
+		copy = data
+
+	return copy
+}
+

package/s/concurrent.ts

@@ -0,0 +1,12 @@
+
+export async function concurrent<O extends Record<string, Promise<any>>>(
+		ob: O,
+	) {
+	const entries = Object.entries(ob)
+	const promises = entries.map(([,promise]) => promise)
+	const values = await Promise.all(promises)
+	return (
+		Object.fromEntries(entries.map(([key], index) => [key, values[index]]))
+	) as {[K in keyof O]: Awaited<O[K]>}
+}
+

package/s/data/anka.ts

@@ -0,0 +1,66 @@
+
+/*
+
+"anka" is an alternative to base64 that i totally made up.
+	- it looks cool because it features characters from the indian subcontinent.
+	- each byte is represented by one character, which makes a 256 bit id incomparably short at only 32 characters.
+	- however, it's probably a bad idea, for these negative reasons:
+		1. many of these characters are actually 2-or-3-byte sequences (so even though anka is visually more compact than base64 to the user, it's actually more data in terms of bytes).
+		2. it's horrible for url-encoding.
+		3. it's horrible for trying to manually copy by typing.
+
+256-bit anka ids look like this:
+
+	ஒഐওଆઊসਅവஎଉखਬശயഘसചവਭଏரঊझഠடଓઐഴঠണവઞ
+	ठକநइஎਦਏஒഊটਹஜഴयભকயঙਪഉजकঝഐवઠসഏਓਡਟऋ
+	થঞठખஉધഫரਜऐફരਪਙਗഭਣഎफઇমએরଔડਉதਤஅदઘച
+
+*/
+
+import {Bytes} from "./bytes.js"
+
+const characters = [...new Set([
+	// devanagari
+	..."अआइईउऊऋएऐओऔकखगघङचछजझञटठडढणतथदधनपफबभमयरलवशषसह",
+
+	// tamil
+	..."அஆஇஈஉஊஎஏஐஒஓகஙசஜஞடணதநபமயரலவழளறன",
+
+	// bengali
+	..."অআইঈউঊএঐওকখগঘঙচছজঝঞটঠডঢণতথদধনপফবভমযরলশষসহ",
+
+	// gurmukhi
+	..."ਅਆਇਈਉਊਏਐਓਕਖਗਘਙਚਛਜਝਞਟਠਡਢਣਤਥਦਧਨਪਫਬਭਮਯਰਲਵਸਹ",
+
+	// malayalam
+	..."അആഇഈഉഊഎഏഐഒഓകഖഗഘങചഛജഝഞടഠഡഢണതഥദധനപഫബഭമയരലവശസഹളഴറ",
+
+	// gujarati
+	..."અઆઇઈઉઊએઐઓકખગઘઙચછજઝઞટઠડઢણતથદધનપફબભમયરલવશષસહ",
+
+	// odia
+	..."ଅଆଇଈଉଊଏଐଓଔକଖଗଘଙଚଛଜଝଞଟଠଡଢଣତଥଦଧନପଫବଭମଯରଲଶଷସହ",
+])]
+
+export const Anka = Object.freeze({
+
+	string(bytes: Uint8Array) {
+		return [...bytes]
+			.map(int => characters.at(int))
+			.join("")
+	},
+
+	bytes(code: string) {
+		return new Uint8Array([...code].map(char => {
+			const index = characters.indexOf(char)
+			if (index === -1)
+				throw new Error(`invalid anka character "${char}"`)
+			return index
+		}))
+	},
+
+	random(count = 32) {
+		return this.string(Bytes.random(count))
+	},
+})
+

package/s/data/barname/badge.ts

@@ -0,0 +1,78 @@
+
+import {Hex} from "../hex.js"
+import {Base58} from "../base58.js"
+import {Barname} from "./barname.js"
+
+/**
+ * Badge is a human-friendly presentation format for arbitrary binary data.
+ *  - looks like "nomluc_rigpem.tg2bjNkjMh1H6M2b2EhD5V4x6XAqx9wyWddsBt"
+ *  - the first bytes are shown in barname format
+ *  - the rest of the data is in base58
+ *  - designed to be a nice way to present 256-bit passport thumbprints
+ *  - can be used for data of different lengths
+ *  - preview size can be customized as 'leadCount', which defaults to 4
+ */
+export class Badge {
+	static readonly separator = "."
+	static readonly defaultLeadCount = 4
+
+	readonly hex: string
+	readonly string: string
+	readonly preview: string
+
+	constructor(
+			public readonly bytes: Uint8Array,
+			public readonly leadCount = Badge.defaultLeadCount,
+		) {
+
+		if (leadCount < 1)
+			throw new Error(`badge leadCount must be greater than 0 (was ${leadCount})`)
+
+		this.hex = Hex.string(this.bytes)
+		this.preview = Barname.string(this.bytes.slice(0, leadCount))
+
+		this.string = (bytes.length > leadCount)
+			? `${this.preview}.${Base58.string(this.bytes.slice(leadCount))}`
+			: this.preview
+	}
+
+	static parse(badge: string) {
+		const [barname, b58] = badge.split(Badge.separator)
+
+		// badge has a base58 component
+		if (b58) {
+			const appetizer = Barname.bytes(barname)
+			const entree = Base58.bytes(b58)
+			const bytes = new Uint8Array([...appetizer, ...entree])
+			return new this(bytes, appetizer.length)
+		}
+
+		// badge is just a barname (no base58 part)
+		else {
+			const bytes = Barname.bytes(barname)
+			return new this(bytes, bytes.length)
+		}
+	}
+
+	static fromHex(hex: string, leadCount = this.defaultLeadCount) {
+		const bytes = Hex.bytes(hex)
+		return new this(bytes, leadCount)
+	}
+
+	static string(bytes: Uint8Array, leadCount = this.defaultLeadCount) {
+		return new this(bytes, leadCount).string
+	}
+
+	static bytes(badge: string) {
+		return this.parse(badge)
+	}
+
+	static hex(badge: string) {
+		return this.parse(badge).hex
+	}
+
+	toString() {
+		return this.string
+	}
+}
+

package/s/data/barname/barname.ts

@@ -0,0 +1,62 @@
+
+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 const Barname = {
+	random(byteCount: number) {
+		return this.string(Bytes.random(byteCount))
+	},
+
+	string(bytes: Uint8Array, options?: {wordsPerGroup?: number}) {
+		const groupSize = options?.wordsPerGroup ?? defaultWordsPerGroup
+
+		const words: string[] = []
+		let currentWord: string[] = []
+
+		bytes.forEach((byte, index) => {
+			const source = ((index % 2) === 0) ? prefixes : suffixes
+			currentWord.push(source[byte]!)
+			if (currentWord.length === 2) {
+				words.push(currentWord.join(""))
+				currentWord = []
+			}
+		})
+
+		if (currentWord.length)
+			words.push(currentWord.join(""))
+
+		const grouped = []
+		for (let i = 0; i < words.length; i += groupSize)
+			grouped.push(words.slice(i, i + groupSize).join(wordSeparator))
+
+		return grouped.join(groupSeparator)
+	},
+
+	bytes(string: string) {
+		const letters = string
+			.toLowerCase()
+			.replace(/[^a-z]/g, "") // strip everything except letters
+
+		const count = letters.length / 3
+		if ((count % 1) !== 0)
+			throw new Error(`invalid triplet count, ${letters.length} does not divide into triplets`)
+
+		const triplets: string[] = []
+		for (let i = 0; i < letters.length; i += 3)
+			triplets.push(letters.slice(i, i + 3))
+
+		return new Uint8Array(triplets.map((triplet, index) => {
+			const source = ((index % 2) === 0) ? prefixes : suffixes
+			const number = source.findIndex(t => t === triplet)
+			if (number === -1)
+				throw new Error(`unknown triplet ${triplet}`)
+			return number
+		}))
+	},
+}
+

package/s/data/barname/demo.ts

@@ -0,0 +1,49 @@
+
+import {Hex} from "../hex.js"
+import {Badge} from "./badge.js"
+import {Bytes} from "../bytes.js"
+import {Barname} from "./barname.js"
+
+for (const _ of Array(2)) {
+	const string = Barname.random(34)
+	const bytes = Barname.bytes(string)
+	const string2 = Barname.string(bytes)
+	console.log(string.replaceAll(" ", "\n"))
+	if (string !== string2)
+		throw new Error("barname fails equality check")
+	console.log("")
+}
+
+for (const _ of Array(10)) {
+	const bytes = Bytes.random(32)
+	const badge = new Badge(bytes)
+	const bytes2 = badge.bytes
+	console.log(badge.string)
+	if (Hex.string(bytes) !== Hex.string(bytes2))
+		throw new Error("badge fails equality check")
+}
+
+{
+	console.log("")
+	const alpha = `
+		dacsyd_labdun_fipsub_bonmel
+		fitlys_rovbud_sipnel_sonryx
+		sitrem_lasdyr_dovpun_nibwep
+		tippet_mapnub_ticnet_famset
+		wanteg
+	`
+	const bravo = `
+		dacsyd-labdun-fipsub-bonmel;
+		[fitlys rovbud sipnel sonryx]
+		sitrem/lasdyr/dovpun/nibwep
+		tippet+mapnub+ticnet+famset
+		wanteg++
+	`
+	const alphaHex = Hex.string(Barname.bytes(alpha))
+	const bravoHex = Hex.string(Barname.bytes(bravo))
+	if (alphaHex.length === 68 && alphaHex === bravoHex)
+		console.log("*barname parsing appears resilient to whitespace and garbage*")
+	else
+		throw new Error("barname resiliency failure")
+}
+

package/s/data/barname/index.ts

@@ -0,0 +1,4 @@
+
+export * from "./barname.js"
+export * from "./badge.js"
+

package/s/data/barname/utils/prefixes.ts

@@ -0,0 +1,20 @@
+
+export const prefixes = [
+	"doz","mar","bin","wan","sam","lit","sig","hid","fid","lis","sog","dir","wac","sab","wis","sib",
+	"rig","sol","dop","mod","fog","lid","hop","dar","dor","lor","hod","fol","rin","tog","sil","mir",
+	"hol","pas","lac","rov","liv","dal","sat","lib","tab","han","tic","pid","tor","bol","fos","dot",
+	"los","dil","for","pil","ram","tir","win","tad","bic","dif","roc","wid","bis","das","mid","lop",
+	"ril","nar","dap","mol","san","loc","nov","sit","nid","tip","sic","rop","wit","nat","pan","min",
+	"rit","pod","mot","tam","tol","sav","pos","nap","nop","som","fin","fon","ban","mor","wor","sip",
+	"ron","nor","bot","wic","soc","wat","dol","mag","pic","dav","bid","bal","tim","tas","mal","lig",
+	"siv","tag","pad","sal","div","dac","tan","sid","fab","tar","mon","ran","nis","wol","mis","pal",
+	"las","dis","map","rab","tob","rol","lat","lon","nod","nav","fig","nom","nib","pag","sop","ral",
+	"bil","had","doc","rid","moc","pac","rav","rip","fal","tod","til","tin","hap","mic","fan","pat",
+	"tac","lab","mog","sim","son","pin","lom","ric","tap","fir","has","bos","bat","poc","hac","tid",
+	"hav","sap","lin","dib","hos","dab","bit","bar","rac","par","lod","dos","bor","toc","hil","mac",
+	"tom","dig","fil","fas","mit","hob","har","mig","hin","rad","mas","hal","rag","lag","fad","top",
+	"mop","hab","nil","nos","mil","fop","fam","dat","nol","din","hat","nac","ris","fot","rib","hoc",
+	"nim","lar","fit","wal","rap","sar","nal","mos","lan","don","dan","lad","dov","riv","bac","pol",
+	"lap","tal","pit","nam","bon","ros","ton","fod","pon","sov","noc","sor","lav","mat","mip","fip",
+]
+

package/s/data/barname/utils/suffixes.ts

@@ -0,0 +1,20 @@
+
+export const suffixes = [
+	"zod","nec","bud","wes","sev","per","sut","let","ful","pen","syt","dur","wep","ser","wyl","sun",
+	"ryp","syx","dyr","nup","heb","peg","lup","dep","dys","put","lug","hec","ryt","tyv","syd","nex",
+	"lun","mep","lut","sep","pes","del","sul","ped","tem","led","tul","met","wen","byn","hex","feb",
+	"pyl","dul","het","mev","rut","tyl","wyd","tep","bes","dex","sef","wyc","bur","der","nep","pur",
+	"rys","reb","den","nut","sub","pet","rul","syn","reg","tyd","sup","sem","wyn","rec","meg","net",
+	"sec","mul","nym","tev","web","sum","mut","nyx","rex","teb","fus","hep","ben","mus","wyx","sym",
+	"sel","ruc","dec","wex","syr","wet","dyl","myn","mes","det","bet","bel","tux","tug","myr","pel",
+	"syp","ter","meb","set","dut","deg","tex","sur","fel","tud","nux","rux","ren","wyt","nub","med",
+	"lyt","dus","neb","rum","tyn","seg","lyx","pun","res","red","fun","rev","ref","mec","ted","rus",
+	"bex","leb","dux","ryn","num","pyx","ryg","ryx","fep","tyr","tus","tyc","leg","nem","fer","mer",
+	"ten","lus","nus","syl","tec","mex","pub","rym","tuc","fyl","lep","deb","ber","mug","hut","tun",
+	"byl","sud","pem","dev","lur","def","bus","bep","run","mel","pex","dyt","byt","typ","lev","myl",
+	"wed","duc","fur","fex","nul","luc","len","ner","lex","rup","ned","lec","ryd","lyd","fen","wel",
+	"nyd","hus","rel","rud","nes","hes","fet","des","ret","dun","ler","nyr","seb","hul","ryl","lud",
+	"rem","lys","fyn","wer","ryc","sug","nys","nyl","lyn","dyn","dem","lux","fed","sed","bec","mun",
+	"lyr","tes","mud","nyt","byr","sen","weg","fyr","mur","tel","rep","teg","pec","nel","nev","fes",
+]
+