@jackens/nnn 2024.4.15 → 2024.7.9

package/nnn.d.ts

@@ -167,12 +167,12 @@ export declare const nanolightJs: (code: string) => HArgs1[];
 /**
  * A helper that implements TypeScript’s `Pick` utility type.
  */
-export declare const pick: <T extends Partial<Record<PropertyKey, unknown>>, K extends (keyof T)[]>(obj: Partial<Record<PropertyKey, unknown>>, keys: Partial<Array<unknown>>) => Pick<T, K[number]>;
+export declare const pick: <T extends Partial<Record<PropertyKey, unknown>>, K extends Array<keyof T>>(obj: Partial<Record<PropertyKey, unknown>>, keys: Partial<Array<unknown>>) => Pick<T, K[number]>;
 
 /**
  * A helper that implements TypeScript’s `Omit` utility type.
  */
-export declare const omit: <T extends Partial<Record<PropertyKey, unknown>>, K extends (keyof T)[]>(obj: Partial<Record<PropertyKey, unknown>>, keys: Partial<Array<unknown>>) => Omit<T, K[number]>;
+export declare const omit: <T extends Partial<Record<PropertyKey, unknown>>, K extends Array<keyof T>>(obj: Partial<Record<PropertyKey, unknown>>, keys: Partial<Array<unknown>>) => Omit<T, K[number]>;
 
 /**
  * A helper for choosing the correct singular and plural.

package/package.json

@@ -1,14 +1,13 @@
 {
   "author": "Jackens",
   "description": "Jackens’ JavaScript helpers.",
-  "homepage": "https://jackens.github.io/nnn/doc/",
+  "homepage": "https://jackens.github.io/nnn/",
   "keywords": [
     "CSS-in-JS",
     "CSV",
     "csvParse",
     "DOM",
     "escape",
-    "Gantt",
     "h",
     "has",
     "highlight",
@@ -25,7 +24,6 @@
     "nnn",
     "omit",
     "pick",
-    "RWD",
     "SVG",
     "translation",
     "typography",
@@ -38,5 +36,5 @@
   "types": "nnn.d.ts",
   "name": "@jackens/nnn",
   "type": "module",
-  "version": "2024.4.15"
+  "version": "2024.7.9"
 }

package/readme.md

@@ -2,7 +2,7 @@
 
 Jackens’ JavaScript helpers.
 
-<sub>Version: <code class="version">2024.4.15</code></sub>
+<sub>Version: <code class="version">2024.7.9</code></sub>
 
 ## Installation
 
@@ -18,18 +18,22 @@ npm i @jackens/nnn
 
 ## Usage
 
-Bun (or Node.js):
-
 ```js
 import { «something» } from '@jackens/nnn'
 ```
 
-The browser (or Bun or Node.js):
+or:
 
 ```js
 import { «something» } from './node_modules/@jackens/nnn/nnn.js'
 ```
 
+or:
+
+```js
+import { «something» } from 'https://unpkg.com/@jackens/nnn@2024.7.9/nnn.js'
+```
+
 ## Exports
 
 - `EscapeMap`: The type of arguments of the `escapeValues` and `escape` helpers.
@@ -132,13 +136,13 @@ yyy",zzz
  42 , "42" , 17
 
 `
-expect(csvParse(text, { header: false })).toStrictEqual([
+expect(csvParse(text, { header: false })).to.deep.equal([
   ['aaa\n"aaa"\naaa', 'bbb', 'ccc,ccc'],
   ['xxx,xxx', 'yyy\nyyy', 'zzz'],
   [' 42 ', '42', ' 17']
 ])
 
-expect(csvParse(text)).toStrictEqual([{
+expect(csvParse(text)).to.deep.equal([{
   'aaa\n"aaa"\naaa': 'xxx,xxx',
   bbb: 'yyy\nyyy',
   'ccc,ccc': 'zzz'
@@ -162,13 +166,13 @@ A generic helper for escaping `values` by given `escapeMap` (in *TemplateStrings
 #### Usage Examples
 
 ```js
-const escapeMap: EscapeMap = new Map([
+const /** @type {import('../dist/nnn.js').EscapeMap} */ escapeMap = new Map([
   [undefined, () => 'NULL'],
-  [Array, (values: Partial<Array<unknown>>) => escapeValues(escapeMap, values).join(', ')],
-  [Boolean, (value: boolean) => `b'${+value}'`],
-  [Date, (value: Date) => `'${value.toISOString().replace(/^(.+)T(.+)\..*$/, '$1 $2')}'`],
-  [Number, (value: number) => `${value}`],
-  [String, (value: string) => `'${value.replace(/'/g, "''")}'`]
+  [Array, (/** @type {Partial<Array<unknown>>} */ values) => escapeValues(escapeMap, values).join(', ')],
+  [Boolean, (/** @type {boolean} */ value) => `b'${+value}'`],
+  [Date, (/** @type {Date} */ value) => `'${value.toISOString().replace(/^(.+)T(.+)\..*$/, '$1 $2')}'`],
+  [Number, (/** @type {number} */ value) => `${value}`],
+  [String, (/** @type {string} */ value) => `'${value.replace(/'/g, "''")}'`]
 ])
 
 const sql = escape.bind(null, escapeMap)
