@jackens/nnn 2026.9.3 → 2026.9.9

package/nnn.d.ts

@@ -242,53 +242,3 @@ export declare const rwd: (root: CNode, selector: string, cellWidthPx: number, c
  *   `xxxxxxxx-xxxx-1xxx-xxxx-xxxxxxxxxxxx`.
  */
 export declare const uuidV1: (date?: Date, node?: string) => string;
-/**
- * A Proxy-based helper for auto-vivification of nested
- * object structures.
- *
- * Accessing, assigning, or deleting any nested property on
- * the returned proxy automatically creates intermediate
- * objects (or arrays for numeric-string keys matching
- * `^(0|[1-9]\d*)$`) as needed, allowing deep operations
- * without explicit null checks.
- *
- * Intermediates of the last level in a get-only property
- * chain are NOT auto-created. For example,
- * `vivify(ref).one.two` will create `ref.one` as `{}`, but
- * will NOT create `ref.one.two`. Only when a deeper access,
- * assignment, or deletion occurs, e.g.
- *
- * ```ts
- * delete vivify(ref).one.two.three
- * ```
- *
- * or
- *
- * ```ts
- * vivify(ref).one.two.three = 4
- * ```
- *
- * Will `ref.one.two` be materialized.
- *
- * When traversal reaches a primitive value, no
- * auto-creation happens; the primitive’s own property is
- * returned instead (e.g. accessing `.toString.name` on a
- * number yields `'toString'` without modifying the
- * underlying structure).
- *
- * Deletion on a non-existing intermediate path will
- * auto-create intermediates up to the parent of the deleted
- * key, e.g.
- *
- * ```ts
- * delete vivify(ref).one.two.three
- * ```
- *
- * Will create `ref.one.two` as `{}` if it does not exist.
- *
- * @param ref The root object to wrap.
- *
- * @returns A proxy that auto-creates nested objects/arrays
- *   on property access.
- */
-export declare const vivify: (ref: unknown) => any;

package/nnn.js

@@ -318,27 +318,6 @@ var uuidV1 = (date = new Date, node = Math.random().toString(16).slice(2)) => {
   counter = counter + 1 & 16383;
   return time.slice(-8).concat("-", time.slice(-12, -8), -1, time.slice(-15, -12), "-", (8 | counter >> 12).toString(16), (ZEROS + (counter & 4095).toString(16)).slice(-3), "-", (ZEROS + node).slice(-12));
 };
-// src/nnn/vivify.ts
-var ARRAY_INDEX_REGEXP = /^(0|[1-9]\d*)$/;
-var isObject = (ref) => typeof ref === "object";
-var getTarget = (parent, parentKey, key) => parent[parentKey] ??= typeof key === "string" && ARRAY_INDEX_REGEXP.test(key) ? [] : {};
-var _vivify = (parent, parentKey) => new Proxy(parent, {
-  get(_, key) {
-    const target = getTarget(parent, parentKey, key);
-    const value = target[key];
-    return typeof key === "string" && isObject(target) && (value == null || isObject(value)) ? _vivify(target, key) : value;
-  },
-  set(_, key, value) {
-    const target = getTarget(parent, parentKey, key);
-    target[key] = value;
-    return true;
-  },
-  deleteProperty(_, key) {
-    const target = getTarget(parent, parentKey, key);
-    return delete target[key];
-  }
-});
-var vivify = (ref) => _vivify({ _: ref }, "_");
 export {
   c,
   createEscape,
@@ -351,6 +330,5 @@ export {
   rwd,
   s,
   svgUse,
-  uuidV1,
-  vivify
+  uuidV1
 };

package/package.json

@@ -1,23 +1,24 @@
 {
-  "author": "Jackens",
+  "name": "@jackens/nnn",
+  "version": "2026.9.9",
   "description": "Jackens’ JavaScript helpers.",
   "keywords": [
-    "autovivify",
-    "c",
     "CSS-in-JS",
     "CSV parse",
     "DOM",
-    "escape",
-    "h",
-    "highlight",
     "HyperScript",
     "JS-to-CSS",
     "Monokai",
-    "nanolight",
-    "nnn",
-    "Responsive Web Design",
     "RWD",
+    "Responsive Web Design",
     "SVG",
+    "autovivify",
+    "c",
+    "escape",
+    "h",
+    "highlight",
+    "nanolight",
+    "nnn",
     "tokenize",
     "tokenizer",
     "typography",
@@ -27,9 +28,8 @@
     "vivify"
   ],
   "license": "MIT",
-  "main": "nnn.js",
-  "name": "@jackens/nnn",
+  "author": "Jackens",
   "type": "module",
-  "types": "nnn.d.ts",
-  "version": "2026.9.3"
+  "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.3`).
+A collection of Jackens’ JavaScript helper utilities (version: `2026.9.9`).
 
 ## Installation
 
@@ -18,6 +18,9 @@ npm i @jackens/nnn
 
 ```js
 import {
+  CNode,
+  HArgs,
+  HArgs1,
   c,
   createEscape,
   createTokenizer,
@@ -30,7 +33,6 @@ import {
   s,
   svgUse,
   uuidV1,
-  vivify,
 } from '@jackens/nnn' // or './node_modules/@jackens/nnn/nnn.js'
 ```
 
@@ -80,9 +82,6 @@ import {
   child referencing an icon by ID.
 - [`uuidV1`](#uuidV1):
   Generates a UUID v1 (time-based) identifier.
-- [`vivify`](#vivify):
-  A Proxy-based helper for auto-vivification of nested
-  object structures.
 
 ### CNode
 
@@ -145,7 +144,7 @@ A CSS string representing the compiled rules.
 #### Usage Examples
 
 ```ts
-const actual1 = c({
+const actual = c({
   a: {
     color: 'red',
     margin: 1,
@@ -154,22 +153,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 +182,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 +230,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 +288,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 +310,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 +332,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 +395,7 @@ const actual7 = c({
     },
 })
 
-const expected7 = `
+const expected = `
   :root{
     --bg:#faf4f2;
     --fg:#29242a;
@@ -412,9 +429,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
@@ -472,16 +490,18 @@ const actual = sql`
       /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'
-  )`
+  )
+`
 
-expect(actual).to.equal(expected)
+expect(actual).toBe(expected)
 ```
 
 ### createTokenizer
@@ -528,15 +548,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 +565,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 +706,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 +752,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 +811,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 +881,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 +926,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 +965,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 +1047,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 +1122,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 +1203,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 +1258,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,213 +1312,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
-```
-
-### vivify
-
-```ts
-const vivify: (ref: unknown) => any;
-```
-
-A Proxy-based helper for auto-vivification of nested
-object structures.
-
-Accessing, assigning, or deleting any nested property on
-the returned proxy automatically creates intermediate
-objects (or arrays for numeric-string keys matching
-`^(0|[1-9]\d*)$`) as needed, allowing deep operations
-without explicit null checks.
-
-Intermediates of the last level in a get-only property
-chain are NOT auto-created. For example,
-`vivify(ref).one.two` will create `ref.one` as `{}`, but
-will NOT create `ref.one.two`. Only when a deeper access,
-assignment, or deletion occurs, e.g.
-
-```ts
-delete vivify(ref).one.two.three
-```
-
-or
-
-```ts
-vivify(ref).one.two.three = 4
-```
-
-Will `ref.one.two` be materialized.
-
-When traversal reaches a primitive value, no
-auto-creation happens; the primitive’s own property is
-returned instead (e.g. accessing `.toString.name` on a
-number yields `'toString'` without modifying the
-underlying structure).
-
-Deletion on a non-existing intermediate path will
-auto-create intermediates up to the parent of the deleted
-key, e.g.
-
-```ts
-delete vivify(ref).one.two.three
-```
-
-Will create `ref.one.two` as `{}` if it does not exist.
-
-#### ref
-
-The root object to wrap.
-
-#### Returns
-
-A proxy that auto-creates nested objects/arrays
-on property access.
-
-#### Usage Examples
-
-```ts
-const ref: any = {}
-
-vivify(ref).one.two[3][4]
-
-expect(ref).to.deep.equal({
-  one: {
-    two: [undefined, undefined, undefined, []],
-  },
-})
-
-vivify(ref).one.two[3][4] = 5
-
-expect(ref).to.deep.equal({
-  one: {
-    two: [
-      undefined,
-      undefined,
-      undefined,
-      [undefined, undefined, undefined, undefined, 5],
-    ],
-  },
-})
-
-vivify(ref).one.two[3].length = 1
-
-expect(ref).to.deep.equal({
-  one: {
-    two: [undefined, undefined, undefined, [undefined]],
-  },
-})
-
-vivify(ref).one.two[3] = 4
-
-expect(ref).to.deep.equal({
-  one: {
-    two: [undefined, undefined, undefined, 4],
-  },
-})
-
-expect(vivify(ref).one.two.length).to.equal(4)
-
-expect(ref).to.deep.equal({
-  one: {
-    two: [undefined, undefined, undefined, 4],
-  },
-})
-
-vivify(ref).one.two = 3
-
-expect(ref).to.deep.equal({ one: { two: 3 } })
-
-vivify(ref).one.two = undefined
-
-expect(ref).to.deep.equal({ one: { two: undefined } })
-
-delete vivify(ref).one.two
-
-expect(ref).to.deep.equal({ one: {} })
-
-expect(vivify(ref).one.toString instanceof Function).to.be
-  .true
-
-expect(vivify(ref).one.toString.name).to.equal('toString')
-
-expect(ref).to.deep.equal({ one: {} })
-
-delete vivify(ref).one.two.three
-
-expect(ref).to.deep.equal({ one: { two: {} } })
-
-vivify(ref).one.two.three.four
-
-expect(ref).to.deep.equal({ one: { two: { three: {} } } })
-
-vivify(ref).one.two[3]
-
-expect(ref).to.deep.equal({ one: { two: { three: {} } } })
-
-vivify(ref).one.two.three.four = 5
-
-expect(ref).to.deep.equal({
-  one: { two: { three: { four: 5 } } },
-})
-
-expect(
-  vivify(ref).one.two.three.four.toString.name
-).to.equal('toString')
-
-expect(ref).to.deep.equal({
-  one: { two: { three: { four: 5 } } },
-})
-
-const u = undefined
-
-vivify(u).one.two = 3
-
-expect(u).to.be.undefined
-
-const n = null
-
-delete vivify(n).one.two.three
-
-expect(n).to.be.null
+).toBe(true)
 ```
 
 ## License