@jackens/nnn 2024.2.12 → 2024.2.17

package/chartable.d.ts

@@ -6,32 +6,26 @@
  * - `gapX`: X axis spacing
  * - `gapY`: Y axis spacing
  * - `headerColumn`: flag indicating that `table` has a header column (with X axis labels)
- * - `id`: chart id
- * - `left`: left padding (for data series labels)
+ * - `left`: left padding
  * - `maxY`: number of Y axis lines
  * - `reverse`: flag to reverse all data series
  * - `right`: right padding (for data series labels)
  * - `rotate`: flag to rotate X axis labels
- * - `singleScale`: flag to force single scale
  * - `table`: `HTMLTableElement` to extract data, data series labels and X axis labels
- * - `title`: chart title
- * - `top`: top padding (for the title)
+ * - `top`: top padding
  */
-export function chartable({ bottom, gapX, gapY, headerColumn, id, left, maxY, reverse, right, rotate, singleScale, table, title, top }: {
+export function chartable({ bottom, gapX, gapY, headerColumn, left, maxY, reverse, right, rotate, table, top }: {
     bottom?: number;
     gapX?: number;
     gapY?: number;
     headerColumn?: boolean;
-    id?: string;
     left?: number;
     maxY?: number;
     reverse?: boolean;
     right?: number;
     rotate?: boolean;
-    singleScale?: boolean;
     table: HTMLTableElement;
-    title?: string;
     top?: number;
-}): SVGSVGElement;
+}): Node;
 
 export const tests: {};

package/chartable.js

@@ -1,6 +1,7 @@
 import { s } from './h.js'
 
 const COLORS = ['#e22', '#e73', '#fc3', '#ad4', '#4d9', '#3be', '#45d', '#c3e']
+const PADDING = 15
 
 /**
  * A helper for creating a chart based on a table (conf. <https://jackens.github.io/nnn/chartable/>).
@@ -10,31 +11,25 @@ const COLORS = ['#e22', '#e73', '#fc3', '#ad4', '#4d9', '#3be', '#45d', '#c3e']
  * - `gapX`: X axis spacing
  * - `gapY`: Y axis spacing
  * - `headerColumn`: flag indicating that `table` has a header column (with X axis labels)
- * - `id`: chart id
- * - `left`: left padding (for data series labels)
+ * - `left`: left padding
  * - `maxY`: number of Y axis lines
  * - `reverse`: flag to reverse all data series
  * - `right`: right padding (for data series labels)
  * - `rotate`: flag to rotate X axis labels
- * - `singleScale`: flag to force single scale
  * - `table`: `HTMLTableElement` to extract data, data series labels and X axis labels
- * - `title`: chart title
- * - `top`: top padding (for the title)
+ * - `top`: top padding
  *
  * @param {{
  *   bottom?: number;
  *   gapX?: number;
  *   gapY?: number;
  *   headerColumn?: boolean;
- *   id?: string;
  *   left?: number;
  *   maxY?: number;
  *   reverse?: boolean;
  *   right?: number;
  *   rotate?: boolean;
- *   singleScale?: boolean;
  *   table: HTMLTableElement;
- *   title?: string;
  *   top?: number;
  * }} options
  */