@@ -183,7 +187,7 @@ const expected = `
   FROM table_name
   WHERE column_name IN (b'1', NULL, NULL, 42, '42', '4''2', NULL, '1980-03-31 04:30:00')`
 
-expect(actual).toStrictEqual(expected)
+expect(actual).to.deep.equal(expected)
 ```
 
 ### escapeValues
@@ -211,7 +215,7 @@ const p = h('p', 'Pchnąć w tę łódź jeża lub ośm skrzyń fig (zob. https:
 
 fixTypography(p)
 
-expect(p.innerHTML).toStrictEqual(
+expect(p.innerHTML).to.deep.equal(
   'Pchnąć <span style="white-space:nowrap">w </span>tę łódź jeża lub ośm skrzyń fig ' +
   '(zob. https://\u200Bpl.\u200Bwikipedia.\u200Borg/\u200Bwiki/\u200BPangram).')
 ```
@@ -247,67 +251,67 @@ A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style help
 ```js
 const b = h('b')
 
-expect(b.outerHTML).toStrictEqual('<b></b>')
+expect(b.outerHTML).to.deep.equal('<b></b>')
 
 const i = h('i', 'text')
 
 h(b, i)
 
-expect(i.outerHTML).toStrictEqual('<i>text</i>')
-expect(b.outerHTML).toStrictEqual('<b><i>text</i></b>')
+expect(i.outerHTML).to.deep.equal('<i>text</i>')
+expect(b.outerHTML).to.deep.equal('<b><i>text</i></b>')
 
 h(i, { $className: 'some class' })
 
-expect(i.outerHTML).toStrictEqual('<i class="some class">text</i>')
-expect(b.outerHTML).toStrictEqual('<b><i class="some class">text</i></b>')
+expect(i.outerHTML).to.deep.equal('<i class="some class">text</i>')
+expect(b.outerHTML).to.deep.equal('<b><i class="some class">text</i></b>')
 ```
 
 ```js
-expect(h('span', 'text').outerHTML).toStrictEqual('<span>text</span>')
-expect(h('span', { $innerText: 'text' }).outerHTML).toStrictEqual('<span>text</span>')
+expect(h('span', 'text').outerHTML).to.deep.equal('<span>text</span>')
+expect(h('span', { $innerText: 'text' }).outerHTML).to.deep.equal('<span>text</span>')
 ```
 
 ```js
 expect(h('div', { style: 'margin:0;padding:0' }).outerHTML)
-  .toStrictEqual('<div style="margin:0;padding:0"></div>')
+  .to.deep.equal('<div style="margin:0;padding:0"></div>')
 expect(h('div', { $style: 'margin:0;padding:0' }).outerHTML)
-  .toStrictEqual('<div style="margin: 0px; padding: 0px;"></div>')
+  .to.deep.equal('<div style="margin: 0px; padding: 0px;"></div>')
 expect(h('div', { $style: { margin: 0, padding: 0 } }).outerHTML)
-  .toStrictEqual('<div style="margin: 0px; padding: 0px;"></div>')
+  .to.deep.equal('<div style="margin: 0px; padding: 0px;"></div>')
 ```
 
 ```js
 const input1 = h('input', { value: 42 })
 const input2 = h('input', { $value: '42' })
 
-expect(input1.value).toStrictEqual('42')
-expect(input2.value).toStrictEqual('42')
+expect(input1.value).to.deep.equal('42')
+expect(input2.value).to.deep.equal('42')
 
-expect(input1.outerHTML).toStrictEqual('<input value="42">')
-expect(input2.outerHTML).toStrictEqual('<input>')
+expect(input1.outerHTML).to.deep.equal('<input value="42">')
+expect(input2.outerHTML).to.deep.equal('<input>')
 
 const checkbox1 = h('input', { type: 'checkbox', checked: true })
 const checkbox2 = h('input', { type: 'checkbox', $checked: true })
 
-expect(checkbox1.checked).toBeTrue()
-expect(checkbox2.checked).toBeTrue()
+expect(checkbox1.checked).to.be.true
+expect(checkbox2.checked).to.be.true
 
-expect(checkbox1.outerHTML).toStrictEqual('<input type="checkbox" checked="">')
-expect(checkbox2.outerHTML).toStrictEqual('<input type="checkbox">')
+expect(checkbox1.outerHTML).to.deep.equal('<input type="checkbox" checked="">')
+expect(checkbox2.outerHTML).to.deep.equal('<input type="checkbox">')
 ```
 
 ```js
 const div = h('div')
 
-expect(div.key).toBeUndefined()
+expect(div.key).to.be.undefined
 
 h(div, { $key: { one: 1 } })
 
-expect(div.key).toStrictEqual({ one: 1 })
+expect(div.key).to.deep.equal({ one: 1 })
 
 h(div, { $key: { two: 2 } })
 
-expect(div.key).toStrictEqual({ one: 1, two: 2 })
+expect(div.key).to.deep.equal({ one: 1, two: 2 })
 ```
 
 ### has
