@jackens/nnn 2024.2.10 → 2024.2.12

package/eq.d.ts

@@ -4,5 +4,5 @@
 export function eq(x: any, y: any): boolean;
 
 export namespace tests {
-    function eq(): void;
+    function eq(expect: import("bun:test").Expect): void;
 }

package/eq.js

@@ -45,39 +45,39 @@ export const eq = /** @return {boolean} */ (/** @type {any} */ x, /** @type {any
 }
 
 export const tests = {
-  eq: () => {
-    console.assert(eq(true, true))
-    console.assert(eq(NaN, NaN))
-    console.assert(!eq(null, undefined))
-    console.assert(eq(42, 42))
+  eq: (/** @type {import('bun:test').Expect} */ expect) => {
+    expect(eq(true, true)).toBe(true)
+    expect(eq(NaN, NaN)).toBe(true)
+    expect(eq(null, undefined)).toBe(false)
+    expect(eq(42, 42)).toBe(true)
     // eslint-disable-next-line no-new-wrappers
-    console.assert(eq(42, new Number(42)))
-    console.assert(eq(42, Number(42)))
+    expect(eq(42, new Number(42))).toBe(true)
+    expect(eq(42, Number(42))).toBe(true)
     // eslint-disable-next-line no-new-wrappers
-    console.assert(eq(new Number(42), Number(42)))
-    console.assert(!eq(42, '42'))
-    console.assert(eq('42', '42'))
+    expect(eq(new Number(42), Number(42))).toBe(true)
+    expect(eq(42, '42')).toBe(false)
+    expect(eq('42', '42')).toBe(true)
     // eslint-disable-next-line no-new-wrappers
-    console.assert(eq('42', new String('42')))
-    console.assert(eq('42', String('42')))
+    expect(eq('42', new String('42'))).toBe(true)
+    expect(eq('42', String('42'))).toBe(true)
     // eslint-disable-next-line no-new-wrappers
-    console.assert(eq(String('42'), new String('42')))
-    console.assert(eq(/42/, /42/))
-    console.assert(!eq(/42/, /42/g))
-    console.assert(eq(new Date(42), new Date(42)))
-    console.assert(!eq(new Date(), new Date(42)))
-    console.assert(eq({ j: '42', c: 42 }, { c: 42, j: '42' }))
-    console.assert(eq([42, '42'], [42, '42']))
-    console.assert(eq(new Set(['42', 42]), new Set([42, '42'])))
-    console.assert(!eq(new Set(['42', 42]), new Set([42])))
-    console.assert(!eq(new Set([42, undefined]), new Set([42])))
-    console.assert(eq(
+    expect(eq(String('42'), new String('42'))).toBe(true)
+    expect(eq(/42/, /42/)).toBe(true)
+    expect(eq(/42/, /42/g)).toBe(false)
+    expect(eq(new Date(42), new Date(42))).toBe(true)
+    expect(eq(new Date(), new Date(42))).toBe(false)
+    expect(eq({ j: '42', c: 42 }, { c: 42, j: '42' })).toBe(true)
+    expect(eq([42, '42'], [42, '42'])).toBe(true)
+    expect(eq(new Set(['42', 42]), new Set([42, '42']))).toBe(true)
+    expect(eq(new Set(['42', 42]), new Set([42]))).toBe(false)
+    expect(eq(new Set([42, undefined]), new Set([42]))).toBe(false)
+    expect(eq(
       new Map([[{ j: 42 }, { J: '42' }], [{ c: 42 }, { C: '42' }]]),
       new Map([[{ c: 42 }, { C: '42' }], [{ j: 42 }, { J: '42' }]])
-    ))
-    console.assert(!eq(
+    )).toBe(true)
+    expect(eq(
       new Map([[{ j: 42 }, { J: '42' }], [{ c: 42 }, { C: '42' }]]),
       new Map([[{ j: '42' }, { J: 42 }], [{ c: '42' }, { C: 42 }]])
-    ))
+    )).toBe(false)
   }
 }