@@ -43,31 +38,28 @@ export const chartable = ({
   gapX = 70,
   gapY = 30,
   headerColumn = false,
-  id,
-  left = 200,
+  left = 300,
   maxY = 10,
   reverse = false,
-  right = 200,
+  right = 100,
   rotate = false,
-  singleScale = false,
   table,
-  title,
-  top = 70
+  top = PADDING
 }) => {
-  const /** @type {number[][]} */ zxY = []
+  const /** @type {number[][]} */ zxValues = []
   const /** @type {string[]}   */ xLabels = []
   const /** @type {string[]}   */ zLabels = []
 
   table.querySelectorAll('tr').forEach((row, r) =>
-    // @ts-ignore
+    // @ts-expect-error
     row.querySelectorAll('td,th').forEach((/** @type {HTMLTableCellElement} */ col, c) => {
       const x = r - 1
       const z = c - +headerColumn
       const value = col.innerText
 
       if (x >= 0 && z >= 0) {
-        zxY[z] = zxY[z] ?? []
-        zxY[z][x] = parseFloat(value)
+        zxValues[z] = zxValues[z] ?? []
+        zxValues[z][x] = parseFloat(value)
       } else if (x >= 0 && z < 0) {
         xLabels[x] = value
       } else if (x < 0 && z >= 0) {
@@ -77,141 +69,90 @@ export const chartable = ({
 
   if (reverse) {
     xLabels.reverse()
-    zxY.forEach(xY => xY.reverse())
+    zxValues.forEach(xValues => xValues.reverse())
   }
 
-  let bestScales = [Infinity, -Infinity, Infinity, -Infinity, Infinity]
+  const maxX = zxValues[0].length
+  const xPx = Array.from({ length: maxX }, (_, x) => x * gapX)
+  const yPx = Array.from({ length: maxY }, (_, y) => y * gapY)
+  const width = gapX * (maxX - 1)
+  const height = gapY * (maxY - 1)
+  const svgW = left + width + right
+  const svgH = top + height + bottom
+
+  const /** @type {import('./h.js').HArgs1} */ gGraph = ['g', { transform: `translate(${left} ${top})` },
+    ...yPx.map(px => ['line', { x1: 0, x2: width, y1: px, y2: px, stroke: '#8888' }]),
+    ...xPx.map(px => ['line', { x1: px, x2: px, y1: 0, y2: height, stroke: '#8888' }])]
+  const /** @type {import('./h.js').HArgs1} */ gZColors = ['g', { transform: `translate(${PADDING} ${top})` }]
+  const /** @type {import('./h.js').HArgs1} */ gZLabels = ['g', { transform: `translate(${2 * PADDING} ${top})` }]
+  const /** @type {import('./h.js').HArgs} */ svg = ['svg',
+    { viewBox: `0 0 ${svgW} ${svgH}`, width: `${svgW}px`, height: `${svgH}px`, class: 'chartable' },
+    gGraph, gZColors, gZLabels]
+
+  if (xLabels.length > 0) {
+    svg.push(['g', { transform: `translate(${left} ${top + height + PADDING})` },
+      ...xPx.slice(0).map((xp, x) => ['text',
+        rotate
+          ? { x: 0, y: -xp, 'text-anchor': 'start', 'alignment-baseline': 'middle', transform: 'rotate(90)' }
+          : { x: xp, y: PADDING, 'text-anchor': 'middle', 'alignment-baseline': 'middle' },
+        xLabels[x]])])
+  }
 
-  const ranges = zxY.map(xY => {
-    xY = xY.filter(y => !isNaN(y))
-    return [Math.min(...xY), Math.max(...xY)]
-  })
+  const /** @type {[SVGElement, SVGElement, SVGTextElement][]} */ toUpdate = []
 
-  if (singleScale) {
-    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) {
-        let min2 = Infinity
-        let max2 = -Infinity
-
-        ranges.forEach(([min, max]) => {
-          if (min < min1 || max1 < max) {
-            if (min2 > min) {
-              min2 = min
-            }
-            if (max2 < max) {
-              max2 = max
-            }
-          }
-        })
-
-        let cost = 0
-
-        ranges.forEach(([min, max]) => {
-          if (min < max) {
-            cost += 1 - (max - min) / (min1 <= min && max <= max1 ? max1 - min1 : max2 - min2)
-          }
-        })
-
-        if (bestScales[4] > cost) {
-          bestScales = [min1, max1, min2, max2, cost]
-        }
-      }
-    }))
-  }
+  const onclick = (/** @type {number} */ z) => toUpdate.forEach(([gLeftYLabels, gRightYLabels, zLabel], z2) => {
+    s(gLeftYLabels, { $style: { display: z2 === z ? 'block' : 'none' } })
+    s(gRightYLabels, { $style: { display: z2 === z ? 'block' : 'none' } })
+    s(zLabel, { $style: { textDecoration: z2 === z ? 'underline' : 'none', cursor: 'pointer' } })
+  })
 
-  const [min1, max1, min2, max2] = bestScales
-  const maxX = zxY[0].length
-  const xi = Array.from({ length: maxX }, (_, x) => x * gapX)
-  const yi = Array.from({ length: maxY }, (_, y) => y * gapY)
-  const w = gapX * (maxX - 1)
-  const h = gapY * (maxY - 1)
-  const svgW = left + w + right
-  const svgH = top + h + bottom
-  const /** @type {import('./h.js').HArgs1} */ 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 {import('./h.js').HArgs1} */ lColors = ['g', { class: 'chartable-z-colors', transform: 'translate(-80 0)' }]
-  const /** @type {import('./h.js').HArgs1} */ lLabels = ['g', { class: 'chartable-z-labels', transform: 'translate(-95 0)' }]
-  const /** @type {import('./h.js').HArgs1} */ rColors = ['g', { class: 'chartable-z-colors', transform: 'translate(80 0)' }]
-  const /** @type {import('./h.js').HArgs1} */ 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}`
+  zxValues.forEach((values, z) => {
     const fill = COLORS[z % COLORS.length]
-    let [min, max] = ranges[z]
-
-    if (min1 <= min && max <= max1) {
-      min = min1
-      max = max1
-      lColors.push(['circle', { class: cls, cx: 0, cy: gapY * (lColors.length - 2), r: 5, fill }])
-      lLabels.push(['text',
-        { x: 0, y: gapY * (lLabels.length - 2), 'text-anchor': 'end', 'alignment-baseline': 'middle' },
-        zLabels[z]])
-    } else {
-      min = min2
-      max = max2
-      rColors.push(['circle', { class: cls, cx: 0, cy: gapY * (rColors.length - 2), r: 5, fill }])
-      rLabels.push(['text',
-        { x: 0, y: gapY * (rLabels.length - 2), 'text-anchor': 'start', 'alignment-baseline': 'middle' },
-        zLabels[z]])
-    }
-
-    const y = xa.map(x => isNaN(x) ? x : h * (max - x) / (max - min))
-
-    xi.forEach((x, i) => {
-      if (!isNaN(y[i])) {
-        graph.push(['circle', { class: cls, cx: x, cy: y[i], r: 5, fill }])
-
-        if (!isNaN(y[i - 1])) {
-          graph.push(['line', { class: cls, x1: x, x2: xi[i - 1], y1: y[i], y2: y[i - 1], stroke: fill }])
+    const minValue = Math.min(...values.filter(value => !isNaN(value)))
+    const maxValue = Math.max(...values.filter(value => !isNaN(value)))
+
+    const valuesPx = values.map(value => isNaN(value) ? value : height * (maxValue - value) / (maxValue - minValue))
+
+    const gLeftYLabels = s('g', { transform: `translate(${left - PADDING} ${top})` },
+      ...yPx.map((yp, y) => ['text',
+        { x: 0, y: yp, 'text-anchor': 'end', 'alignment-baseline': 'middle' },
+        (maxValue - (maxValue - minValue) / maxY * (y + 1)).toFixed(2)]))
+
+    const gRightYLabels = s('g', { transform: `translate(${left + width + PADDING} ${top})` },
+      ...yPx.map((yp, y) => ['text',
+        { x: 0, y: yp, 'text-anchor': 'start', 'alignment-baseline': 'middle' },
+        (maxValue - (maxValue - minValue) / maxY * (y + 1)).toFixed(2)]))
+
+    svg.push(gLeftYLabels, gRightYLabels)
+
+    const zLabel = s('text', {
+      x: 0,
+      y: gapY * (gZLabels.length - 2),
+      'text-anchor': 'start',
+      'alignment-baseline': 'middle',
+      $onclick: () => onclick(z)
+    },
+    zLabels[z])
+
+    gZLabels.push(zLabel)
+    gZColors.push(['circle', { cx: 0, cy: gapY * (gZColors.length - 2), r: 5, fill }])
+
+    toUpdate.push([gLeftYLabels, gRightYLabels, zLabel])
+
+    xPx.forEach((px, x) => {
+      if (!isNaN(valuesPx[x])) {
+        gGraph.push(['g', ['circle', { cx: px, cy: valuesPx[x], r: 5, fill }]])
+
+        if (!isNaN(valuesPx[x - 1])) {
+          gGraph.push(['line', { x1: px, x2: xPx[x - 1], y1: valuesPx[x], y2: valuesPx[x - 1], stroke: fill }])
         }
       }
     })
   })
 
-  return s('svg', {
-    viewBox: `0 0 ${svgW} ${svgH}`,
-    width: `${svgW}px`,
-    height: `${svgH}px`,
-    class: 'chartable'
-  }, id != null ? { id } : null, title != null
-    ? ['text',
-        { class: 'chartable-title', x: svgW / 2, y: top / 2, 'text-anchor': 'middle', 'alignment-baseline': 'middle' },
-        title]
-    : null,
-  graph,
-  min1 < Infinity
-    ? ['g', { class: 'chartable-left', transform: `translate(${left} ${top})` },
-        ['g', { class: 'chartable-y-labels', transform: 'translate(-15 0)' },
-          ...yi.map((y, i) => ['text',
-            { x: 0, y, 'text-anchor': 'end', 'alignment-baseline': 'middle' },
-            yLabel(min1, max1, i)])],
-        lColors, lLabels]
-    : null,
-  min2 < Infinity
-    ? ['g', { class: 'chartable-right', transform: `translate(${left + w} ${top})` },
-        ['g', { class: 'chartable-y-labels', transform: 'translate(15 0)' },
-          ...yi.map((y, i) => ['text',
-            { x: 0, y, 'text-anchor': 'start', 'alignment-baseline': 'middle' },
-            yLabel(min2, max2, i)])],
-        rColors, rLabels]
-    : null,
-  xLabels.length > 0
-    ? ['g', { transform: `translate(${left} ${top + h})` },
-        ['g', { class: 'chartable-x-labels', transform: 'translate(0 15)' },
-          ...xi.slice(0).map((x, i) => ['text', rotate
-            ? { x: 0, y: -x, 'text-anchor': 'start', 'alignment-baseline': 'hanging', transform: 'rotate(90)' }
-            : { x, y: 0, 'text-anchor': 'middle', 'alignment-baseline': 'hanging' },
-          xLabels[i]])]]
-    : null
-  )
+  onclick(0)
+
+  return s(...svg)
 }
 
 export const tests = {}

package/escape.js

@@ -23,7 +23,7 @@ export const escape = (
 
 export const tests = {
   escape: (/** @type {import('bun:test').Expect} */ expect) => {
-    // @ts-ignore
+    // @ts-expect-error
     const /** @type {EscapeMap} */ escapeMap = new Map([
       [undefined, () => 'NULL'],
       [Array, (/** @type {any[]} */ values) => escapeValues(escapeMap, values).join(', ')],
@@ -33,7 +33,7 @@ export const tests = {
       [String, (/** @type {string} */ value) => `'${value.replace(/'/g, "''")}'`]
     ])
 