@@ -323,17 +327,17 @@ A replacement for the `in` operator (not to be confused with the `for-in` loop)
 ```js
 const obj = { key: 'K', null: 'N' }
 
-expect('key' in obj).toBeTrue()
-expect(has('key', obj)).toBeTrue()
+expect('key' in obj).to.be.true
+expect(has('key', obj)).to.be.true
 
-expect('null' in obj).toBeTrue()
-expect(has('null', obj)).toBeTrue()
+expect('null' in obj).to.be.true
+expect(has('null', obj)).to.be.true
 
-expect(null in obj).toBeTrue()
-expect(has(null, obj)).toBeFalse()
+expect(null in obj).to.be.true
+expect(has(null, obj)).to.be.false
 
-expect('toString' in obj).toBeTrue()
-expect(has('toString', obj)).toBeFalse()
+expect('toString' in obj).to.be.true
+expect(has('toString', obj)).to.be.false
 ```
 
 ```js
@@ -346,7 +350,7 @@ try {
 }
 
 expect(typeError instanceof TypeError) // Cannot use 'in' operator to search for 'key' in null
-expect(has('key', null)).toBeFalse()
+expect(has('key', null)).to.be.false
 ```
 
 ### is
@@ -372,58 +376,61 @@ A helper that checks if the given argument is of a certain type.
 #### Usage Examples
 
 ```js
-expect(is(Number, 42)).toBeTrue()
-expect(is(Number, Number(42))).toBeTrue()
-expect(is(Number, new Number(42))).toBeTrue()
-expect(is(Number, NaN)).toBeTrue()
-expect(is(String, '42')).toBeTrue()
-expect(is(String, String('42'))).toBeTrue()
-expect(is(String, new String('42'))).toBeTrue()
-expect(is(Symbol, Symbol('42'))).toBeTrue()
-expect(is(Symbol, Object(Symbol('42')))).toBeTrue()
-expect(is(undefined, undefined)).toBeTrue()
-expect(is(undefined, null)).toBeTrue()
-expect(is(Object, {})).toBeTrue()
-expect(is(Array, [])).toBeTrue()
-expect(is(RegExp, /42/)).toBeTrue()
-expect(is(Date, new Date(42))).toBeTrue()
-expect(is(Set, new Set(['42', 42]))).toBeTrue()
-expect(is(Map, new Map([[{ j: 42 }, { J: '42' }], [{ c: 42 }, { C: '42' }]]))).toBeTrue()
+expect(is(Number, 42)).to.be.true
+expect(is(Number, Number(42))).to.be.true
+
+expect(is(Number, new Number(42))).to.be.true
+expect(is(Number, NaN)).to.be.true
+expect(is(String, '42')).to.be.true
+expect(is(String, String('42'))).to.be.true
+
+expect(is(String, new String('42'))).to.be.true
+expect(is(Symbol, Symbol('42'))).to.be.true
+expect(is(Symbol, Object(Symbol('42')))).to.be.true
+expect(is(undefined, undefined)).to.be.true
+expect(is(undefined, null)).to.be.true
+expect(is(Object, {})).to.be.true
+expect(is(Array, [])).to.be.true
+expect(is(RegExp, /42/)).to.be.true
+expect(is(Date, new Date(42))).to.be.true
+expect(is(Set, new Set(['42', 42]))).to.be.true
+expect(is(Map, new Map([[{ j: 42 }, { J: '42' }], [{ c: 42 }, { C: '42' }]]))).to.be.true
 ```
 
 ```js
-const iz = (type: unknown, arg: unknown) => ({}).toString.call(arg).slice(8, -1) === type?.name
+const iz = (/** @type {unknown} */ type, /** @type {unknown} */ arg) =>
+  ({}).toString.call(arg).slice(8, -1) === type?.name
 
 class FooBar { }
 
-expect(is(FooBar, new FooBar())).toBeTrue()
-expect(iz(FooBar, new FooBar())).toBeFalse()
+expect(is(FooBar, new FooBar())).to.be.true
+expect(iz(FooBar, new FooBar())).to.be.false
 
-expect(is(Object, new FooBar())).toBeFalse()
-expect(iz(Object, new FooBar())).toBeTrue()
+expect(is(Object, new FooBar())).to.be.false
+expect(iz(Object, new FooBar())).to.be.true
 
 const fakeFooBar = {}
 
 fakeFooBar[Symbol.toStringTag] = FooBar.name
 
-expect(is(FooBar, fakeFooBar)).toBeFalse()
-expect(iz(FooBar, fakeFooBar)).toBeTrue()
+expect(is(FooBar, fakeFooBar)).to.be.false
+expect(iz(FooBar, fakeFooBar)).to.be.true
 
-expect(is(Object, fakeFooBar)).toBeTrue()
-expect(iz(Object, fakeFooBar)).toBeFalse()
+expect(is(Object, fakeFooBar)).to.be.true
+expect(iz(Object, fakeFooBar)).to.be.false
 ```
 
 ```js
 const num = 42
 const str = '42'
 
-expect(is(Number, num)).toBeTrue()
+expect(is(Number, num)).to.be.true
 
 try {
   num.constructor = str.constructor
 } catch { /* empty */ }
 
-expect(is(Number, num)).toBeTrue()
+expect(is(Number, num)).to.be.true
 ```
 
 ### jc
