@jackens/nnn 2026.9.2 → 2026.9.7

package/nnn.js

@@ -108,7 +108,7 @@ var _h = (createElement, tagOrNode, ...args) => {
       child = _h(createElement, ...arg);
     } else if (typeof arg === "string" || typeof arg === "number") {
       child = document.createTextNode(arg);
-    } else if (arg != null) {
+    } else if (typeof arg === "object" && arg != null) {
       for (const name in arg) {
         const value = arg[name];
         if (name[0] === "$") {

package/package.json

@@ -1,33 +1,24 @@
 {
-  "author": "Jackens",
+  "name": "@jackens/nnn",
+  "version": "2026.9.7",
   "description": "Jackens’ JavaScript helpers.",
   "keywords": [
-    "autovivify",
-    "c",
     "CSS-in-JS",
     "CSV parse",
     "DOM",
-    "escape",
-    "h",
-    "has",
-    "highlight",
     "HyperScript",
-    "in",
-    "is",
-    "isArray",
-    "isFiniteNumber",
-    "isNumber",
-    "isRecord",
-    "isString",
     "JS-to-CSS",
     "Monokai",
-    "nanolight",
-    "nnn",
-    "omit",
-    "pick",
-    "Responsive Web Design",
     "RWD",
+    "Responsive Web Design",
     "SVG",
+    "autovivify",
+    "c",
+    "escape",
+    "h",
+    "highlight",
+    "nanolight",
+    "nnn",
     "tokenize",
     "tokenizer",
     "typography",
@@ -37,9 +28,8 @@
     "vivify"
   ],
   "license": "MIT",
-  "main": "nnn.js",
-  "name": "@jackens/nnn",
+  "author": "Jackens",
   "type": "module",
-  "types": "nnn.d.ts",
-  "version": "2026.9.2"
+  "main": "nnn.js",
+  "types": "nnn.d.ts"
 }

package/readme.md

@@ -1,6 +1,6 @@
 # nnn
 
-A collection of Jackens’ JavaScript helper utilities (version: `2026.9.2`).
+A collection of Jackens’ JavaScript helper utilities (version: `2026.9.7`).
 
 ## Installation
 
@@ -18,6 +18,9 @@ npm i @jackens/nnn
 
 ```js
 import {
+  CNode,
+  HArgs,
+  HArgs1,
   c,
   createEscape,
   createTokenizer,
@@ -145,7 +148,7 @@ A CSS string representing the compiled rules.
 #### Usage Examples
 
 ```ts
-const actual1 = c({
+const actual = c({
   a: {
     color: 'red',
     margin: 1,
@@ -154,22 +157,25 @@ const actual1 = c({
   },
 })
 
-const expected1 = `
-a{
-  color:red;
-  margin:1
-}
-a.c{
-  margin:2;
-  padding:2
-}
-a{
-  padding:1
-}`.replace(/\n\s*/g, '')
+const expected = `
+  a{
+    color:red;
+    margin:1
+  }
+  a.c{
+    margin:2;
+    padding:2
+  }
+  a{
+    padding:1
+  }
+`.replace(/\n\s*/g, '')
 
-expect(actual1).to.equal(expected1)
+expect(actual).toBe(expected)
+```
 
-const actual2 = c({
+```ts
+const actual = c({
   a: {
     '.b': {
       color: 'red',
@@ -180,22 +186,25 @@ const actual2 = c({
   },
 })
 
-const expected2 = `
-a.b{
-  color:red;
-  margin:1
-}
-a.b.c{
-  margin:2;
-  padding:2
-}
-a.b{
-  padding:1
-}`.replace(/\n\s*/g, '')
+const expected = `
+  a.b{
+    color:red;
+    margin:1
+  }
+  a.b.c{
+    margin:2;
+    padding:2
+  }
+  a.b{
+    padding:1
+  }
+`.replace(/\n\s*/g, '')
 
-expect(actual2).to.equal(expected2)
+expect(actual).toBe(expected)
+```
 
-const actual3 = c({
+```ts
+const actual = c({
   '@font-face$$1': {
     'font-family': 'Jackens',
     src$$1: 'url(otf/jackens.otf)',
@@ -225,51 +234,54 @@ const actual3 = c({
   },
 })
 
-const expected3 = `
-@font-face{
-  font-family:Jackens;
-  src:url(otf/jackens.otf);
-  src:url(otf/jackens.otf) format('opentype'),url(svg/jackens.svg) format('svg');
-  font-weight:normal;
-  font-style:normal
-}
-@font-face{
-  font-family:C64;
-  src:url(fonts/C64_Pro_Mono-STYLE.woff)
-}
-@keyframes spin{
-  0%{
-    transform:rotate(0deg)
+const expected = `
+  @font-face{
+    font-family:Jackens;
+    src:url(otf/jackens.otf);
+    src:url(otf/jackens.otf) format('opentype'),url(svg/jackens.svg) format('svg');
+    font-weight:normal;
+    font-style:normal
   }
-  100%{
-    transform:rotate(360deg)
+  @font-face{
+    font-family:C64;
+    src:url(fonts/C64_Pro_Mono-STYLE.woff)
+  }
+  @keyframes spin{
+    0%{
+      transform:rotate(0deg)
+    }
+    100%{
+      transform:rotate(360deg)
+    }
   }
-}
-div{
-  border:solid red 1px
-}
-div.c1{
-  background-color:#000
-}
-div .c1{
-  background-color:black
-}
-div.c2{
-  background-color:rgb(0,0,0)
-}
-@media(min-width:200px){
   div{
-    margin:0;
-    padding:0
+    border:solid red 1px
+  }
+  div.c1{
+    background-color:#000
   }
-  span{
-    color:#000
+  div .c1{
+    background-color:black
   }
-}`.replace(/\n\s*/g, '')
+  div.c2{
+    background-color:rgb(0,0,0)
+  }
+  @media(min-width:200px){
+    div{
+      margin:0;
+      padding:0
+    }
+    span{
+      color:#000
+    }
+  }
+`.replace(/\n\s*/g, '')
 
-expect(actual3).to.equal(expected3)
+expect(actual).toBe(expected)
+```
 
-const actual4 = c({
+```ts
+const actual = c({
   a: {
     '.b,.c': {
       margin: 1,
@@ -280,17 +292,20 @@ const actual4 = c({
   },
 })
 
-const expected4 = `
-a.b,a.c{
-  margin:1
-}
-a.b.d,a.c.d{
-  margin:2
-}`.replace(/\n\s*/g, '')
+const expected = `
+  a.b,a.c{
+    margin:1
+  }
+  a.b.d,a.c.d{
+    margin:2
+  }
+`.replace(/\n\s*/g, '')
 
-expect(actual4).to.equal(expected4)
+expect(actual).toBe(expected)
+```
 
-const actual5 = c({
+```ts
+const actual = c({
   '.b,.c': {
     margin: 1,
     '.d': {
@@ -299,17 +314,20 @@ const actual5 = c({
   },
 })
 
-const expected5 = `
-.b,.c{
-  margin:1
-}
-.b.d,.c.d{
-  margin:2
-}`.replace(/\n\s*/g, '')
+const expected = `
+  .b,.c{
+    margin:1
+  }
+  .b.d,.c.d{
+    margin:2
+  }
+`.replace(/\n\s*/g, '')
 
-expect(actual5).to.equal(expected5)
+expect(actual).toBe(expected)
+```
 
-const actual6 = c({
+```ts
+const actual = c({
   '.a,.b': {
     margin: 1,
     '.c,.d': {
@@ -318,17 +336,20 @@ const actual6 = c({
   },
 })
 
-const expected6 = `
-.a,.b{
-  margin:1
-}
-.a.c,.a.d,.b.c,.b.d{
-  margin:2
-}`.replace(/\n\s*/g, '')
+const expected = `
+  .a,.b{
+    margin:1
+  }
+  .a.c,.a.d,.b.c,.b.d{
+    margin:2
+  }
+`.replace(/\n\s*/g, '')
 
-expect(actual6).to.equal(expected6)
+expect(actual).toBe(expected)
+```
 
-const actual7 = c({
+```ts
+const actual = c({
   ':root$$monokai': {
     '--': {
       bg: '#faf4f2',
@@ -378,7 +399,7 @@ const actual7 = c({
     },
 })
 
-const expected7 = `
+const expected = `
   :root{
     --bg:#faf4f2;
     --fg:#29242a;
@@ -412,9 +433,10 @@ const expected7 = `
       --punctuation:#727072;
       --string:#ffd866
     }
-  }`.replace(/\n\s*/g, '')
+  }
+`.replace(/\n\s*/g, '')
 
-expect(actual7).to.equal(expected7)
+expect(actual).toBe(expected)
 ```
 
 ### createEscape
@@ -457,31 +479,31 @@ const escapeFn = (value: any): string =>
 const sql = createEscape(escapeFn)
 
 const actual = sql`
-  SELECT *
-  FROM table_name
-  WHERE column_name IN (
-    ${[
-      true,
-      null,
-      undefined,
-      NaN,
-      Infinity,
-      42,
-      '42',
-      "4'2",
-      /42/,
-      new Date(323325000000),
-    ]}
-  )`
+SELECT *
+FROM table_name
+WHERE column_name IN (
+  ${[
+    true,
+    null,
+    undefined,
+    NaN,
+    Infinity,
+    42,
+    '42',
+    "4'2",
+    /42/,
+    new Date(323325000000),
+  ]}
+)`
 
 const expected = `
-  SELECT *
-  FROM table_name
-  WHERE column_name IN (
-    b'1', NULL, NULL, NULL, NULL, 42, '42', '4''2', NULL, '1980-03-31 04:30:00'
-  )`
+SELECT *
+FROM table_name
+WHERE column_name IN (
+  b'1', NULL, NULL, NULL, NULL, 42, '42', '4''2', NULL, '1980-03-31 04:30:00'
+)`
 
-expect(actual).to.equal(expected)
+expect(actual).toBe(expected)
 ```
 
 ### createTokenizer
@@ -528,15 +550,15 @@ and returns an array of decorated tokens.
 #### Usage Examples
 
 ```ts
-const tokenizer1 = createTokenizer(
+const tokenizer = createTokenizer(
   (chunk, metadata) => ({ chunk, metadata }),
   ['keyword', /\b(if|else|for)\b/],
   ['string', /"[^"]*"/]
 )
 
-const result1 = tokenizer1('if "hello" else "world"')
+const result = tokenizer('if "hello" else "world"')
 
-expect(result1).to.deep.equal([
+expect(result).toEqual([
   { chunk: 'if', metadata: 'keyword' },
   { chunk: ' ', metadata: undefined },
   { chunk: '"hello"', metadata: 'string' },
@@ -545,92 +567,108 @@ expect(result1).to.deep.equal([
   { chunk: ' ', metadata: undefined },
   { chunk: '"world"', metadata: 'string' },
 ])
+```
 
-const tokenizer2 = createTokenizer(
+```ts
+const tokenizer = createTokenizer(
   (chunk, metadata) => `${metadata}:${chunk}`,
   ['tag', 'BEGIN'],
   ['end', 'END']
 )
 
-const result2 = tokenizer2('aBEGINbENDc')
+const result = tokenizer('aBEGINbENDc')
 
-expect(result2).to.deep.equal([
+expect(result).toEqual([
   'undefined:a',
   'tag:BEGIN',
   'undefined:b',
   'end:END',
   'undefined:c',
 ])
+```
 
-const tokenizer3 = createTokenizer(
+```ts
+const tokenizer = createTokenizer(
   chunk => chunk,
   ['test', /test/]
 )
 
-const result3 = tokenizer3('')
+const result = tokenizer('')
 
-expect(result3).to.deep.equal([])
+expect(result).toEqual([])
+```
 
-const tokenizer4 = createTokenizer(
+```ts
+const tokenizer = createTokenizer(
   (chunk, metadata) => ({ chunk, metadata }),
   ['start', /^test/]
 )
 
-const result4 = tokenizer4('test here')
+const result = tokenizer('test here')
 
-expect(result4).to.deep.equal([
+expect(result).toEqual([
   { chunk: 'test', metadata: 'start' },
   { chunk: ' here', metadata: undefined },
 ])
+```
 
-const tokenizer5 = createTokenizer(
+```ts
+const tokenizer = createTokenizer(
   (chunk, metadata) => metadata,
   ['later', /x/],
   ['earlier', /y/]
 )
 
-const result5 = tokenizer5('yx')
+const result = tokenizer('yx')
 
-expect(result5).to.deep.equal(['earlier', 'later'])
+expect(result).toEqual(['earlier', 'later'])
+```
 
-const tokenizer6 = createTokenizer(
+```ts
+const tokenizer = createTokenizer(
   chunk => chunk,
   ['short', 'a'],
   ['long', 'abc']
 )
 
-const result6 = tokenizer6('abc')
+const result = tokenizer('abc')
 
-expect(result6).to.deep.equal(['abc'])
+expect(result).toEqual(['abc'])
+```
 
-const tokenizer7 = createTokenizer(
+```ts
+const tokenizer = createTokenizer(
   chunk => chunk,
   ['empty', ''],
   ['word', /\w+/]
 )
 
-const result7 = tokenizer7('hello')
+const result = tokenizer('hello')
 
-expect(result7).to.deep.equal(['hello'])
+expect(result).toEqual(['hello'])
+```
 
-const tokenizer8 = createTokenizer(
+```ts
+const tokenizer = createTokenizer(
   chunk => chunk,
   ['test', /xyz/]
 )
 
-const result8 = tokenizer8('abc')
+const result = tokenizer('abc')
 
-expect(result8).to.deep.equal(['abc'])
+expect(result).toEqual(['abc'])
+```
 
-const tokenizer9 = createTokenizer(
+```ts
+const tokenizer = createTokenizer(
   (_chunk, metadata) => metadata,
   ['a', 'a'],
   ['b', 'b']
 )
 
-const result9 = tokenizer9('aabb')
+const result = tokenizer('aabb')
 
-expect(result9).to.deep.equal(['a', 'a', 'b', 'b'])
+expect(result).toEqual(['a', 'a', 'b', 'b'])
 ```
 
 ### csvParse
@@ -670,7 +708,7 @@ yyy",zzz
 
 `
 
-expect(csvParse(text)).to.deep.equal([
+expect(csvParse(text)).toEqual([
   ['aaa\n"aaa"\naaa', 'bbb', 'ccc,ccc'],
   ['xxx,xxx', 'yyy\nyyy', 'zzz'],
   [' 42 ', '42', ' 17'],
@@ -716,7 +754,7 @@ const p = h(
 
 fixPlTypography(p)
 
-expect(p.innerHTML).to.deep.equal(
+expect(p.innerHTML).toEqual(
   'Pchnąć ' +
     '<span style="white-space:nowrap">w </span>' +
     'tę łódź jeża lub ośm skrzyń fig ' +
@@ -775,61 +813,66 @@ The created or modified `HTMLElement`.
 ```ts
 const b = h('b')
 
-expect(b.outerHTML).to.equal('<b></b>')
+expect(b.outerHTML).toBe('<b></b>')
 
 const i = h('i', 'text')
 
 h(b, i)
 
-expect(i.outerHTML).to.equal('<i>text</i>')
+expect(i.outerHTML).toBe('<i>text</i>')
 
-expect(b.outerHTML).to.equal('<b><i>text</i></b>')
+expect(b.outerHTML).toBe('<b><i>text</i></b>')
 
 h(i, { $className: 'some class' })
 
-expect(i.outerHTML).to.equal(
-  '<i class="some class">text</i>'
-)
+expect(i.outerHTML).toBe('<i class="some class">text</i>')
 
-expect(b.outerHTML).to.equal(
+expect(b.outerHTML).toBe(
   '<b><i class="some class">text</i></b>'
 )
+```
 
-expect(h('span', 'text').outerHTML).to.equal(
+```ts
+expect(h('span', 'text').outerHTML).toBe(
   '<span>text</span>'
 )
 
-expect(
-  h('span', { $innerText: 'text' }).outerHTML
-).to.equal('<span>text</span>')
-
-expect(h('span', '42').outerHTML).to.equal(
-  '<span>42</span>'
+expect(h('span', { $innerText: 'text' }).outerHTML).toBe(
+  '<span>text</span>'
 )
 
-expect(h('span', 42).outerHTML).to.equal('<span>42</span>')
+expect(h('span', '42').outerHTML).toBe('<span>42</span>')
 
+expect(h('span', 42).outerHTML).toBe('<span>42</span>')
+```
+
+```ts
 expect(
   h('div', { style: 'margin:0;padding:0' }).outerHTML
-).to.equal('<div style="margin:0;padding:0"></div>')
+).toBe('<div style="margin:0;padding:0"></div>')
 
 expect(
   h('div', { $style: 'margin:0;padding:0' }).outerHTML
-).to.equal('<div style="margin: 0px; padding: 0px;"></div>')
+).toBe('<div style="margin: 0px; padding: 0px;"></div>')
 
 expect(
-  h('div', { $style: { margin: 0, padding: 0 } }).outerHTML
-).to.equal('<div style="margin: 0px; padding: 0px;"></div>')
+  h('div', { $style: { margin: 0, padding: 0 } })
+    .outerHTML
+).toBe('<div style="margin: 0px; padding: 0px;"></div>')
+```
 
+```ts
 const input1 = h('input', { value: 42 })
 const input2 = h('input', { $value: '42' })
 
-expect(input1.value).to.equal('42')
-expect(input2.value).to.equal('42')
+expect(input1.value).toBe('42')
+expect(input2.value).toBe('42')
 
-expect(input1.outerHTML).to.equal('<input value="42">')
-expect(input2.outerHTML).to.equal('<input>')
+expect(input1.outerHTML).toBe('<input value="42">')
+expect(input2.outerHTML).toBe('<input>')
+```
 
+```ts
 const checkbox1 = h('input', {
   type: 'checkbox',
   checked: true,
@@ -840,38 +883,42 @@ const checkbox2 = h('input', {
   $checked: true,
 })
 
-expect(checkbox1.checked).to.be.true
-expect(checkbox2.checked).to.be.true
+expect(checkbox1.checked).toBe(true)
+expect(checkbox2.checked).toBe(true)
 
-expect(checkbox1.outerHTML).to.equal(
+expect(checkbox1.outerHTML).toBe(
   '<input type="checkbox" checked="">'
 )
 
-expect(checkbox2.outerHTML).to.equal(
+expect(checkbox2.outerHTML).toBe(
   '<input type="checkbox">'
 )
+```
 
+```ts
 const div = h('div')
 
-expect(div.key).to.be.undefined
+expect(div.key).toBeUndefined()
 
 h(div, { $key: { one: 1 } })
 
-expect(div.key).to.deep.equal({ one: 1 })
+expect(div.key).toEqual({ one: 1 })
 
 h(div, { $key: { two: 2 } })
 
-expect(div.key).to.deep.equal({ one: 1, two: 2 })
+expect(div.key).toEqual({ one: 1, two: 2 })
+```
 
+```ts
 const elemWithClass = h('div', { class: 'test' })
 
-expect(elemWithClass.getAttribute('class')).to.equal('test')
+expect(elemWithClass.getAttribute('class')).toBe('test')
 
 const elemWithText = h('div', 'initial')
 
 h(elemWithText, ' more')
 
-expect(elemWithText.outerHTML).to.equal(
+expect(elemWithText.outerHTML).toBe(
   '<div>initial more</div>'
 )
 
@@ -881,7 +928,7 @@ const elemWithNested = h(
   ['b', 'world']
 )
 
-expect(elemWithNested.outerHTML).to.equal(
+expect(elemWithNested.outerHTML).toBe(
   '<div><span>hello</span><b>world</b></div>'
 )
 ```
@@ -920,7 +967,7 @@ const codeJs =
   'const answerToLifeTheUniverseAndEverything = ' +
   "{ 42: 42 }['42'] /* 42 */"
 
-expect(nanolightTs(codeJs)).to.deep.equal([
+expect(nanolightTs(codeJs)).toEqual([
   ['span', { class: 'keyword1' }, 'const'],
   ' ',
   [
@@ -1002,7 +1049,7 @@ const style: CNode = {
 
 rwd(style, '.r6', 200, 50, [6], [3], [1, 1, 2])
 
-expect(style).to.deep.equal({
+expect(style).toEqual({
   body: {
     margin: 0,
   },
@@ -1077,29 +1124,49 @@ The created or modified `SVGElement`.
 #### Usage Examples
 
 ```ts
-const XLINK_NS = 'http://www.w3.org/1999/xlink'
-
-const svg1 = s('svg', { 'xlink:href': true })
+const svg = s('svg', { 'xlink:href': true })
 
-expect(svg1.getAttributeNS(XLINK_NS, 'href')).to.equal('')
+expect(
+  svg.getAttributeNS(
+    'http://www.w3.org/1999/xlink',
+    'href'
+  )
+).toBe('')
+```
 
-const svg2 = s('svg', { 'xlink:href': false })
+```ts
+const svg = s('svg', { 'xlink:href': false })
 
-expect(svg2.getAttributeNS(XLINK_NS, 'href')).to.be.null
+expect(
+  svg.getAttributeNS(
+    'http://www.w3.org/1999/xlink',
+    'href'
+  )
+).toBeNull()
+```
 
-const svg3 = s('svg', {
+```ts
+const svg = s('svg', {
   'xlink:href': 'http://example.com',
 })
 
-expect(svg3.getAttributeNS(XLINK_NS, 'href')).to.equal(
-  'http://example.com'
-)
+expect(
+  svg.getAttributeNS(
+    'http://www.w3.org/1999/xlink',
+    'href'
+  )
+).toBe('http://example.com')
+```
 
-const svg4 = s('svg', { 'xlink:title': 42 })
+```ts
+const svg = s('svg', { 'xlink:title': 42 })
 
-expect(svg4.getAttributeNS(XLINK_NS, 'title')).to.equal(
-  '42'
-)
+expect(
+  svg.getAttributeNS(
+    'http://www.w3.org/1999/xlink',
+    'title'
+  )
+).toBe('42')
 ```
 
 ### svgUse
@@ -1138,47 +1205,54 @@ An `SVGSVGElement` containing a `<use>` element.
 #### Usage Examples
 
 ```ts
-const XLINK_NS = 'http://www.w3.org/1999/xlink'
-
 const svg = svgUse('icon-home')
 
-expect(svg.children.length).to.equal(1)
+expect(svg.children.length).toBe(1)
 
 const useElement = svg.children[0]
 
 expect(
-  useElement.getAttributeNS(XLINK_NS, 'href')
-).to.equal('#icon-home')
+  useElement.getAttributeNS(
+    'http://www.w3.org/1999/xlink',
+    'href'
+  )
+).toBe('#icon-home')
 
 const svgWithViewBox = svgUse('icon-star', {
   viewBox: '0 0 24 24',
 })
 
-expect(svgWithViewBox.getAttribute('viewBox')).to.equal(
+expect(svgWithViewBox.getAttribute('viewBox')).toBe(
   '0 0 24 24'
 )
 
 const useViewBox = svgWithViewBox.children[0]
 
 expect(
-  useViewBox.getAttributeNS(XLINK_NS, 'href')
-).to.equal('#icon-star')
+  useViewBox.getAttributeNS(
+    'http://www.w3.org/1999/xlink',
+    'href'
+  )
+).toBe('#icon-star')
 
 const svgWithClass = svgUse('icon-menu', {
   class: 'icon-btn',
 })
 
-expect(svgWithClass.getAttribute('class')).to.equal(
+expect(svgWithClass.getAttribute('class')).toBe(
   'icon-btn'
 )
 
-expect(svgWithClass.children.length).to.equal(1)
+expect(svgWithClass.children.length).toBe(1)
 
 const useClass = svgWithClass.children[0]
 
-expect(useClass.getAttributeNS(XLINK_NS, 'href')).to.equal(
-  '#icon-menu'
-)
+expect(
+  useClass.getAttributeNS(
+    'http://www.w3.org/1999/xlink',
+    'href'
+  )
+).toBe('#icon-menu')
 
 const svgWithMultipleAttrs = svgUse('icon-settings', {
   width: 24,
@@ -1186,23 +1260,26 @@ const svgWithMultipleAttrs = svgUse('icon-settings', {
   class: 'icon',
 })
 
-expect(svgWithMultipleAttrs.getAttribute('width')).to.equal(
+expect(svgWithMultipleAttrs.getAttribute('width')).toBe(
   '24'
 )
 
-expect(
-  svgWithMultipleAttrs.getAttribute('height')
-).to.equal('24')
+expect(svgWithMultipleAttrs.getAttribute('height')).toBe(
+  '24'
+)
 
-expect(svgWithMultipleAttrs.getAttribute('class')).to.equal(
+expect(svgWithMultipleAttrs.getAttribute('class')).toBe(
   'icon'
 )
 
 const useMultiple = svgWithMultipleAttrs.children[0]
 
 expect(
-  useMultiple.getAttributeNS(XLINK_NS, 'href')
-).to.equal('#icon-settings')
+  useMultiple.getAttributeNS(
+    'http://www.w3.org/1999/xlink',
+    'href'
+  )
+).toBe('#icon-settings')
 ```
 
 ### uuidV1
@@ -1237,47 +1314,49 @@ for (let i = 1; i <= 22136; ++i) {
   const uuid = uuidV1()
 
   if (i === 1) {
-    expect(uuid.split('-')[3]).to.equal('8001')
+    expect(uuid.split('-')[3]).toBe('8001')
   }
 
   if (i === 4095) {
-    expect(uuid.split('-')[3]).to.equal('8fff')
+    expect(uuid.split('-')[3]).toBe('8fff')
   }
 
   if (i === 4096) {
-    expect(uuid.split('-')[3]).to.equal('9000')
+    expect(uuid.split('-')[3]).toBe('9000')
   }
 
   if (i === 9029) {
-    expect(uuid.split('-')[3]).to.equal('a345')
+    expect(uuid.split('-')[3]).toBe('a345')
   }
 
   if (i === 13398) {
-    expect(uuid.split('-')[3]).to.equal('b456')
+    expect(uuid.split('-')[3]).toBe('b456')
   }
 
   if (i === 16384) {
-    expect(uuid.split('-')[3]).to.equal('8000')
+    expect(uuid.split('-')[3]).toBe('8000')
   }
 
   if (i === 17767) {
-    expect(uuid.split('-')[3]).to.equal('8567')
+    expect(uuid.split('-')[3]).toBe('8567')
   }
 }
+```
 
+```ts
 expect(
   uuidV1(new Date(), '000123456789abc').split('-')[4]
-).to.equal('123456789abc')
+).toBe('123456789abc')
 
 expect(
   uuidV1(new Date(), '123456789').split('-')[4]
-).to.equal('000123456789')
+).toBe('000123456789')
 
 expect(
   uuidV1(new Date(323325000000)).startsWith(
     'c1399400-9a71-11bd'
   )
-).to.be.true
+).toBe(true)
 ```
 
 ### vivify
@@ -1345,7 +1424,7 @@ const ref: any = {}
 
 vivify(ref).one.two[3][4]
 
-expect(ref).to.deep.equal({
+expect(ref).toEqual({
   one: {
     two: [undefined, undefined, undefined, []],
   },
@@ -1353,7 +1432,7 @@ expect(ref).to.deep.equal({
 
 vivify(ref).one.two[3][4] = 5
 
-expect(ref).to.deep.equal({
+expect(ref).toEqual({
   one: {
     two: [
       undefined,
@@ -1366,7 +1445,7 @@ expect(ref).to.deep.equal({
 
 vivify(ref).one.two[3].length = 1
 
-expect(ref).to.deep.equal({
+expect(ref).toEqual({
   one: {
     two: [undefined, undefined, undefined, [undefined]],
   },
@@ -1374,15 +1453,15 @@ expect(ref).to.deep.equal({
 
 vivify(ref).one.two[3] = 4
 
-expect(ref).to.deep.equal({
+expect(ref).toEqual({
   one: {
     two: [undefined, undefined, undefined, 4],
   },
 })
 
-expect(vivify(ref).one.two.length).to.equal(4)
+expect(vivify(ref).one.two.length).toBe(4)
 
-expect(ref).to.deep.equal({
+expect(ref).toEqual({
   one: {
     two: [undefined, undefined, undefined, 4],
   },
@@ -1390,60 +1469,63 @@ expect(ref).to.deep.equal({
 
 vivify(ref).one.two = 3
 
-expect(ref).to.deep.equal({ one: { two: 3 } })
+expect(ref).toEqual({ one: { two: 3 } })
 
 vivify(ref).one.two = undefined
 
-expect(ref).to.deep.equal({ one: { two: undefined } })
+expect(ref).toEqual({ one: { two: undefined } })
 
 delete vivify(ref).one.two
 
-expect(ref).to.deep.equal({ one: {} })
+expect(ref).toEqual({ one: {} })
 
-expect(vivify(ref).one.toString instanceof Function).to.be
-  .true
+expect(vivify(ref).one.toString instanceof Function).toBe(
+  true
+)
 
-expect(vivify(ref).one.toString.name).to.equal('toString')
+expect(vivify(ref).one.toString.name).toBe('toString')
 
-expect(ref).to.deep.equal({ one: {} })
+expect(ref).toEqual({ one: {} })
 
 delete vivify(ref).one.two.three
 
-expect(ref).to.deep.equal({ one: { two: {} } })
+expect(ref).toEqual({ one: { two: {} } })
 
 vivify(ref).one.two.three.four
 
-expect(ref).to.deep.equal({ one: { two: { three: {} } } })
+expect(ref).toEqual({ one: { two: { three: {} } } })
 
 vivify(ref).one.two[3]
 
-expect(ref).to.deep.equal({ one: { two: { three: {} } } })
+expect(ref).toEqual({ one: { two: { three: {} } } })
 
 vivify(ref).one.two.three.four = 5
 
-expect(ref).to.deep.equal({
+expect(ref).toEqual({
   one: { two: { three: { four: 5 } } },
 })
 
-expect(
-  vivify(ref).one.two.three.four.toString.name
-).to.equal('toString')
+expect(vivify(ref).one.two.three.four.toString.name).toBe(
+  'toString'
+)
 
-expect(ref).to.deep.equal({
+expect(ref).toEqual({
   one: { two: { three: { four: 5 } } },
 })
+```
 
+```ts
 const u = undefined
 
 vivify(u).one.two = 3
 
-expect(u).to.be.undefined
+expect(u).toBeUndefined()
 
 const n = null
 
 delete vivify(n).one.two.three
 
-expect(n).to.be.null
+expect(n).toBeNull()
 ```
 
 ## License