@jackens/nnn 2023.10.14 → 2023.11.3

package/nnn.js

@@ -1,91 +1,5 @@
-/* eslint-disable no-console */
-
-export const _test = {}
-export const _version = '2023.10.14'
-
-/**
- * ```ts
- * export type EscapeMap = Map<any, (value?: any) => string>;
- * ```
- */
-
-/**
- * @typedef {Map<any, (value?: any) => string>} EscapeMap
- *
- * The type of arguments of the `escapeValues` and `escape` helpers.
- */
-
-/**
- * ```ts
- * export type HArgs = [
- *   string | Node,
- *   ...(Record<string, any> | null | undefined | Node | string | number | HArgs)[]
- * ];
- * ```
- */
-
-/**
- * @typedef {[
- *   string | Node,
- *   ...(Record<string, any> | null | undefined | Node | string | number | HArgs)[]
- * ]} HArgs
- *
- * The type of arguments of the `h` and `s` helpers.
- */
-
-/**
- * ```ts
- * export type JcssNode = {
- *   [attributeOrSelector: string]: string | number | JcssNode;
- * };
- * ```
- */
-
-/**
- * @typedef {{
- *   [attributeOrSelector: string]: string | number | JcssNode;
- * }} JcssNode
- *
- * The type of arguments of the `jcss` helper.
- */
-
-/**
- * ```ts
- * export type JcssRoot = Record<string, JcssNode>;
- * ```
- */
-
-/**
- * @typedef {Record<string, JcssNode>} JcssRoot
- *
- * The type of arguments of the `jcss` helper.
- */
-
 const _COLORS = ['#e22', '#e73', '#fc3', '#ad4', '#4d9', '#3be', '#45d', '#c3e']
 