@@ -467,7 +474,7 @@ a{
   padding:1
 }`.replace(/\n\s*/g, '')
 
-expect(actual).toStrictEqual(expected)
+expect(actual).to.deep.equal(expected)
 ```
 
 ```js
@@ -495,7 +502,7 @@ a.b{
   padding:1
 }`.replace(/\n\s*/g, '')
 
-expect(actual).toStrictEqual(expected)
+expect(actual).to.deep.equal(expected)
 ```
 
 ```js
@@ -570,7 +577,7 @@ div.c2{
   }
 }`.replace(/\n\s*/g, '')
 
-expect(actual).toStrictEqual(expected)
+expect(actual).to.deep.equal(expected)
 ```
 
 ```js
@@ -593,7 +600,7 @@ a.b.d,a.c.d{
   margin:2
 }`.replace(/\n\s*/g, '')
 
-expect(actual).toStrictEqual(expected)
+expect(actual).to.deep.equal(expected)
 ```
 
 ```js
@@ -614,7 +621,7 @@ const expected = `
   margin:2
 }`.replace(/\n\s*/g, '')
 
-expect(actual).toStrictEqual(expected)
+expect(actual).to.deep.equal(expected)
 ```
 
 ```js
@@ -635,7 +642,7 @@ const expected = `
   margin:2
 }`.replace(/\n\s*/g, '')
 