-    // @ts-ignore
+    // @ts-expect-error
     const sql = escape.bind(null, escapeMap)
 
     const actual = sql`

package/h.js

@@ -44,10 +44,10 @@ const _h = (/** @type {string?=} */ namespaceURI) => {
       if (arg instanceof Node) {
         child = arg
       } else if (is(String, arg) || is(Number, arg)) {
-        // @ts-ignore
+        // @ts-expect-error
         child = new Text(arg)
       } else if (is(Array, arg)) {
-        // @ts-ignore
+        // @ts-expect-error
         child = h(...arg)
       } else if (arg != null) {
         for (const name in arg) {
@@ -57,19 +57,19 @@ const _h = (/** @type {string?=} */ namespaceURI) => {
             const name1 = name.slice(1)
 
             if (is(Object, value)) {
-              // @ts-ignore
+              // @ts-expect-error
               node[name1] = node[name1] ?? {}
-              // @ts-ignore
+              // @ts-expect-error
               Object.assign(node[name1], value)
             } else {
-              // @ts-ignore
+              // @ts-expect-error
               node[name1] = value
             }
           } else if (node instanceof Element) {
             const indexOfColon = name.indexOf(':')
 
             if (indexOfColon >= 0) {
-              // @ts-ignore
+              // @ts-expect-error
               const /** @type {string=} */ ns = NS[name.slice(0, indexOfColon)]
 
               if (ns != null) {
@@ -197,17 +197,17 @@ export const tests = {
   'h: nested properties': (/** @type {import('bun:test').Expect} */ expect) => {
     const div = h('div')
 
-    // @ts-ignore
+    // @ts-expect-error
     expect(div.key).toBeUndefined()
 
     h(div, { $key: { one: 1 } })
 
-    // @ts-ignore
+    // @ts-expect-error
     expect(div.key).toEqual({ one: 1 })
 
     h(div, { $key: { two: 2 } })
 
-    // @ts-ignore
+    // @ts-expect-error
     expect(div.key).toEqual({ one: 1, two: 2 })
   }
 }

package/has.js

@@ -16,7 +16,7 @@ export const tests = {
     expect('null' in obj).toBe(true)
     expect(has('null', obj)).toBe(true)
 
-    // @ts-ignore
+    // @ts-expect-error
     expect(null in obj).toBe(true)
     expect(has(null, obj)).toBe(false)
 
@@ -28,7 +28,7 @@ export const tests = {
     let typeError
 
     try {
-      // @ts-ignore
+      // @ts-expect-error
       'key' in null
     } catch (error) {
       typeError = error

package/is.js

@@ -53,7 +53,7 @@ export const tests = {
 
     const fakeFooBar = {}
 
-    // @ts-ignore
+    // @ts-expect-error
     fakeFooBar[Symbol.toStringTag] = FooBar.name
 
     expect(is(FooBar, fakeFooBar)).toBe(false)

package/jsOnParse.js

@@ -31,7 +31,7 @@ export const jsOnParse = (
     }
 
     if (has(key, handlers) && is(Array, value[key])) {
-      // @ts-ignore
+      // @ts-expect-error
       return handlers[key](...value[key])
     }
   }

package/nanolightJs.js

@@ -4,7 +4,7 @@ import { nanolight } from './nanolight.js'
 /**
  * A helper for highlighting JavaScript.
  */
-// @ts-ignore
+// @ts-expect-error
 export const nanolightJs = nanolight.bind(0,
   /('.*?'|".*?"|`[\s\S]*?`)|(\/\/.*?\n|\/\*[\s\S]*?\*\/)|(any|bigint|break|boolean|case|catch|const|continue|debugger|default|delete|do|else|eval|export|extends|false|finally|for|from|function|goto|if|import|in|instanceof|is|keyof|let|NaN|new|number|null|package|return|string|super|switch|symbol|this|throw|true|try|type|typeof|undefined|unknown|var|void|while|with|yield)(?!\w)|([<>=.?:&|!^~*/%+-])|(0x[\dabcdef]+|0o[01234567]+|0b[01]+|\d+(?:\.[\d_]+)?(?:e[+-]?[\d_]+)?)|([$\w]+)(?=\()|([$\wąćęłńóśżźĄĆĘŁŃÓŚŻŹ]+)/,
   [

package/package.json

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

package/pick.js

@@ -2,45 +2,19 @@
  * A helper that implements TypeScript’s `Pick` utility type.
  *
  * @type {<T extends Partial<Record<PropertyKey, any>>, K extends (keyof T)[]>(obj: T, keys: K) => Pick<T, K[number]>}
- * @template {Partial<Record<PropertyKey, any>>} T
- * @template {keyof T} K
  */
-export const pick = (/** @type {T} */ obj, /** @type {K[]} */ keys) => {
-  const result = {}
-
-  for (const key in obj) {
-    // @ts-ignore
-    if (keys.includes(key)) {
-      // @ts-ignore
-      result[key] = obj[key]
-    }
-  }
-
-  // @ts-ignore
-  return result
-}
+export const pick = (/** @type {Partial<Record<PropertyKey, any>>} */ obj, /** @type {any[]} */ keys) =>
+  // @ts-expect-error
+  Object.fromEntries(Object.entries(obj).filter(([key]) => keys.includes(key)))
 
 /**
  * A helper that implements TypeScript’s `Omit` utility type.
  *
  * @type {<T extends Partial<Record<PropertyKey, any>>, K extends (keyof T)[]>(obj: T, keys: K) => Omit<T, K[number]>}
- * @template {Partial<Record<PropertyKey, any>>} T
- * @template {keyof T} K
  */
-export const omit = (/** @type {T} */ obj, /** @type {K[]} */ keys) => {
-  const result = {}
-
-  for (const key in obj) {
-    // @ts-ignore
-    if (!keys.includes(key)) {
-      // @ts-ignore
-      result[key] = obj[key]
-    }
-  }
-
-  // @ts-ignore
-  return result
-}
+export const omit = (/** @type {Partial<Record<PropertyKey, any>>} */ obj, /** @type {any[]} */ keys) =>
+  // @ts-expect-error
+  Object.fromEntries(Object.entries(obj).filter(([key]) => !keys.includes(key)))
 
 export const tests = {
   pick: (/** @type {import('bun:test').Expect} */ expect) => {

package/plUral.js

@@ -20,7 +20,7 @@ export const plUral = (
 
 export const tests = {
   plUral: (/** @type {import('bun:test').Expect} */ expect) => {
-    // @ts-ignore
+    // @ts-expect-error
     const auto = plUral.bind(null, 'auto', 'auta', 'aut')
 
     expect(auto(0)).toEqual('aut')
@@ -28,7 +28,7 @@ export const tests = {
     expect(auto(17)).toEqual('aut')
     expect(auto(42)).toEqual('auta')
 
-    // @ts-ignore
+    // @ts-expect-error
     const car = plUral.bind(null, 'car', 'cars', 'cars')
 
     expect(car(0)).toEqual('cars')

package/pro.js

@@ -1,7 +1,7 @@
 /**
  * A helper that protects calls to nested properties by a `Proxy` that initializes non-existent values with an empty object.
  */
-// @ts-ignore
+// @ts-expect-error
 export const pro = (/** @type {any} */ ref) => new Proxy(ref, {
   get (target, key) {
     return pro(target[key] = target[key] ?? {})

package/readme.md

@@ -2,7 +2,7 @@
 
 Jackens’ JavaScript helpers.
 
-<sub>Version: <code class="version">2024.2.12</code></sub>
+<sub>Version: <code class="version">2024.2.17</code></sub>
 
 ## Installation
 
@@ -103,22 +103,19 @@ The type of arguments of the `jcss` helper.
 ### chartable
 
 ```ts
