@jackens/nnn 2024.2.11 → 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

@@ -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,4 +1,3 @@
-import { eq } from './eq.js'
 import { is } from './is.js'
 
 /**
@@ -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

@@ -24,10 +24,10 @@ export type JcssRoot = Partial<Record<PropertyKey, 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

@@ -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

@@ -16,5 +16,5 @@
 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'
 
@@ -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

@@ -4,5 +4,5 @@
 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;
 }

package/locale.js

@@ -17,23 +17,23 @@ export const locale = (
 }
 
 export const tests = {
-  locale: () => {
+  locale: (/** @type {import('bun:test').Expect} */ expect) => {
     const _ = locale({
       default: { Password: 'Hasło' },
       button: { Login: 'Zaloguj' }
     }, 'default')
 
-    console.assert(_('Login') === 'Login')
-    console.assert(_('Password') === 'Hasło')
+    expect(_('Login')).toEqual('Login')
+    expect(_('Password')).toEqual('Hasło')
 
-    console.assert(_('Undefined text') === 'Undefined text')
+    expect(_('Undefined text')).toEqual('Undefined text')
 
-    console.assert(_('Login', 'button') === 'Zaloguj')
+    expect(_('Login', 'button')).toEqual('Zaloguj')
 
-    console.assert(_('Password', 'undefined_version') === 'Hasło')
-    console.assert(_('Undefined text', 'undefined_version') === 'Undefined text')
+    expect(_('Password', 'undefined_version')).toEqual('Hasło')
+    expect(_('Undefined text', 'undefined_version')).toEqual('Undefined text')
 
-    console.assert(_('toString') === 'toString')
-    console.assert(_('toString', 'undefined_version') === 'toString')
+    expect(_('toString')).toEqual('toString')
+    expect(_('toString', 'undefined_version')).toEqual('toString')
   }
 }

package/nanolightJs.d.ts

@@ -4,5 +4,5 @@
 export const nanolightJs: (code?: string | undefined) => import("./h.js").HArgs1[];
 
 export namespace tests {
-    function nanolightJs(): void;
+    function nanolightJs(expect: import("bun:test").Expect): void;
 }

package/nanolightJs.js

@@ -20,10 +20,10 @@ export const nanolightJs = nanolight.bind(0,
 )
 
 export const tests = {
-  nanolightJs: () => {
+  nanolightJs: (/** @type {import('bun:test').Expect} */ expect) => {
     const codeJs = 'const answerToLifeTheUniverseAndEverything = 42'
 
-    console.assert(h('pre', ['code', ...nanolightJs(codeJs)]).outerHTML ===
+    expect(h('pre', ['code', ...nanolightJs(codeJs)]).outerHTML).toEqual(
       '<pre><code><span class="keyword">const</span> <span class="literal">answerToLifeTheUniverseAndEverything</span> <span class="operator">=</span> <span class="number">42</span></code></pre>')
   }
 }

package/nnn.d.ts

@@ -11,9 +11,11 @@ import { jsOnParse } from './jsOnParse.js';
 import { locale } from './locale.js';
 import { nanolight } from './nanolight.js';
 import { nanolightJs } from './nanolightJs.js';
+import { omit } from './pick.js';
+import { pick } from './pick.js';
 import { plUral } from './plUral.js';
 import { pro } from './pro.js';
 import { refsInfo } from './refsInfo.js';
 import { s } from './h.js';
 import { uuid1 } from './uuid1.js';
-export { chartable, eq, escape, escapeValues, fixTypography, h, has, is, jcss, jsOnParse, locale, nanolight, nanolightJs, plUral, pro, refsInfo, s, uuid1 };
+export { chartable, eq, escape, escapeValues, fixTypography, h, has, is, jcss, jsOnParse, locale, nanolight, nanolightJs, omit, pick, plUral, pro, refsInfo, s, uuid1 };

package/nnn.js

@@ -10,6 +10,7 @@ import { jsOnParse } from './jsOnParse.js'
 import { locale } from './locale.js'
 import { nanolight } from './nanolight.js'
 import { nanolightJs } from './nanolightJs.js'
+import { omit, pick } from './pick.js'
 import { plUral } from './plUral.js'
 import { pro } from './pro.js'
 import { refsInfo } from './refsInfo.js'
@@ -18,7 +19,8 @@ import { uuid1 } from './uuid1.js'
 export {
   chartable,
   eq,
-  escape, escapeValues,
+  escape,
+  escapeValues,
   fixTypography,
   h,
   has,
@@ -28,6 +30,8 @@ export {
   locale,
   nanolight,
   nanolightJs,
+  omit,
+  pick,
   plUral,
   pro,
   refsInfo,

package/package.json

@@ -40,5 +40,5 @@
   "types": "nnn.d.ts",
   "name": "@jackens/nnn",
   "type": "module",
-  "version": "2024.2.11"
+  "version": "2024.2.12"
 }