-expect(actual).toStrictEqual(expected)
+expect(actual).to.deep.equal(expected)
 ```
 
 ### jsOnParse
@@ -664,7 +671,7 @@ handlers['«handlerName»'](...«params»)
 
 ```js
 const handlers = {
-  $hello: (name: string) => `Hello ${name}!`,
+  $hello: (/** @type {string} */ name) => `Hello ${name}!`,
   $foo: () => 'bar'
 }
 
@@ -704,7 +711,7 @@ const expected = [
   }
 ]
 
-expect(actual).toStrictEqual(expected)
+expect(actual).to.deep.equal(expected)
 ```
 
 ### locale
@@ -725,18 +732,18 @@ const _ = locale({
   button: { Login: 'Zaloguj' }
 }, 'default')
 
-expect(_('Login')).toStrictEqual('Login')
-expect(_('Password')).toStrictEqual('Hasło')
+expect(_('Login')).to.deep.equal('Login')
+expect(_('Password')).to.deep.equal('Hasło')
 
-expect(_('Undefined text')).toStrictEqual('Undefined text')
+expect(_('Undefined text')).to.deep.equal('Undefined text')
 
-expect(_('Login', 'button')).toStrictEqual('Zaloguj')
+expect(_('Login', 'button')).to.deep.equal('Zaloguj')
 
-expect(_('Password', 'undefined_version')).toStrictEqual('Hasło')
-expect(_('Undefined text', 'undefined_version')).toStrictEqual('Undefined text')
+expect(_('Password', 'undefined_version')).to.deep.equal('Hasło')
+expect(_('Undefined text', 'undefined_version')).to.deep.equal('Undefined text')
 
-expect(_('toString')).toStrictEqual('toString')
-expect(_('toString', 'undefined_version')).toStrictEqual('toString')
+expect(_('toString')).to.deep.equal('toString')
+expect(_('toString', 'undefined_version')).to.deep.equal('toString')
 ```
 
 ### nanolight
@@ -762,7 +769,7 @@ A helper for highlighting JavaScript.
 ```js
 const codeJs = 'const answerToLifeTheUniverseAndEverything = 42'
 
-expect(nanolightJs(codeJs)).toStrictEqual([
+expect(nanolightJs(codeJs)).to.deep.equal([
   ['span', { class: 'keyword' }, 'const'],
   ' ',
   ['span', { class: 'literal' }, 'answerToLifeTheUniverseAndEverything'],
@@ -776,7 +783,7 @@ expect(nanolightJs(codeJs)).toStrictEqual([
 ### omit
 
 ```ts