-/**
- * ```ts
- * export function chartable(options?: {
- *   bottom?: number;
- *   gapX?: number;
- *   gapY?: number;
- *   headerColumn?: boolean;
- *   headerRow?: boolean;
- *   id?: string;
- *   left?: number;
- *   maxY?: number;
- *   right?: number;
- *   singleScale?: boolean;
- *   table?: HTMLTableElement;
- *   title?: string;
- *   top?: number;
- *   xLabels?: string[];
- *   zLabels?: string[];
- *   zxY?: number[][];
- * }): SVGSVGElement;
- * ```
- */
-
 /**
  * A helper for creating a chart based on a table (conf. <https://jackens.github.io/nnn/chartable/>).
  *
@@ -174,8 +88,7 @@ export const chartable = ({
   })
 
   if (singleScale) {
-    bestScales = ranges.reduce(([totalMin, totalMax], [min, max]) =>
-      [Math.min(totalMin, min), Math.max(totalMax, max)], bestScales)
+    bestScales = ranges.reduce(([totalMin, totalMax], [min, max]) => [Math.min(totalMin, min), Math.max(totalMax, max)], bestScales)
   } else {
     ranges.forEach(([min1, max0]) => ranges.forEach(([min0, max1]) => {
       if (min0 >= min1 && max1 >= max0) {
@@ -216,15 +129,14 @@ export const chartable = ({
   const h = gapY * (maxY - 1)
   const svgW = left + w + right
   const svgH = top + h + bottom
-  const /** @type {HArgs} */ graph = ['g', { transform: `translate(${left} ${top})` },
+  const /** @type {import('./h.js').HArgs} */ graph = ['g', { transform: `translate(${left} ${top})` },
     ...yi.map(y => ['line', { x1: 0, x2: w, y1: y, y2: y, stroke: '#8888' }]),
     ...xi.map(x => ['line', { x1: x, x2: x, y1: 0, y2: h, stroke: '#8888' }])]
-  const /** @type {HArgs} */ lColors = ['g', { class: 'chartable-z-colors', transform: 'translate(-80 0)' }]
-  const /** @type {HArgs} */ lLabels = ['g', { class: 'chartable-z-labels', transform: 'translate(-95 0)' }]
-  const /** @type {HArgs} */ rColors = ['g', { class: 'chartable-z-colors', transform: 'translate(80 0)' }]
-  const /** @type {HArgs} */ rLabels = ['g', { class: 'chartable-z-labels', transform: 'translate(95 0)' }]
-  const yLabel = (/** @type {number} */ min, /** @type {number} */ max, /** @type {number} */ y) =>
-    (min + (max - min) * (maxY - 1 - y) / (maxY - 1)).toFixed(2).replace(/\.?0+$/, '')
+  const /** @type {import('./h.js').HArgs} */ lColors = ['g', { class: 'chartable-z-colors', transform: 'translate(-80 0)' }]
+  const /** @type {import('./h.js').HArgs} */ lLabels = ['g', { class: 'chartable-z-labels', transform: 'translate(-95 0)' }]
+  const /** @type {import('./h.js').HArgs} */ rColors = ['g', { class: 'chartable-z-colors', transform: 'translate(80 0)' }]
+  const /** @type {import('./h.js').HArgs} */ rLabels = ['g', { class: 'chartable-z-labels', transform: 'translate(95 0)' }]
+  const yLabel = (/** @type {number} */ min, /** @type {number} */ max, /** @type {number} */ y) => (min + (max - min) * (maxY - 1 - y) / (maxY - 1)).toFixed(2).replace(/\.?0+$/, '')
 
   zxY.forEach((xa, z) => {
     const cls = `chartable-z-${z + 1}`
@@ -297,16 +209,10 @@ export const chartable = ({
   )
 }
 
-/**
- * ```ts
- * export function eq(x: any, y: any): boolean;
- * ```
- */
-
 /**
  * A helper that checks equality of the given arguments.
  */
-export const eq = /** @returns {boolean} */ (/** @type {any} */ x, /** @type {any} */ y) => {
+export const eq = /** @return {boolean} */ (/** @type {any} */ x, /** @type {any} */ y) => {
   if (x === y) {
     return true
   }
@@ -348,47 +254,19 @@ export const eq = /** @returns {boolean} */ (/** @type {any} */ x, /** @type {an
   return false
 }
 
-_test.eq = () => {
-  console.assert(eq(true, true))
-  console.assert(eq(NaN, NaN))
-  console.assert(!eq(null, undefined))
-  console.assert(eq(42, 42))
-  // eslint-disable-next-line no-new-wrappers
-  console.assert(eq(42, new Number(42)))
-  console.assert(eq(42, Number(42)))
-  // 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'))
-  // eslint-disable-next-line no-new-wrappers
-  console.assert(eq('42', new String('42')))
-  console.assert(eq('42', String('42')))
-  // 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(
-    new Map([[{ j: 42 }, { J: '42' }], [{ c: 42 }, { C: '42' }]]),
-    new Map([[{ c: 42 }, { C: '42' }], [{ j: 42 }, { J: '42' }]])
-  ))
-  console.assert(!eq(
-    new Map([[{ j: 42 }, { J: '42' }], [{ c: 42 }, { C: '42' }]]),
-    new Map([[{ j: '42' }, { J: 42 }], [{ c: '42' }, { C: 42 }]])
-  ))
-}
+/**
+ * @typedef {Map<any, (value?: any) => string>} EscapeMap
+ *
+ * The type of arguments of the `escapeValues` and `escape` helpers.
+ */
 
 /**
- * ```ts
- * export function escape(escapeMap: EscapeMap, template: TemplateStringsArray, ...values: any[]): string;
- * ```
+ * A generic helper for escaping `values` by given `escapeMap`.
  */
+export const escapeValues = (
+  /** @type {EscapeMap} */ escapeMap,
+  /** @type {any[]}     */ values
+) => values.map(value => (escapeMap.get(value?.constructor) ?? escapeMap.get(undefined))?.(value) ?? '')
 
 /**
  * A generic helper for escaping `values` by given `escapeMap` (in *TemplateStrings* flavor).
@@ -399,55 +277,8 @@ export const escape = (
   /** @type {any[]}                */ ...values
 ) => String.raw(template, ...escapeValues(escapeMap, values))
 
-_test.escape = () => {
-  // @ts-expect-error
-  const /** @type {EscapeMap} */ escapeMap = new Map([
-    [undefined, () => 'NULL'],
-    [Array, (/** @type {any[]} */ 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, "''")}'`]
-  ])
-
-  // @ts-expect-error
-  const sql = escape.bind(null, escapeMap)
-
-  const actual = sql`
-    SELECT *
-    FROM table_name
-    WHERE column_name IN (${[true, null, undefined, 42, '42', "4'2", /42/, new Date(323325e6)]})`
-
-  const expected = `
-    SELECT *
-    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)
-}
-
-/**
- * ```ts
- * export function escapeValues(escapeMap: EscapeMap, values: any[]): string[];
- * ```
- */
-
-/**
- * A generic helper for escaping `values` by given `escapeMap`.
- */
-export const escapeValues = (
-  /** @type {EscapeMap} */ escapeMap,
-  /** @type {any[]}     */ values
-) => values.map(value => (escapeMap.get(value?.constructor) ?? escapeMap.get(undefined))?.(value) ?? '')
-
 const _TAGS_TO_SKIP = { IFRAME: 1, NOSCRIPT: 1, PRE: 1, SCRIPT: 1, STYLE: 1, TEXTAREA: 1 }
 
-/**
- * ```ts
- * export function fixTypography(node: Node): void;
- * ```
- */
-
 /**
  * A helper that implements typographic corrections specific to Polish typography.
  */
@@ -491,15 +322,14 @@ export const fixTypography = (/** @type {Node} */ node) => {
   }
 }
 
-_test.fixTypography = () => {
-  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 ===
-    'Pchnąć <span style="white-space:nowrap">w </span>tę łódź jeża lub ośm skrzyń fig ' +
-    '(zob. https://\u200Bpl.\u200Bwikipedia.\u200Borg/\u200Bwiki/\u200BPangram).')
-}
+/**
+ * @typedef {[
+ *   string | Node,
+ *   ...(Record<string, any> | null | undefined | Node | string | number | HArgs)[]
+ * ]} HArgs
+ *
+ * The type of arguments of the `h` and `s` helpers.
+ */
 
 const /** @type {Record<string, string>} */ _NS = {
   xlink: 'http://www.w3.org/1999/xlink'
@@ -595,14 +425,6 @@ const _h = (/** @type {string?=} */ namespaceURI) => {
   return h
 }
 
-/**
- * ```ts
- * export function h<T extends keyof HTMLElementTagNameMap>(tag: T, ...args: HArgs[1][]): HTMLElementTagNameMap[T];
- * export function h<N extends Node>(node: N, ...args: HArgs[1][]): N;
- * export function h(...args: HArgs): Node;
- * ```
- */
-
 /**
  * A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style helper for creating and modifying `HTMLElement`s (see also `s`).
  *
@@ -620,129 +442,27 @@ const _h = (/** @type {string?=} */ namespaceURI) => {
  */
 export const h = _h()
 
-_test.h = () => {
-  const b = h('b')
-
-  console.assert(b.outerHTML === '<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>')
-
-  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>')
-}
-
-_test['h: innerText vs items'] = () => {
-  console.assert(h('span', 'text').outerHTML === '<span>text</span>')
-  console.assert(h('span', { $innerText: 'text' }).outerHTML === '<span>text</span>')
-}
-
-_test['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>')
-}
-
-_test['h: attributes vs properties'] = () => {
-  const input1 = h('input', { value: 42 })
-  const input2 = h('input', { $value: '42' })
-
-  console.assert(input1.value === '42')
-  console.assert(input2.value === '42')
-
-  console.assert(input1.outerHTML === '<input value="42">')
-  console.assert(input2.outerHTML === '<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)
-
-  console.assert(checkbox1.outerHTML === '<input type="checkbox" checked="">')
-  console.assert(checkbox2.outerHTML === '<input type="checkbox">')
-}
-
-_test['h: nested properties'] = () => {
-  const div = h('div')
-
-  // @ts-expect-error
-  console.assert(div.key === undefined)
-
-  h(div, { $key: { one: 1 } })
-
-  // @ts-expect-error
-  console.assert(eq(div.key, { one: 1 }))
-
-  h(div, { $key: { two: 2 } })
-
-  // @ts-expect-error
-  console.assert(eq(div.key, { one: 1, two: 2 }))
-}
-
 /**
- * ```ts
- * export function has(key: any, ref: any): boolean;
- * ```
+ * A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style helper for creating and modifying `SVGElement`s (see also `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.
+ *   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`.
+ *   An attribute equal to `false` causes the attribute to be removed by `removeAttributeNS`.
+ * - All other arguments of type `null` or `undefined` are simply ignored.
+ * - All other arguments of type `Node` are appended to the element being created or modified.
+ * - All other arguments of type `string`/`number` are converted to `Text` nodes and appended to the element being created or modified.
+ * - All other arguments of type `HArgs` are passed to `s` and the results are appended to the element being created or modified.
  */
+export const s = _h('http://www.w3.org/2000/svg')
 
 /**
  * A replacement for the `in` operator (not to be confused with the `for-in` loop) that works properly.
  */
-export const has = (/** @type {any} */ key, /** @type {any} */ ref) =>
-  (is(String, key) || is(Number, key) || is(Symbol, key)) && Object.hasOwnProperty.call(ref ?? Object, key)
-
-_test.has = () => {
-  const obj = { key: 'K', null: 'N' }
-
-  console.assert('key' in obj)
-  console.assert(has('key', obj))
-
-  console.assert('null' in obj)
-  console.assert(has('null', obj))
-
-  // @ts-expect-error
-  console.assert(null in obj)
-  console.assert(!has(null, obj))
-
-  console.assert('toString' in obj)
-  console.assert(!has('toString', obj))
-}
-
-_test['has: null'] = () => {
-  let typeError
-
-  try {
-    // @ts-expect-error
-    console.assert('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))
-}
-
-/**
- * ```ts
- * export function is(type: BigIntConstructor, arg: any): arg is bigint;
- * export function is(type: BooleanConstructor, arg: any): arg is boolean;
- * export function is(type: NumberConstructor, arg: any): arg is number;
- * export function is(type: StringConstructor, arg: any): arg is string;
- * export function is(type: SymbolConstructor, arg: any): arg is symbol;
- * export function is(type: undefined, arg: any): arg is null | undefined;
- * export function is<T extends abstract new (...args: any[]) => any>(type: T, arg: any): arg is InstanceType<T>;
- * ```
- */
+export const has = (/** @type {any} */ key, /** @type {any} */ ref) => (is(String, key) || is(Number, key) || is(Symbol, key)) && Object.hasOwnProperty.call(ref ?? Object, key)
 
 /**
  * A helper that checks if the given argument is of a certain type.
@@ -759,42 +479,23 @@ _test['has: null'] = () => {
  *   <T extends abstract new (...args: any[]) => any>(type: T, arg: any): arg is InstanceType<T>;
  * }}
  *
- * @returns {arg is bigint | boolean | number | string | symbol | undefined | null | InstanceType<T>}
+ * @return {arg is bigint | boolean | number | string | symbol | undefined | null | InstanceType<T>}
  */
 export const is = (/** @type {T} */ type, /** @type {any} */ arg) => arg?.constructor === type
 
-_test.is = () => {
-  console.assert(is(Number, 42))
-  console.assert(is(Number, Number(42)))
-  // 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')))
-  // 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' }]])))
-}
-
-_test['is vs ‘toString.call’'] = () => {
-  class FooBar { }
-
-  console.assert(is(FooBar, new FooBar()))
-
-  const fakeFooBar = { [Symbol.toStringTag]: 'FooBar' }
+/**
+ * @typedef {{
+ *   [attributeOrSelector: string]: string | number | JcssNode;
+ * }} JcssNode
+ *
+ * The type of arguments of the `jcss` helper.
+ */
 
-  console.assert(({}).toString.call(new FooBar()) === '[object Object]')
-  console.assert(({}).toString.call(fakeFooBar) === '[object FooBar]')
-}
+/**
+ * @typedef {Record<string, JcssNode>} JcssRoot
+ *
+ * The type of arguments of the `jcss` helper.
+ */
 
 const _jcss = (
   /** @type {JcssNode} */ node,
@@ -850,12 +551,6 @@ const _jcss = (
   }
 }
 
-/**
- * ```ts
- * export function jcss(root: JcssRoot, splitter?: string): string;
- * ```
- */
-
 /**
  * A simple CSS-in-JS helper.
  *
@@ -886,206 +581,6 @@ export const jcss = (/** @type {JcssRoot} */ root, splitter = '$$') => {
   return result.join('')
 }
 
-_test['jcss: #1'] = () => {
-  const actual = jcss({
-    a: {
-      color: 'red',
-      margin: 1,
-      '.c': { margin: 2, padding: 2 },
-      padding: 1
-    }
-  })
-
-  const expected = `
-    a{
-      color:red;
-      margin:1
-    }
-    a.c{
-      margin:2;
-      padding:2
-    }
-    a{
-      padding:1
-    }`.replace(/\n\s*/g, '')
-
-  console.assert(actual === expected)
-}
-
-_test['jcss: #2'] = () => {
-  const actual = jcss({
-    a: {
-      '.b': {
-        color: 'red',
-        margin: 1,
-        '.c': { margin: 2, padding: 2 },
-        padding: 1
-      }
-    }
-  })
-
-  const expected = `
-    a.b{
-      color:red;
-      margin:1
-    }
-    a.b.c{
-      margin:2;
-      padding:2
-    }
-    a.b{
-      padding:1
-    }`.replace(/\n\s*/g, '')
-
-  console.assert(actual === expected)
-}
-
-_test['jcss: #3'] = () => {
-  const actual = jcss({
-    '@font-face$$1': {
-      fontFamily: 'Jackens',
-      src$$1: 'url(otf/jackens.otf)',
-      src$$2: "url(otf/jackens.otf) format('opentype')," +
-        "url(svg/jackens.svg) format('svg')",
-      fontWeight: 'normal',
-      fontStyle: 'normal'
-    },
-    '@font-face$$2': {
-      fontFamily: 'C64',
-      src: 'url(fonts/C64_Pro_Mono-STYLE.woff)'
-    },
-    '@keyframes spin': {
-      '0%': { transform: 'rotate(0deg)' },
-      '100%': { transform: 'rotate(360deg)' }
-    },
-    div: {
-      border: 'solid red 1px',
-      '.c1': { 'background-color': '#000' },
-      ' .c1': { backgroundColor: 'black' },
-      '.c2': { backgroundColor: 'rgb(0,0,0)' }
-    },
-    '@media(min-width:200px)': {
-      div: { margin: 0, padding: 0 },
-      span: { color: '#000' }
-    }
-  })
-
-  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
-    }
-    @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
-      }
-      span{
-        color:#000
-      }
-    }`.replace(/\n\s*/g, '')
-
-  console.assert(actual === expected)
-}
-
-_test['jcss: #4'] = () => {
-  const actual = jcss({
-    a: {
-      '.b,.c': {
-        margin: 1,
-        '.d': {
-          margin: 2
-        }
-      }
-    }
-  })
-
-  const expected = `
-    a.b,a.c{
-      margin:1
-    }
-    a.b.d,a.c.d{
-      margin:2
-    }`.replace(/\n\s*/g, '')
-
-  console.assert(actual === expected)
-}
-
-_test['jcss: #5'] = () => {
-  const actual = jcss({
-    '.b,.c': {
-      margin: 1,
-      '.d': {
-        margin: 2
-      }
-    }
-  })
-
-  const expected = `
-    .b,.c{
-      margin:1
-    }
-    .b.d,.c.d{
-      margin:2
-    }`.replace(/\n\s*/g, '')
-
-  console.assert(actual === expected)
-}
-
-_test['jcss: #6'] = () => {
-  const actual = jcss({
-    '.a,.b': {
-      margin: 1,
-      '.c,.d': {
-        margin: 2
-      }
-    }
-  })
-
-  const expected = `
-    .a,.b{
-      margin:1
-    }
-    .a.c,.a.d,.b.c,.b.d{
-      margin:2
-    }`.replace(/\n\s*/g, '')
-
-  console.assert(actual === expected)
-}
-
-/**
- * ```ts
- * export function jsOnParse(handlers: Record<string, Function>, text: string): any;
- * ```
- */
-
 /**
  * `JSON.parse` with “JavaScript turned on”.
  *
@@ -1123,49 +618,6 @@ export const jsOnParse = (
   return value
 })
 
-_test.jsOnParse = () => {
-  const handlers = {
-    $hello: (/** @type {string} */ name) => `Hello ${name}!`,
-    $foo: () => 'bar'
-  }
-  const actual = jsOnParse(handlers, `
-  [
-    {
-      "$hello": ["World"]
-    },
-    {
-      "nested": {
-        "$hello": ["nested World"]
-      },
-      "one": 1,
-      "two": 2
-    },
-    {
-      "$foo": []
-    },
-    {
-      "$foo": ["The parent object does not have exactly one property!"],
-      "one": 1,
-      "two": 2
-    }
-  ]`)
-  const expected = [
-    'Hello World!',
-    {
-      nested: 'Hello nested World!',
-      one: 1,
-      two: 2
-    },
-    'bar',
-    {
-      $foo: ['The parent object does not have exactly one property!'],
-      one: 1,
-      two: 2
-    }]
-
-  console.assert(eq(actual, expected))
-}
-
 const _locale = (
   /** @type {Record<string, Record<string, string | Record<string, string>>>} */ locales,
   /** @type {string} */ language,
@@ -1184,16 +636,6 @@ const _locale = (
   return is(String, t) ? t : text
 }
 
-/**
- * ```ts
- * export function locale(
- *   locales: Record<string, Record<string, string | Record<string, string>>>,
- *   defaultLanguage: string,
- *   languages?: readonly string[]
- * ): (text?: string, version?: string) => string;
- * ```
- */
-
 /**
  * Language translations helper.
  */
@@ -1213,48 +655,15 @@ export const locale = (
   return _locale.bind(0, locales, defaultLanguage)
 }
 
-_test.locale = () => {
-  const locales = {
-    pl: {
-      Password: 'Hasło',
-      button: { Login: 'Zaloguj' }
-    }
-  }
-  const _ = locale(locales, 'pl', [])
-
-  console.assert(_('Login') === 'Login')
-  console.assert(_('Password') === 'Hasło')
-
-  console.assert(_('Undefined text') === 'Undefined text')
-
-  console.assert(_('Login', 'button') === 'Zaloguj')
-
-  console.assert(_('Password', 'undefined_version') === 'Hasło')
-  console.assert(_('Undefined text', 'undefined_version') === 'Undefined text')
-
-  console.assert(_('toString') === 'toString')
-  console.assert(_('toString', 'undefined_version') === 'toString')
-}
-
-/**
- * ```ts
- * export function nanolight(
- *   pattern: RegExp,
- *   highlighters: ((chunk: string, index: number) => HArgs[1])[],
- *   code: string
- * ): HArgs[1][];
- * ```
- */
-
 /**
  * A generic helper for syntax highlighting (see also `nanolightJs`).
  */
 export const nanolight = (
   /** @type {RegExp} */ pattern,
-  /** @type {((chunk: string, index: number) => HArgs[1])[]} */ highlighters,
+  /** @type {((chunk: string, index: number) => import('./h.js').HArgs[1])[]} */ highlighters,
   /** @type {string} */ code
 ) => {
-  const /** @type {HArgs[1][]} */ result = []
+  const /** @type {import('./h.js').HArgs[1][]} */ result = []
 
   code.split(pattern).forEach((chunk, index) => {
     index %= highlighters.length
@@ -1266,12 +675,6 @@ export const nanolight = (
   return result
 }
 
-/**
- * ```ts
- * export function nanolightJs(codeJs: string): HArgs[1][];
- * ```
- */
-
 /**
  * A helper for highlighting JavaScript.
  */
@@ -1290,19 +693,6 @@ export const nanolightJs = nanolight.bind(0,
   ]
 )
 
-_test.nanolightJs = () => {
-  const codeJs = 'const answerToLifeTheUniverseAndEverything = 42'
-
-  console.assert(h('pre', ['code', ...nanolightJs(codeJs)]).outerHTML ===
-    '<pre><code><b>const</b> <i>answerToLifeTheUniverseAndEverything</i> <b>=</b> <u>42</u></code></pre>')
-}
-
-/**
- * ```ts
- * export function plUral(singular: string, plural2: string, plural5: string, value: number): string;
- * ```
- */
-
 /**
  * A helper for choosing the correct singular and plural.
  */
@@ -1324,30 +714,6 @@ export const plUral = (
         : plural5
 }
 
-_test.plUral = () => {
-  // @ts-expect-error
-  const auto = plUral.bind(null, 'auto', 'auta', 'aut')
-
-  console.assert(auto(0) === 'aut')
-  console.assert(auto(1) === 'auto')
-  console.assert(auto(17) === 'aut')
-  console.assert(auto(42) === 'auta')
-
-  // @ts-expect-error
-  const car = plUral.bind(null, 'car', 'cars', 'cars')
-
-  console.assert(car(0) === 'cars')
-  console.assert(car(1) === 'car')
-  console.assert(car(17) === 'cars')
-  console.assert(car(42) === 'cars')
-}
-
-/**
- * ```ts
- * export function pro(ref: any): any;
- * ```
- */
-
 /**
  * A helper that protect calls to nested properties by `Proxy` which initializes non-existent values with an empty object.
  */
@@ -1358,40 +724,6 @@ export const pro = (/** @type {any} */ ref) => new Proxy(ref, {
   }
 })
 
-_test.pro = () => {
-  const ref = {}
-
-  pro(ref).one.two[3][4] = 1234
-
-  console.assert(eq(ref, { one: { two: { 3: { 4: 1234 } } } }))
-
-  pro(ref).one.two.tree = 123
-
-  console.assert(eq(ref, { one: { two: { 3: { 4: 1234 }, tree: 123 } } }))
-
-  pro(ref).one.two = undefined
-
-  console.assert(eq(ref, { one: { two: undefined } }))
-
-  delete pro(ref).one.two
-
-  console.assert(eq(ref, { one: {} }))
-
-  pro(ref).one.two.three.four
-
-  console.assert(eq(ref, { one: { two: { three: { four: {} } } } }))
-
-  pro(ref).one.two.three.four = 1234
-
-  console.assert(eq(ref, { one: { two: { three: { four: 1234 } } } }))
-}
-
-/**
- * ```ts
- * export function refsInfo(...refs: any[]): [string, string, string[]][];
- * ```
- */
-
 /**
  * A helper that provides information about the given `refs`.
  *
@@ -1407,81 +739,15 @@ export const refsInfo = (/** @type {any[]} */ ...refs) => {
     }
   })
 
-  return Array.from(fns.values()).map(/** @returns {[string, string, string[]]} */ fn => [
+  return Array.from(fns.values()).map(/** @return {[string, string, string[]]} */ fn => [
     fn.name,
     Object.getPrototypeOf(fn)?.name ?? '',
     Object.getOwnPropertyNames(fn.prototype ?? Object.create(null)).sort()
   ]).sort((a, b) => -(a[0] < b[0]))
 }
 
-_test.refsInfo = () => {
-  const info = refsInfo(Array, Function)
-
-  console.assert(info.find(([name]) => name === 'Array')?.[2]?.includes?.('length'))
-  console.assert(info.find(([name]) => name === 'Function')?.[2]?.includes?.('length'))
-}
-
-_test['refsInfo: browserFingerprint'] = () => {
-  const browserFingerprint = () => {
-    // @ts-expect-error
-    const refs = Object.getOwnPropertyNames(window).map(name => window[name])
-    const info = refsInfo(...refs)
-    const json = JSON.stringify(info)
-    const hash = Array(32).fill(0)
-    let j = 0
-
-    for (let i = 0; i < json.length; i++) {
-      let charCode = json.charCodeAt(i)
-
-      while (charCode > 0) {
-        hash[j] = hash[j] ^ (charCode & 15)
-        charCode >>= 4
-        j = (j + 1) & 31
-      }
-    }
-
-    return hash.map(x => x.toString(16)).join('')
-  }
-
-  console.log(browserFingerprint())
-}
-
-/**
- * ```ts
- * export function s<T extends keyof SVGElementTagNameMap>(tag: T, ...args: HArgs[1][]): SVGElementTagNameMap[T];
- * export function s<N extends Node>(node: N, ...args: HArgs[1][]): N;
- * export function s(...args: HArgs): Node;
- * ```
- */
-
-/**
- * A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style helper for creating and modifying `SVGElement`s (see also `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.
- *   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`.
- *   An attribute equal to `false` causes the attribute to be removed by `removeAttributeNS`.
- * - All other arguments of type `null` or `undefined` are simply ignored.
- * - All other arguments of type `Node` are appended to the element being created or modified.
- * - All other arguments of type `string`/`number` are converted to `Text` nodes and appended to the element being created or modified.
- * - All other arguments of type `HArgs` are passed to `s` and the results are appended to the element being created or modified.
- */
-export const s = _h('http://www.w3.org/2000/svg')
-
-const _ZEROS = '0'.repeat(16)
-let _counter = 0
-
-/**
- * ```ts
- * export function uuid1(options?: {
- *   date?: Date;
- *   node?: string;
- * }): string;
- * ```
- */
+const ZEROS = '0'.repeat(16)
+let counter = 0
 
 /**
  * A helper that generates a UUID v1 identifier (with a creation timestamp).
@@ -1493,9 +759,9 @@ export const uuid1 = ({
   date = new Date(),
   node = Math.random().toString(16).slice(2)
 } = {}) => {
-  const time = _ZEROS + (10_000 * (+date + 12_219_292_800_000)).toString(16)
+  const time = ZEROS + (10000 * (+date + 12219292800000)).toString(16)
 
-  _counter = (_counter + 1) & 0x3fff
+  counter = (counter + 1) & 16383
 
   return time.slice(-8).concat(
     '-',
@@ -1504,31 +770,8 @@ export const uuid1 = ({
     -1,
     time.slice(-15, -12),
     '-',
-    (8 | (_counter >> 12)).toString(16),
-    (_ZEROS + (_counter & 0xfff).toString(16)).slice(-3),
+    (8 | (counter >> 12)).toString(16),
+    (ZEROS + (counter & 4095).toString(16)).slice(-3),
     '-',
-    (_ZEROS + node).slice(-12))
-}
-
-_test.uuid1 = () => {
-  for (let counter = 1; counter <= 0x5678; ++counter) {
-    const uuid = uuid1()
-
-    counter === 0x0001 && console.assert(uuid.split('-')[3] === '8001')
-    counter === 0x0fff && console.assert(uuid.split('-')[3] === '8fff')
-    counter === 0x1000 && console.assert(uuid.split('-')[3] === '9000')
-    counter === 0x2345 && console.assert(uuid.split('-')[3] === 'a345')
-    counter === 0x3456 && console.assert(uuid.split('-')[3] === 'b456')
-    counter === 0x4000 && console.assert(uuid.split('-')[3] === '8000')
-    counter === 0x4567 && console.assert(uuid.split('-')[3] === '8567')
-  }
-}
-
-_test['uuid1: node'] = () => {
-  console.assert(uuid1({ node: '000123456789abc' }).split('-')[4] === '123456789abc')
-  console.assert(uuid1({ node: '123456789' }).split('-')[4] === '000123456789')
-}
-
-_test['uuid1: date'] = () => {
-  console.assert(uuid1({ date: new Date(323325e6) }).startsWith('c1399400-9a71-11bd'))
+    (ZEROS + node).slice(-12))
 }

package/package.json

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