package/escape.d.ts

@@ -14,5 +14,5 @@ export function escape(escapeMap: EscapeMap, template: TemplateStringsArray, ...
 export function escapeValues(escapeMap: EscapeMap, values: any[]): string[];
 
 export namespace tests {
-    function escape(): void;
+    function escape(expect: import("bun:test").Expect): void;
 }

package/escape.js

@@ -22,7 +22,7 @@ export const escape = (
 ) => String.raw(template, ...escapeValues(escapeMap, values))
 
 export const tests = {
-  escape: () => {
+  escape: (/** @type {import('bun:test').Expect} */ expect) => {
     // @ts-ignore
     const /** @type {EscapeMap} */ escapeMap = new Map([
       [undefined, () => 'NULL'],
@@ -46,6 +46,6 @@ export const tests = {
       FROM table_name
       WHERE column_name IN (b'1', NULL, NULL, 42, '42', '4''2', NULL, '1980-03-31 04:30:00')`
 
-    console.assert(actual === expected)
+    expect(actual).toEqual(expected)
   }
 }

package/fixTypography.d.ts

@@ -4,5 +4,5 @@
 export function fixTypography(node: Node): void;
 
 export namespace tests {
-    function fixTypography(): void;
+    function fixTypography(expect: import("bun:test").Expect): void;
 }

package/fixTypography.js

@@ -49,12 +49,12 @@ export const fixTypography = (/** @type {Node} */ node) => {
 }
 
 export const tests = {
-  fixTypography: () => {
+  fixTypography: (/** @type {import('bun:test').Expect} */ expect) => {
     const p = h('p', 'Pchnąć w tę łódź jeża lub ośm skrzyń fig (zob. https://pl.wikipedia.org/wiki/Pangram).')
 
     fixTypography(p)
 
-    console.assert(p.innerHTML ===
+    expect(p.innerHTML).toEqual(
       'Pchnąć <span style="white-space:nowrap">w </span>tę łódź jeża lub ośm skrzyń fig ' +
       '(zob. https://\u200Bpl.\u200Bwikipedia.\u200Borg/\u200Bwiki/\u200BPangram).')
   }

package/h.d.ts

@@ -6,14 +6,14 @@ export type HArgs = [string | Node, ...HArgs1[]];
 /**
  * The type of arguments of the `h` and `s` helpers.
  */
-export type HArgs1 = Record<string, any> | null | undefined | Node | string | number | [string | Node, ...HArgs1[]];
+export type HArgs1 = Partial<Record<PropertyKey, any>> | null | undefined | Node | string | number | [string | Node, ...HArgs1[]];
 
 /**
  * A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style helper for creating and modifying `HTMLElement`s (see also `s`).
  *
  * - The first argument of type `string` specifies the tag of the element to be created.
  * - The first argument of type `Node` specifies the element to be modified.
- * - All other arguments of type `Record<string, any>` are mappings of attributes and properties.
+ * - All other arguments of type `Partial<Record<PropertyKey, any>>` are mappings of attributes and properties.
  *   Keys starting with `$` specify *properties* (without the leading `$`) to be set on the element being created or modified.
  *   (Note that `$` is not a valid attribute name character.)
  *   All other keys specify *attributes* to be set by `setAttribute`.
@@ -32,7 +32,7 @@ export function h(tagOrNode: string | Node, ...args1: HArgs1[]): Node;
  *
  * - The first argument of type `string` specifies the tag of the element to be created.
  * - The first argument of type `Node` specifies the element to be modified.
- * - All other arguments of type `Record<string, any>` are mappings of attributes and properties.
+ * - All other arguments of type `Partial<Record<PropertyKey, any>>` are mappings of attributes and properties.
  *   Keys starting with `$` specify *properties* (without the leading `$`) to be set on the element being created or modified.
  *   (Note that `$` is not a valid attribute name character.)
  *   All other keys specify *attributes* to be set by `setAttributeNS`.
@@ -47,9 +47,9 @@ export function s<N extends Node>(node: N, ...args1: HArgs1[]): N;
 export function s(tagOrNode: string | Node, ...args1: HArgs1[]): Node;
 
 export const tests: {
-    h: () => void;
-    'h: innerText vs items': () => void;
-    'h: style': () => void;
-    'h: attributes vs properties': () => void;
-    'h: nested properties': () => void;
+    h: (expect: import('bun:test').Expect) => void;
+    'h: innerText vs items': (expect: import('bun:test').Expect) => void;
+    'h: style': (expect: import('bun:test').Expect) => void;
+    'h: attributes vs properties': (expect: import('bun:test').Expect) => void;
+    'h: nested properties': (expect: import('bun:test').Expect) => void;
 };

package/h.js

@@ -1,10 +1,9 @@
-import { eq } from './eq.js'
 import { is } from './is.js'
 
 /**
  * The type of arguments of the `h` and `s` helpers.
  *
- * @typedef {Record<string, any> | null | undefined | Node | string | number | HArgs} HArgs1
+ * @typedef {Partial<Record<PropertyKey, any>> | null | undefined | Node | string | number | HArgs} HArgs1
  */
 
 /**
@@ -113,7 +112,7 @@ const _h = (/** @type {string?=} */ namespaceURI) => {
  *
  * - The first argument of type `string` specifies the tag of the element to be created.
  * - The first argument of type `Node` specifies the element to be modified.
- * - All other arguments of type `Record<string, any>` are mappings of attributes and properties.
+ * - All other arguments of type `Partial<Record<PropertyKey, any>>` are mappings of attributes and properties.
  *   Keys starting with `$` specify *properties* (without the leading `$`) to be set on the element being created or modified.
  *   (Note that `$` is not a valid attribute name character.)
  *   All other keys specify *attributes* to be set by `setAttribute`.
@@ -130,7 +129,7 @@ export const h = _h()
  *
  * - The first argument of type `string` specifies the tag of the element to be created.
  * - The first argument of type `Node` specifies the element to be modified.
- * - All other arguments of type `Record<string, any>` are mappings of attributes and properties.
+ * - All other arguments of type `Partial<Record<PropertyKey, any>>` are mappings of attributes and properties.
  *   Keys starting with `$` specify *properties* (without the leading `$`) to be set on the element being created or modified.
  *   (Note that `$` is not a valid attribute name character.)
  *   All other keys specify *attributes* to be set by `setAttributeNS`.
@@ -143,72 +142,72 @@ export const h = _h()
 export const s = _h('http://www.w3.org/2000/svg')
 
 export const tests = {
-  h: () => {
+  h: (/** @type {import('bun:test').Expect} */ expect) => {
     const b = h('b')
 
-    console.assert(b.outerHTML === '<b></b>')
+    expect(b.outerHTML).toEqual('<b></b>')
 
     const i = h('i', 'text')
 
     h(b, i)
 
-    console.assert(i.outerHTML === '<i>text</i>')
-    console.assert(b.outerHTML === '<b><i>text</i></b>')
+    expect(i.outerHTML).toEqual('<i>text</i>')
+    expect(b.outerHTML).toEqual('<b><i>text</i></b>')
 
     h(i, { $className: 'some class' })
 
-    console.assert(i.outerHTML === '<i class="some class">text</i>')
-    console.assert(b.outerHTML === '<b><i class="some class">text</i></b>')
+    expect(i.outerHTML).toEqual('<i class="some class">text</i>')
+    expect(b.outerHTML).toEqual('<b><i class="some class">text</i></b>')
   },
 
-  'h: innerText vs items': () => {
-    console.assert(h('span', 'text').outerHTML === '<span>text</span>')
-    console.assert(h('span', { $innerText: 'text' }).outerHTML === '<span>text</span>')
+  'h: innerText vs items': (/** @type {import('bun:test').Expect} */ expect) => {
+    expect(h('span', 'text').outerHTML).toEqual('<span>text</span>')
+    expect(h('span', { $innerText: 'text' }).outerHTML).toEqual('<span>text</span>')
   },
 
-  'h: style': () => {
-    console.assert(h('div', { style: 'margin:0;padding:0' }).outerHTML ===
-      '<div style="margin:0;padding:0"></div>')
-    console.assert(h('div', { $style: 'margin:0;padding:0' }).outerHTML ===
-      '<div style="margin: 0px; padding: 0px;"></div>')
-    console.assert(h('div', { $style: { margin: 0, padding: 0 } }).outerHTML ===
-      '<div style="margin: 0px; padding: 0px;"></div>')
+  'h: style': (/** @type {import('bun:test').Expect} */ expect) => {
+    expect(h('div', { style: 'margin:0;padding:0' }).outerHTML)
+      .toEqual('<div style="margin:0;padding:0"></div>')
+    expect(h('div', { $style: 'margin:0;padding:0' }).outerHTML)
+      .toEqual('<div style="margin: 0px; padding: 0px;"></div>')
+    expect(h('div', { $style: { margin: 0, padding: 0 } }).outerHTML)
+      .toEqual('<div style="margin: 0px; padding: 0px;"></div>')
   },
 
-  'h: attributes vs properties': () => {
+  'h: attributes vs properties': (/** @type {import('bun:test').Expect} */ expect) => {
     const input1 = h('input', { value: 42 })
     const input2 = h('input', { $value: '42' })
 
-    console.assert(input1.value === '42')
-    console.assert(input2.value === '42')
+    expect(input1.value).toEqual('42')
+    expect(input2.value).toEqual('42')
 
-    console.assert(input1.outerHTML === '<input value="42">')
-    console.assert(input2.outerHTML === '<input>')
+    expect(input1.outerHTML).toEqual('<input value="42">')
+    expect(input2.outerHTML).toEqual('<input>')
 
     const checkbox1 = h('input', { type: 'checkbox', checked: true })
     const checkbox2 = h('input', { type: 'checkbox', $checked: true })
 
-    console.assert(checkbox1.checked === true)
-    console.assert(checkbox2.checked === true)
+    expect(checkbox1.checked).toBe(true)
+    expect(checkbox2.checked).toBe(true)
 
-    console.assert(checkbox1.outerHTML === '<input type="checkbox" checked="">')
-    console.assert(checkbox2.outerHTML === '<input type="checkbox">')
+    expect(checkbox1.outerHTML).toEqual('<input type="checkbox" checked="">')
+    expect(checkbox2.outerHTML).toEqual('<input type="checkbox">')
   },
 
-  'h: nested properties': () => {
+  'h: nested properties': (/** @type {import('bun:test').Expect} */ expect) => {
     const div = h('div')
 
     // @ts-ignore
-    console.assert(div.key === undefined)
+    expect(div.key).toBeUndefined()
 
     h(div, { $key: { one: 1 } })
 
     // @ts-ignore
-    console.assert(eq(div.key, { one: 1 }))
+    expect(div.key).toEqual({ one: 1 })
 
     h(div, { $key: { two: 2 } })
 
     // @ts-ignore
-    console.assert(eq(div.key, { one: 1, two: 2 }))
+    expect(div.key).toEqual({ one: 1, two: 2 })
   }
 }

package/has.d.ts

@@ -4,6 +4,6 @@
 export function has(key: any, ref: any): boolean;
 
 export const tests: {
-    has: () => void;
-    'has: null': () => void;
+    has: (expect: import('bun:test').Expect) => void;
+    'has: null': (expect: import('bun:test').Expect) => void;
 };

package/has.js

@@ -7,34 +7,34 @@ export const has = (/** @type {any} */ key, /** @type {any} */ ref) =>
   (is(String, key) || is(Number, key) || is(Symbol, key)) && Object.hasOwnProperty.call(ref ?? Object, key)
 
 export const tests = {
-  has: () => {
+  has: (/** @type {import('bun:test').Expect} */ expect) => {
     const obj = { key: 'K', null: 'N' }
 
-    console.assert('key' in obj)
-    console.assert(has('key', obj))
+    expect('key' in obj).toBe(true)
+    expect(has('key', obj)).toBe(true)
 
-    console.assert('null' in obj)
-    console.assert(has('null', obj))
+    expect('null' in obj).toBe(true)
+    expect(has('null', obj)).toBe(true)
 
     // @ts-ignore
-    console.assert(null in obj)
-    console.assert(!has(null, obj))
+    expect(null in obj).toBe(true)
+    expect(has(null, obj)).toBe(false)
 
-    console.assert('toString' in obj)
-    console.assert(!has('toString', obj))
+    expect('toString' in obj).toBe(true)
+    expect(has('toString', obj)).toBe(false)
   },
 
-  'has: null': () => {
+  'has: null': (/** @type {import('bun:test').Expect} */ expect) => {
     let typeError
 
     try {
       // @ts-ignore
-      console.assert('key' in null)
+      'key' in null
     } catch (error) {
       typeError = error
     }
 
-    console.assert(typeError instanceof TypeError) // Cannot use 'in' operator to search for 'key' in null
-    console.assert(!has('key', null))
+    expect(typeError instanceof TypeError) // Cannot use 'in' operator to search for 'key' in null
+    expect(has('key', null)).toBe(false)
   }
 }

package/is.d.ts

@@ -12,6 +12,6 @@ export const is: {
 };
 
 export const tests: {
-    is: () => void;
-    'is: toString.call': () => void;
+    is: (expect: import('bun:test').Expect) => void;
+    'is: toString.call': (expect: import('bun:test').Expect) => void;
 };

package/is.js

@@ -18,48 +18,48 @@
 export const is = (/** @type {T} */ type, /** @type {any} */ arg) => arg?.constructor === type
 
 export const tests = {
-  is: () => {
-    console.assert(is(Number, 42))
-    console.assert(is(Number, Number(42)))
+  is: (/** @type {import('bun:test').Expect} */ expect) => {
+    expect(is(Number, 42)).toBe(true)
+    expect(is(Number, Number(42))).toBe(true)
     // eslint-disable-next-line no-new-wrappers
-    console.assert(is(Number, new Number(42)))
-    console.assert(is(Number, NaN))
-    console.assert(is(String, '42'))
-    console.assert(is(String, String('42')))
+    expect(is(Number, new Number(42))).toBe(true)
+    expect(is(Number, NaN)).toBe(true)
+    expect(is(String, '42')).toBe(true)
+    expect(is(String, String('42'))).toBe(true)
     // eslint-disable-next-line no-new-wrappers
-    console.assert(is(String, new String('42')))
-    console.assert(is(Symbol, Symbol('42')))
-    console.assert(is(Symbol, Object(Symbol('42'))))
-    console.assert(is(undefined, undefined))
-    console.assert(is(undefined, null))
-    console.assert(is(Object, {}))
-    console.assert(is(Array, []))
-    console.assert(is(RegExp, /42/))
-    console.assert(is(Date, new Date(42)))
-    console.assert(is(Set, new Set(['42', 42])))
-    console.assert(is(Map, new Map([[{ j: 42 }, { J: '42' }], [{ c: 42 }, { C: '42' }]])))
+    expect(is(String, new String('42'))).toBe(true)
+    expect(is(Symbol, Symbol('42'))).toBe(true)
+    expect(is(Symbol, Object(Symbol('42')))).toBe(true)
+    expect(is(undefined, undefined)).toBe(true)
+    expect(is(undefined, null)).toBe(true)
+    expect(is(Object, {})).toBe(true)
+    expect(is(Array, [])).toBe(true)
+    expect(is(RegExp, /42/)).toBe(true)
+    expect(is(Date, new Date(42))).toBe(true)
+    expect(is(Set, new Set(['42', 42]))).toBe(true)
+    expect(is(Map, new Map([[{ j: 42 }, { J: '42' }], [{ c: 42 }, { C: '42' }]]))).toBe(true)
   },
 
-  'is: toString.call': () => {
+  'is: toString.call': (/** @type {import('bun:test').Expect} */ expect) => {
     const iz = (/** @type {any} */ type, /** @type {any} */ arg) => ({}).toString.call(arg).slice(8, -1) === type?.name
 
     class FooBar { }
 
-    console.assert(is(FooBar, new FooBar()))
-    console.assert(!iz(FooBar, new FooBar()))
+    expect(is(FooBar, new FooBar())).toBe(true)
+    expect(iz(FooBar, new FooBar())).toBe(false)
 
-    console.assert(!is(Object, new FooBar()))
-    console.assert(iz(Object, new FooBar()))
+    expect(is(Object, new FooBar())).toBe(false)
+    expect(iz(Object, new FooBar())).toBe(true)
 
     const fakeFooBar = {}
 
     // @ts-ignore
     fakeFooBar[Symbol.toStringTag] = FooBar.name
 
-    console.assert(!is(FooBar, fakeFooBar))
-    console.assert(iz(FooBar, fakeFooBar))
+    expect(is(FooBar, fakeFooBar)).toBe(false)
+    expect(iz(FooBar, fakeFooBar)).toBe(true)
 
-    console.assert(is(Object, fakeFooBar))
-    console.assert(!iz(Object, fakeFooBar))
+    expect(is(Object, fakeFooBar)).toBe(true)
+    expect(iz(Object, fakeFooBar)).toBe(false)
   }
 }

package/jcss.d.ts

@@ -8,7 +8,7 @@ export type JcssNode = {
 /**
  * The type of arguments of the `jcss` helper.
  */
-export type JcssRoot = Partial<Record<string, JcssNode>>;
+export type JcssRoot = Partial<Record<PropertyKey, JcssNode>>;
 
 /**
  * A simple CSS-in-JS helper.
@@ -24,10 +24,10 @@ export type JcssRoot = Partial<Record<string, JcssNode>>;
 export function jcss(root: JcssRoot, splitter?: string): string;
 
 export const tests: {
-    'jcss: #1': () => void;
-    'jcss: #2': () => void;
-    'jcss: #3': () => void;
-    'jcss: #4': () => void;
-    'jcss: #5': () => void;
-    'jcss: #6': () => void;
+    'jcss: #1': (expect: import('bun:test').Expect) => void;
+    'jcss: #2': (expect: import('bun:test').Expect) => void;
+    'jcss: #3': (expect: import('bun:test').Expect) => void;
+    'jcss: #4': (expect: import('bun:test').Expect) => void;
+    'jcss: #5': (expect: import('bun:test').Expect) => void;
+    'jcss: #6': (expect: import('bun:test').Expect) => void;
 };

package/jcss.js

@@ -11,7 +11,7 @@ import { is } from './is.js'
 /**
  * The type of arguments of the `jcss` helper.
  *
- * @typedef {Partial<Record<string, JcssNode>>} JcssRoot
+ * @typedef {Partial<Record<PropertyKey, JcssNode>>} JcssRoot
  */
 
 const _jcss = (
@@ -97,7 +97,7 @@ export const jcss = (/** @type {JcssRoot} */ root, splitter = '$$') => {
 }
 
 export const tests = {
-  'jcss: #1': () => {
+  'jcss: #1': (/** @type {import('bun:test').Expect} */ expect) => {
     const actual = jcss({
       a: {
         color: 'red',
@@ -120,10 +120,10 @@ export const tests = {
       padding:1
     }`.replace(/\n\s*/g, '')
 
-    console.assert(actual === expected)
+    expect(actual).toEqual(expected)
   },
 
-  'jcss: #2': () => {
+  'jcss: #2': (/** @type {import('bun:test').Expect} */ expect) => {
     const actual = jcss({
       a: {
         '.b': {
@@ -148,10 +148,10 @@ export const tests = {
       padding:1
     }`.replace(/\n\s*/g, '')
 
-    console.assert(actual === expected)
+    expect(actual).toEqual(expected)
   },
 
-  'jcss: #3': () => {
+  'jcss: #3': (/** @type {import('bun:test').Expect} */ expect) => {
     const actual = jcss({
       '@font-face$$1': {
         fontFamily: 'Jackens',
@@ -223,10 +223,10 @@ export const tests = {
       }
     }`.replace(/\n\s*/g, '')
 
-    console.assert(actual === expected)
+    expect(actual).toEqual(expected)
   },
 
-  'jcss: #4': () => {
+  'jcss: #4': (/** @type {import('bun:test').Expect} */ expect) => {
     const actual = jcss({
       a: {
         '.b,.c': {
@@ -246,10 +246,10 @@ export const tests = {
       margin:2
     }`.replace(/\n\s*/g, '')
 
-    console.assert(actual === expected)
+    expect(actual).toEqual(expected)
   },
 
-  'jcss: #5': () => {
+  'jcss: #5': (/** @type {import('bun:test').Expect} */ expect) => {
     const actual = jcss({
       '.b,.c': {
         margin: 1,
@@ -267,10 +267,10 @@ export const tests = {
       margin:2
     }`.replace(/\n\s*/g, '')
 
-    console.assert(actual === expected)
+    expect(actual).toEqual(expected)
   },
 
-  'jcss: #6': () => {
+  'jcss: #6': (/** @type {import('bun:test').Expect} */ expect) => {
     const actual = jcss({
       '.a,.b': {
         margin: 1,
@@ -288,6 +288,6 @@ export const tests = {
       margin:2
     }`.replace(/\n\s*/g, '')
 
-    console.assert(actual === expected)
+    expect(actual).toEqual(expected)
   }
 }

package/jsOnParse.d.ts

@@ -13,8 +13,8 @@
  * handlers['«handlerName»'](...«params»)
  * ```
  */
-export function jsOnParse(handlers: Partial<Record<string, Function>>, text: string): any;
+export function jsOnParse(handlers: Partial<Record<PropertyKey, Function>>, text: string): any;
 
 export namespace tests {
-    function jsOnParse(): void;
+    function jsOnParse(expect: import("bun:test").Expect): void;
 }

package/jsOnParse.js

@@ -1,4 +1,3 @@
-import { eq } from './eq.js'
 import { has } from './has.js'
 import { is } from './is.js'
 
@@ -18,7 +17,7 @@ import { is } from './is.js'
  * ```
  */
 export const jsOnParse = (
-  /** @type {Partial<Record<string, Function>>} */ handlers,
+  /** @type {Partial<Record<PropertyKey, Function>>} */ handlers,
   /** @type {string}                   */ text
 ) => JSON.parse(text, (key, value) => {
   if (is(Object, value)) {
@@ -41,7 +40,7 @@ export const jsOnParse = (
 })
 
 export const tests = {
-  jsOnParse: () => {
+  jsOnParse: (/** @type {import('bun:test').Expect} */ expect) => {
     const handlers = {
       $hello: (/** @type {string} */ name) => `Hello ${name}!`,
       $foo: () => 'bar'
@@ -81,6 +80,6 @@ export const tests = {
       }
     ]
 
-    console.assert(eq(actual, expected))
+    expect(actual).toEqual(expected)
   }
 }

package/locale.d.ts

@@ -1,8 +1,8 @@
 /**
  * Language translations helper.
  */
-export function locale(map: Partial<Record<string, Partial<Record<string, string>>>>, defaultVersion: string): (text: string, version?: string) => string;
+export function locale(map: Partial<Record<PropertyKey, Partial<Record<PropertyKey, string>>>>, defaultVersion: string): (text: string, version?: string) => string;
 
 export namespace tests {
-    function locale(): void;
+    function locale(expect: import("bun:test").Expect): void;
 }