-const omit: <T extends Partial<Record<PropertyKey, unknown>>, K extends (keyof T)[]>(obj: Partial<Record<PropertyKey, unknown>>, keys: Partial<Array<unknown>>) => Omit<T, K[number]>;
+const omit: <T extends Partial<Record<PropertyKey, unknown>>, K extends Array<keyof T>>(obj: Partial<Record<PropertyKey, unknown>>, keys: Partial<Array<unknown>>) => Omit<T, K[number]>;
 ```
 
 > See [here](https://jackens.github.io/nnn/doc/#Why-Partial-Array-and-Partial-Record) for an explanation of why `Partial<Array>`/`Partial<Record>` instead of `Array`/`Record`.
@@ -788,13 +795,13 @@ A helper that implements TypeScript’s `Omit` utility type.
 ```js
 const obj = { a: 42, b: '42', c: 17 }
 
-expect(omit(obj, ['c'])).toStrictEqual({ a: 42, b: '42' })
+expect(omit(obj, ['c'])).to.deep.equal({ a: 42, b: '42' })
 ```
 
 ### pick
 
 ```ts
-const pick: <T extends Partial<Record<PropertyKey, unknown>>, K extends (keyof T)[]>(obj: Partial<Record<PropertyKey, unknown>>, keys: Partial<Array<unknown>>) => Pick<T, K[number]>;
+const pick: <T extends Partial<Record<PropertyKey, unknown>>, K extends Array<keyof T>>(obj: Partial<Record<PropertyKey, unknown>>, keys: Partial<Array<unknown>>) => Pick<T, K[number]>;
 ```
 
 > See [here](https://jackens.github.io/nnn/doc/#Why-Partial-Array-and-Partial-Record) for an explanation of why `Partial<Array>`/`Partial<Record>` instead of `Array`/`Record`.
@@ -806,7 +813,7 @@ A helper that implements TypeScript’s `Pick` utility type.
 ```js
 const obj = { a: 42, b: '42', c: 17 }
 
-expect(pick(obj, ['a', 'b'])).toStrictEqual({ a: 42, b: '42' })
+expect(pick(obj, ['a', 'b'])).to.deep.equal({ a: 42, b: '42' })
 ```
 
 ### plUral
@@ -822,17 +829,17 @@ A helper for choosing the correct singular and plural.
 ```js
 const auto = plUral.bind(null, 'auto', 'auta', 'aut')
 
-expect(auto(0)).toStrictEqual('aut')
-expect(auto(1)).toStrictEqual('auto')
-expect(auto(17)).toStrictEqual('aut')
-expect(auto(42)).toStrictEqual('auta')
+expect(auto(0)).to.deep.equal('aut')
+expect(auto(1)).to.deep.equal('auto')
+expect(auto(17)).to.deep.equal('aut')
+expect(auto(42)).to.deep.equal('auta')
 
 const car = plUral.bind(null, 'car', 'cars', 'cars')
 