-export function chartable({ bottom, gapX, gapY, headerColumn, id, left, maxY, reverse, right, rotate, singleScale, table, title, top }: {
+export function chartable({ bottom, gapX, gapY, headerColumn, left, maxY, reverse, right, rotate, table, top }: {
     bottom?: number;
     gapX?: number;
     gapY?: number;
     headerColumn?: boolean;
-    id?: string;
     left?: number;
     maxY?: number;
     reverse?: boolean;
     right?: number;
     rotate?: boolean;
-    singleScale?: boolean;
     table: HTMLTableElement;
-    title?: string;
     top?: number;
-}): SVGSVGElement;
+}): Node;
 ```
 
 A helper for creating a chart based on a table (conf. <https://jackens.github.io/nnn/chartable/>).
@@ -128,16 +125,13 @@ Options:
 - `gapX`: X axis spacing
 - `gapY`: Y axis spacing
 - `headerColumn`: flag indicating that `table` has a header column (with X axis labels)
-- `id`: chart id
-- `left`: left padding (for data series labels)
+- `left`: left padding
 - `maxY`: number of Y axis lines
 - `reverse`: flag to reverse all data series
 - `right`: right padding (for data series labels)
 - `rotate`: flag to rotate X axis labels
-- `singleScale`: flag to force single scale
 - `table`: `HTMLTableElement` to extract data, data series labels and X axis labels
-- `title`: chart title
-- `top`: top padding (for the title)
+- `top`: top padding
 
 ### eq
 

package/refsInfo.js

@@ -32,7 +32,7 @@ export const tests = {
 
   'refsInfo: browserFingerprint': (/** @type {import('bun:test').Expect} */ expect) => {
     const browserFingerprint = () => {
-      // @ts-ignore
+      // @ts-expect-error
       const refs = Object.getOwnPropertyNames(window).map(name => window[name])
       const info = refsInfo(...refs)
       const json = JSON.stringify(info)

package/uuid1.js

@@ -18,7 +18,7 @@ export const uuid1 = ({
   return time.slice(-8).concat(
     '-',
     time.slice(-12, -8),
-    // @ts-ignore
+    // @ts-expect-error
     -1,
     time.slice(-15, -12),
     '-',