-expect(car(0)).toStrictEqual('cars')
-expect(car(1)).toStrictEqual('car')
-expect(car(17)).toStrictEqual('cars')
-expect(car(42)).toStrictEqual('cars')
+expect(car(0)).to.deep.equal('cars')
+expect(car(1)).to.deep.equal('car')
+expect(car(17)).to.deep.equal('cars')
+expect(car(42)).to.deep.equal('cars')
 ```
 
 ### pro
@@ -850,27 +857,27 @@ const ref = {}
 
 pro(ref).one.two[3][4] = 1234
 
-expect(ref).toStrictEqual({ one: { two: { 3: { 4: 1234 } } } })
+expect(ref).to.deep.equal({ one: { two: { 3: { 4: 1234 } } } })
 
 pro(ref).one.two.tree = 123
 
-expect(ref).toStrictEqual({ one: { two: { 3: { 4: 1234 }, tree: 123 } } })
+expect(ref).to.deep.equal({ one: { two: { 3: { 4: 1234 }, tree: 123 } } })
 
 pro(ref).one.two = undefined
 
-expect(ref).toStrictEqual({ one: { two: undefined } })
+expect(ref).to.deep.equal({ one: { two: undefined } })
 
 delete pro(ref).one.two
 
-expect(ref).toStrictEqual({ one: {} })
+expect(ref).to.deep.equal({ one: {} })
 
 pro(ref).one.two.three.four
 
-expect(ref).toStrictEqual({ one: { two: { three: { four: {} } } } })
+expect(ref).to.deep.equal({ one: { two: { three: { four: {} } } } })
 
 pro(ref).one.two.three.four = 1234
 
-expect(ref).toStrictEqual({ one: { two: { three: { four: 1234 } } } })
+expect(ref).to.deep.equal({ one: { two: { three: { four: 1234 } } } })
 ```
 
 ### refsInfo
@@ -890,8 +897,8 @@ It returns an array of triples: `[«name», «prototype-name», «array-of-own-p
 ```js
 const info = refsInfo(Array, Function)
 
-expect(info.find(item => item?.[0] === 'Array')?.[2]?.includes('length')).toBeTrue()
-expect(info.find(item => item?.[0] === 'Function')?.[2]?.includes('length')).toBeTrue()
+expect(info.find(item => item?.[0] === 'Array')?.[2]?.includes('length')).to.be.true
+expect(info.find(item => item?.[0] === 'Function')?.[2]?.includes('length')).to.be.true
 ```
 
 ```js
@@ -974,23 +981,23 @@ A helper that generates a UUID v1 identifier (with a creation timestamp).
 for (let i = 1; i <= 22136; ++i) {
   const uuid = uuid1()
 
-  i === 1 && expect(uuid.split('-')[3]).toStrictEqual('8001')
-  i === 4095 && expect(uuid.split('-')[3]).toStrictEqual('8fff')
-  i === 4096 && expect(uuid.split('-')[3]).toStrictEqual('9000')
-  i === 9029 && expect(uuid.split('-')[3]).toStrictEqual('a345')
-  i === 13398 && expect(uuid.split('-')[3]).toStrictEqual('b456')
-  i === 16384 && expect(uuid.split('-')[3]).toStrictEqual('8000')
-  i === 17767 && expect(uuid.split('-')[3]).toStrictEqual('8567')
+  i === 1 && expect(uuid.split('-')[3]).to.deep.equal('8001')
+  i === 4095 && expect(uuid.split('-')[3]).to.deep.equal('8fff')
+  i === 4096 && expect(uuid.split('-')[3]).to.deep.equal('9000')
+  i === 9029 && expect(uuid.split('-')[3]).to.deep.equal('a345')
+  i === 13398 && expect(uuid.split('-')[3]).to.deep.equal('b456')
+  i === 16384 && expect(uuid.split('-')[3]).to.deep.equal('8000')
+  i === 17767 && expect(uuid.split('-')[3]).to.deep.equal('8567')
 }
 ```
 
 ```js
-expect(uuid1({ node: '000123456789abc' }).split('-')[4]).toStrictEqual('123456789abc')
-expect(uuid1({ node: '123456789' }).split('-')[4]).toStrictEqual('000123456789')
+expect(uuid1({ node: '000123456789abc' }).split('-')[4]).to.deep.equal('123456789abc')
+expect(uuid1({ node: '123456789' }).split('-')[4]).to.deep.equal('000123456789')
 ```
 
 ```js
-expect(uuid1({ date: new Date(323325000000) }).startsWith('c1399400-9a71-11bd')).toBeTrue()
+expect(uuid1({ date: new Date(323325000000) }).startsWith('c1399400-9a71-11bd')).to.be.true
 ```
 
 ## Why Partial\<Array\> and Partial\<Record\>