@jackens/nnn 2025.6.14 → 2025.9.3

package/nnn.d.ts

@@ -1,13 +1,13 @@
 /**
  * The type of arguments of the `c` helper.
  */
-export type CNode = {
-    [attributeOrSelector: string]: string | number | CNode | undefined;
+export type C_Node = {
+    [attribute_or_selector: string]: string | number | C_Node | undefined;
 };
 /**
  * The type of arguments of the `c` helper.
  */
-export type CRoot = Record<PropertyKey, CNode>;
+export type C_Root = Record<PropertyKey, C_Node>;
 /**
  * A simple JS-to-CSS (aka CSS-in-JS) helper.
  *
@@ -15,43 +15,39 @@ export type CRoot = Record<PropertyKey, CNode>;
  *
  * - Keys of sub-objects whose values are NOT objects are treated as CSS attribute, and values are treated as values of those CSS attributes; the concatenation of keys of all parent objects is a CSS rule.
  * - All keys ignore the part starting with a splitter (default: `$$`) sign until the end of the key (e.g. `src$$1` → `src`, `@font-face$$1` → `@font-face`).
- * - In keys specifying CSS attribute, all uppercase letters are replaced by lowercase letters with an additional `-` character preceding them (e.g. `fontFamily` → `font-family`).
+ * - In keys specifying CSS attribute, all uppercase letters are replaced by lowercase letters with an additional `-` character preceding them (e.g. `fontFamily` → `font-family`), while all `_` characters are replaced by `-` character (e.g. `font_family` → `font-family`).
  * - Commas in keys that makes a CSS rule cause it to “split” and create separate rules for each part (e.g. `{div:{margin:1,'.a,.b,.c':{margin:2}}}` → `div{margin:1}div.a,div.b,div.c{margin:2}`).
  * - Top-level keys that begin with `@` are not concatenated with sub-object keys.
  */
-export declare const c: (root: CRoot, splitter?: string) => string;
+export declare const c: (root: C_Root, splitter?: string) => string;
 /**
  * A tiny helper for parsing CSV.
  */
-export declare const csvParseRaw: (csv: string, separator?: string) => string[][];
+export declare const csv_parse: (csv: string, separator?: string) => string[][];
 /**
- * A tiny helper for parsing CSV.
- */
-export declare const csvParse: (csv: string, separator?: string) => Record<PropertyKey, string>[];
-/**
- * The type of arguments of the `escapeValues` and `escape` helpers.
+ * The type of arguments of the `escape_values` and `escape` helpers.
  */
-export type EscapeMap = Map<unknown, (value?: unknown) => string>;
+export type Escape_Map = Map<unknown, (value?: unknown) => string>;
 /**
- * A generic helper for escaping `values` by given `escapeMap`.
+ * A generic helper for escaping `values` by given `escape_map`.
  */
-export declare const escapeValues: (escapeMap: EscapeMap, values: unknown[]) => string[];
+export declare const escape_values: (escape_map: Escape_Map, values: unknown[]) => string[];
 /**
- * A generic helper for escaping `values` by given `escapeMap` (in *TemplateStrings* flavor).
+ * A generic helper for escaping `values` by given `escape_map` (in *TemplateStrings* flavor).
  */
-export declare const escape: (escapeMap: EscapeMap, template: TemplateStringsArray, ...values: unknown[]) => string;
+export declare const escape: (escape_map: Escape_Map, template: TemplateStringsArray, ...values: unknown[]) => string;
 /**
  * A helper that implements typographic corrections specific to Polish typography.
  */
-export declare const fixTypography: (node: Node) => void;
+export declare const fix_typography: (node: Node) => void;
 /**
  * The type of arguments of the `h` and `s` helpers.
  */
-export type HArgs1 = Record<PropertyKey, unknown> | null | undefined | Node | string | number | HArgs;
+export type H_Args_1 = Record<PropertyKey, unknown> | null | undefined | Node | string | number | H_Args;
 /**
  * The type of arguments of the `h` and `s` helpers.
  */
-export type HArgs = [string | Node, ...HArgs1[]];
+export type H_Args = [string | Node, ...H_Args_1[]];
 /**
  * A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style helper for creating and modifying `HTMLElement`s (see also `s`).
  *
@@ -64,9 +60,9 @@ export type HArgs = [string | Node, ...HArgs1[]];
  * - All other arguments of type `HArgs` are passed to `h` and the results are appended to the element being created or modified.
  */
 export declare const h: {
-    <T extends keyof HTMLElementTagNameMap>(tag: T, ...args1: HArgs1[]): HTMLElementTagNameMap[T];
-    <N extends Node>(node: N, ...args1: HArgs1[]): N;
-    (tagOrNode: string | Node, ...args1: HArgs1[]): Node;
+    <T extends keyof HTMLElementTagNameMap>(tag: T, ...args1: H_Args_1[]): HTMLElementTagNameMap[T];
+    <N extends Node>(node: N, ...args1: H_Args_1[]): N;
+    (tag_or_node: string | Node, ...args1: H_Args_1[]): Node;
 };
 /**
  * A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style helper for creating and modifying `SVGElement`s (see also `h`).
@@ -80,58 +76,68 @@ export declare const h: {
  * - All other arguments of type `HArgs` are passed to `s` and the results are appended to the element being created or modified.
  */
 export declare const s: {
-    <T extends keyof SVGElementTagNameMap>(tag: T, ...args1: HArgs1[]): SVGElementTagNameMap[T];
-    <N extends Node>(node: N, ...args1: HArgs1[]): N;
-    (tagOrNode: string | Node, ...args1: HArgs1[]): Node;
+    <T extends keyof SVGElementTagNameMap>(tag: T, ...args1: H_Args_1[]): SVGElementTagNameMap[T];
+    <N extends Node>(node: N, ...args1: H_Args_1[]): N;
+    (tag_or_node: string | Node, ...args1: H_Args_1[]): Node;
 };
 /**
  * A convenient shortcut for `s('svg', ['use', { 'xlink:href': '#' + id }], ...args)`.
  */
-export declare const svgUse: (id: string, ...args: HArgs1[]) => SVGSVGElement;
+export declare const svg_use: (id: string, ...args: H_Args_1[]) => SVGSVGElement;
 /**
  * A replacement for the `in` operator (not to be confused with the `for-in` loop) that works properly.
  */
-export declare const hasOwn: (ref: unknown, key: unknown) => boolean;
+export declare const has_own: (ref: unknown, key: unknown) => boolean;
 /**
  * A helper that checks if the given argument is of type `any[]`.
  */
-export declare const isArray: (arg: any) => arg is any[];
+export declare const is_array: (arg: any) => arg is any[];
+declare const FINITE_NUMBER: unique symbol;
+type Finite_Number = number & {
+    readonly [FINITE_NUMBER]: true;
+};
+/**
+ * A helper that checks if the given argument is of type `number` but not `±Infinity` nor `NaN`.
+ */
+export declare const is_finite_number: ((arg: unknown) => arg is Finite_Number);
 /**
  * A helper that checks if the given argument is of type `number`.
  */
-export declare const isNumber: (arg: any) => arg is number;
+export declare const is_number: (arg: unknown) => arg is number;
 /**
  * A helper that checks if the given argument is of type `Record<PropertyKey, unknown>`.
  */
-export declare const isRecord: (arg: any) => arg is Record<PropertyKey, unknown>;
+export declare const is_record: (arg: unknown) => arg is Record<PropertyKey, unknown>;
 /**
  * A helper that checks if the given argument is of type `string`.
  */
-export declare const isString: (arg: any) => arg is string;
+export declare const is_string: (arg: unknown) => arg is string;
+export {};
 /**
  * `JSON.parse` with “JavaScript turned on”.
  *
  * Objects having *exactly* one property which is present in the `handlers` map, i.e. objects of the form:
  *
  * ```js
- * { "«handlerName»": [«params»] }
+ * { "«handler_name»": [«params»] }
  * ```
  *
  * are replaced by the result of call
  *
  * ```js
- * handlers['«handlerName»'](...«params»)
+ * handlers['«handler_name»'](...«params»)
  * ```
  */
-export declare const jsOnParse: (handlers: Record<PropertyKey, Function>, text: string) => any;
+export declare const js_on_parse: (handlers: Record<PropertyKey, Function>, text: string) => any;
+import type { H_Args_1 } from './h.js';
 /**
- * A generic helper for syntax highlighting (see also `nanolightJs`).
+ * A generic helper for syntax highlighting (see also `nanolight_js`).
  */
-export declare const nanolight: (pattern: RegExp, highlighters: ((chunk: string, index: number) => HArgs1)[], code: string) => HArgs1[];
+export declare const nanolight: (pattern: RegExp, highlighters: ((chunk: string, index: number) => H_Args_1)[], code: string) => H_Args_1[];
 /**
  * A helper for highlighting JavaScript (see also `nanolight`).
  */
-export declare const nanolightJs: (code: string) => HArgs1[];
+export declare const nanolight_js: (code: string) => H_Args_1[];
 /**
  * A helper that implements TypeScript’s `Pick` utility type (see also `omit`).
  */
@@ -143,7 +149,7 @@ export declare const omit: <T, K extends keyof T>(ref: T, keys: unknown[]) => Om
 /**
  * A helper for choosing the correct singular and plural.
  */
-export declare const plUral: (singular: string, plural2: string, plural5: string, value: number) => string;
+export declare const pl_ural: (singular: string, plural_2: string, plural_5: string, value: number) => string;
 /**
  * A helper that protects calls to nested properties by a `Proxy` that initializes non-existent values with an empty object.
  */
@@ -153,4 +159,4 @@ export declare const pro: (ref: unknown) => any;
  *
  * - The optional `node` parameter should have the format `/^[0123456789abcdef]+$/`. Its value will be trimmed to last 12 characters and left padded with zeros.
  */
-export declare const uuid1: (date?: Date, node?: string) => string;
+export declare const uuid_v1: (date?: Date, node?: string) => string;

package/nnn.js

@@ -1,38 +1,40 @@
 // src/nnn/is.ts
-var isArray = Array.isArray;
-var isNumber = (arg) => typeof arg === "number";
-var isRecord = (arg) => typeof arg === "object" && arg != null && !isArray(arg);
-var isString = (arg) => typeof arg === "string";
+var is_array = Array.isArray;
+var is_finite_number = Number.isFinite;
+var is_number = (arg) => typeof arg === "number";
+var is_record = (arg) => typeof arg === "object" && arg != null && !is_array(arg);
+var is_string = (arg) => typeof arg === "string";
 
 // src/nnn/c.ts
-var _c = (node, prefix, result, split) => {
+var _c = (node, prefix, result, splitter) => {
   const queue = [[node, prefix]];
   while (queue.length > 0) {
-    const [style0, prefix0] = queue.shift() ?? [];
-    if (style0 == null || prefix0 == null) {
+    const [style_0, prefix_0] = queue.shift() ?? [];
+    if (style_0 == null || prefix_0 == null) {
       continue;
     }
-    if (isArray(style0)) {
-      result.push(prefix0, prefix0 !== "" ? "{" : "", style0.join(";"), prefix0 !== "" ? "}" : "");
+    if (is_array(style_0)) {
+      result.push(prefix_0, prefix_0 !== "" ? "{" : "", style_0.join(";"), prefix_0 !== "" ? "}" : "");
     } else {
       const todo = [];
       let attributes = [];
-      let attributesPushed = false;
-      for (const key in style0) {
-        const value = style0[key];
-        if (isString(value) || isNumber(value)) {
-          if (!attributesPushed) {
-            attributesPushed = true;
+      let attributes_pushed = false;
+      for (const key in style_0) {
+        const value = style_0[key];
+        if (is_string(value) || is_number(value)) {
+          if (!attributes_pushed) {
+            attributes_pushed = true;
             attributes = [];
-            todo.push([attributes, prefix0]);
+            todo.push([attributes, prefix_0]);
           }
-          attributes.push(`${split(key).replace(/([A-Z])/g, (_, letter) => "-" + letter.toLowerCase())}:${value}`);
+          const attribute = key.split(splitter)[0].replace(/_/g, "-").replace(/([A-Z])/g, (_, letter) => "-" + letter.toLowerCase());
+          attributes.push(`${attribute}:${value}`);
         } else if (value != null) {
-          attributesPushed = false;
-          const prefixN = [];
-          const keyChunks = key.split(",");
-          prefix0.split(",").forEach((prefixChunk) => keyChunks.forEach((keyChunk) => prefixN.push(prefixChunk + keyChunk)));
-          todo.push([value, prefixN.join(",")]);
+          attributes_pushed = false;
+          const prefix_n = [];
+          const key_chunks = key.split(",");
+          prefix_0.split(",").forEach((prefix_chunk) => key_chunks.forEach((key_chunk) => prefix_n.push(prefix_chunk + key_chunk)));
+          todo.push([value, prefix_n.join()]);
         }
       }
       queue.unshift(...todo);
@@ -40,67 +42,59 @@ var _c = (node, prefix, result, split) => {
   }
 };
 var c = (root, splitter = "$$") => {
-  const split = (text) => text.split(splitter)[0];
   const chunks = [];
   for (const key in root) {
     const value = root[key];
     if (value != null) {
       if (key[0] === "@") {
-        chunks.push(split(key) + "{");
-        _c(value, "", chunks, split);
+        chunks.push(key.split(splitter)[0] + "{");
+        _c(value, "", chunks, splitter);
         chunks.push("}");
       } else {
-        _c(value, split(key), chunks, split);
+        _c(value, key.split(splitter)[0], chunks, splitter);
       }
     }
   }
   return chunks.join("");
 };
-// src/nnn/csvParse.ts
-var csvParseRaw = (csv, separator = ",") => {
-  const regExp = new RegExp(`${separator}|(?<!")\\s*"((?:[^"]|"")*)"\\s*(?!")`, "g");
-  return csv.replace(/\r/g, "").replace(/\n+$/, "").replace(/\n|(?<!")("(?:[^"]|"")*")(?!")/g, (_, chunk) => chunk ?? "\r").split("\r").map((line) => line.replace(regExp, (_, chunk) => chunk == null ? "\r" : chunk.replace(/""/g, '"')).split("\r"));
-};
-var csvParse = (csv, separator = ",") => {
-  const rows = csvParseRaw(csv, separator);
-  const keys = rows.shift();
-  return keys != null ? rows.map((row) => keys.reduce((record, key, index) => {
-    record[key] = row[index];
-    return record;
-  }, {})) : [];
+// src/nnn/csv_parse.ts
+var csv_parse = (csv, separator = ",") => {
+  const main_pattern = /\n|(?<!")("(?:[^"]|"")*")(?!")/g;
+  const line_pattern = new RegExp(`${separator}|(?<!")\\s*"((?:[^"]|"")*)"\\s*(?!")`, "g");
+  return csv.replace(/\r/g, "").replace(/\n+$/, "").replace(main_pattern, (_, chunk) => chunk ?? "\r").split("\r").map((line) => line.replace(line_pattern, (_, chunk) => chunk == null ? "\r" : chunk.replace(/""/g, '"')).split("\r"));
 };
 // src/nnn/escape.ts
-var escapeValues = (escapeMap, values) => values.map((value) => (escapeMap.get(value?.constructor) ?? escapeMap.get(undefined))?.(value) ?? "");
-var escape = (escapeMap, template, ...values) => String.raw(template, ...escapeValues(escapeMap, values));
+var escape_values = (escape_map, values) => values.map((value) => (escape_map.get(value?.constructor) ?? escape_map.get(undefined))?.(value) ?? "");
+var escape = (escape_map, template, ...values) => String.raw(template, ...escape_values(escape_map, values));
 // src/nnn/h.ts
-var _h = (namespaceURI) => {
-  const createElement = namespaceURI == null ? (tag) => document.createElement(tag) : (tag) => document.createElementNS(namespaceURI, tag);
-  const h = (tagOrNode, ...args) => {
-    const node = isString(tagOrNode) ? createElement(tagOrNode) : tagOrNode;
+var _h = (namespace_uri) => {
+  const create_element = namespace_uri == null ? (tag) => document.createElement(tag) : (tag) => document.createElementNS(namespace_uri, tag);
+  const h = (tag_or_node, ...args) => {
+    const node = is_string(tag_or_node) ? create_element(tag_or_node) : tag_or_node;
     args.forEach((arg) => {
       let child = null;
       if (arg instanceof Node) {
         child = arg;
-      } else if (isArray(arg)) {
+      } else if (is_array(arg)) {
         child = h(...arg);
-      } else if (isRecord(arg)) {
+      } else if (is_record(arg)) {
         for (const name in arg) {
           const value = arg[name];
           if (name[0] === "$") {
             const name1 = name.slice(1);
-            if (isRecord(value)) {
-              node[name1] = node[name1] ?? {};
+            if (is_record(value)) {
+              node[name1] ??= {};
               Object.assign(node[name1], value);
             } else {
               node[name1] = value;
             }
           } else if (node instanceof Element) {
-            const indexOfColon = name.indexOf(":");
-            if (indexOfColon >= 0) {
-              const nsKey = name.slice(0, indexOfColon);
-              if (nsKey === "xlink") {
+            const index_of_colon = name.indexOf(":");
+            if (index_of_colon >= 0) {
+              const ns_key = name.slice(0, index_of_colon);
+              if (ns_key === "xlink") {
                 const ns = "http://www.w3.org/1999/xlink";
-                const basename = name.slice(indexOfColon + 1);
+                const basename = name.slice(index_of_colon + 1);
                 if (value === true) {
                   node.setAttributeNS(ns, basename, "");
                 } else if (value === false) {
@@ -120,7 +114,7 @@ var _h = (namespaceURI) => {
             }
           }
         }
-      } else if (isString(arg)) {
+      } else if (is_string(arg)) {
         child = document.createTextNode(arg);
       }
       if (child != null) {
@@ -133,54 +127,54 @@ var _h = (namespaceURI) => {
 };
 var h = _h();
 var s = _h("http://www.w3.org/2000/svg");
-var svgUse = (id, ...args) => s("svg", ["use", { "xlink:href": "#" + id }], ...args);
+var svg_use = (id, ...args) => s("svg", ["use", { "xlink:href": "#" + id }], ...args);
 
-// src/nnn/fixTypography.ts
+// src/nnn/fix_typography.ts
 var TAGS_TO_SKIP = ["IFRAME", "NOSCRIPT", "PRE", "SCRIPT", "STYLE", "TEXTAREA"];
-var fixTypography = (node) => {
+var fix_typography = (node) => {
   const queue = [node];
   while (queue.length > 0) {
-    const node0 = queue.shift();
-    if (node0 instanceof Element) {
-      node0.childNodes.forEach((childNode) => {
-        if (childNode instanceof Text) {
-          queue.push(childNode);
-        } else if (childNode instanceof Element && !TAGS_TO_SKIP.includes(childNode.tagName)) {
-          queue.push(childNode);
+    const node_0 = queue.shift();
+    if (node_0 instanceof Element) {
+      node_0.childNodes.forEach((child_node) => {
+        if (child_node instanceof Text) {
+          queue.push(child_node);
+        } else if (child_node instanceof Element && !TAGS_TO_SKIP.includes(child_node.tagName)) {
+          queue.push(child_node);
         }
       });
-    } else if (node0 instanceof Text) {
-      const nodeValue = node0.nodeValue?.trim?.();
-      if (nodeValue != null) {
-        let previousNode = node0;
-        nodeValue.split(/(\s|\(|„)([aiouwz—]\s)/gi).forEach((chunk, i) => {
+    } else if (node_0 instanceof Text) {
+      const node_value = node_0.nodeValue?.trim?.();
+      if (node_value != null) {
+        let previous_node = node_0;
+        node_value.split(/(\s|\(|„)([aiouwz—]\s)/gi).forEach((chunk, i) => {
           i %= 3;
-          const currentNode = i === 2 ? h("span", { style: "white-space:nowrap" }, chunk) : i === 1 ? document.createTextNode(chunk) : document.createTextNode(chunk.replace(/(\/(?=[^/\s])|\.(?=[^\s]))/g, "$1​"));
-          if (node0.parentNode != null) {
-            node0.parentNode.insertBefore(currentNode, previousNode.nextSibling);
+          const current_node = i === 2 ? h("span", { style: "white-space:nowrap" }, chunk) : i === 1 ? document.createTextNode(chunk) : document.createTextNode(chunk.replace(/(\/(?=[^/\s])|\.(?=[^\s]))/g, "$1​"));
+          if (node_0.parentNode != null) {
+            node_0.parentNode.insertBefore(current_node, previous_node.nextSibling);
           }
-          previousNode = currentNode;
+          previous_node = current_node;
         });
-        node0.parentNode?.removeChild(node0);
+        node_0.parentNode?.removeChild(node_0);
       }
     }
   }
 };
-// src/nnn/hasOwn.ts
-var hasOwn = (ref, key) => ref != null && Object.hasOwn(ref, key);
-// src/nnn/jsOnParse.ts
-var jsOnParse = (handlers, text) => JSON.parse(text, (key, value) => {
-  if (isRecord(value)) {
-    let isSecondKey = false;
+// src/nnn/has_own.ts
+var has_own = (ref, key) => ref != null && Object.hasOwn(ref, key);
+// src/nnn/js_on_parse.ts
+var js_on_parse = (handlers, text) => JSON.parse(text, (key, value) => {
+  if (is_record(value)) {
+    let is_second_key = false;
     for (key in value) {
-      if (isSecondKey) {
+      if (is_second_key) {
         return value;
       }
-      isSecondKey = true;
+      is_second_key = true;
     }
     const handler = handlers[key];
     const params = value[key];
-    if (handler instanceof Function && isArray(params)) {
+    if (handler instanceof Function && is_array(params)) {
       return handler(...params);
     }
   }
@@ -197,8 +191,8 @@ var nanolight = (pattern, highlighters, code) => {
   });
   return result;
 };
-// src/nnn/nanolightJs.ts
-var nanolightJs = nanolight.bind(0, /('.*?'|".*?"|`[\s\S]*?`)|(\/\/.*?\n|\/\*[\s\S]*?\*\/)|(any|bigint|break|boolean|case|catch|class|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_]*(?:\.[\d_]+)?(?:e[+-]?[\d_]+)?)|([$\w]+)(?=\()|([$\wąćęłńóśżźĄĆĘŁŃÓŚŻŹ]+)/, [
+// src/nnn/nanolight_js.ts
+var nanolight_js = nanolight.bind(0, /('.*?'|".*?"|`[\s\S]*?`)|(\/\/.*?\n|\/\*[\s\S]*?\*\/)|(any|bigint|break|boolean|case|catch|class|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_]*(?:\.[\d_]+)?(?:e[+-]?[\d_]+)?)|([$\w]+)(?=\()|([$\wąćęłńóśżźĄĆĘŁŃÓŚŻŹ]+)/, [
   (chunk) => chunk,
   (chunk) => ["span", { class: "string" }, chunk],
   (chunk) => ["span", { class: "comment" }, chunk],
@@ -211,47 +205,47 @@ var nanolightJs = nanolight.bind(0, /('.*?'|".*?"|`[\s\S]*?`)|(\/\/.*?\n|\/\*[\s
 // src/nnn/pick.ts
 var pick = (ref, keys) => Object.fromEntries(Object.entries(ref).filter(([key]) => keys.includes(key)));
 var omit = (ref, keys) => Object.fromEntries(Object.entries(ref).filter(([key]) => !keys.includes(key)));
-// src/nnn/plUral.ts
-var plUral = (singular, plural2, plural5, value) => {
-  const absValue = Math.abs(value);
-  const absValueMod10 = absValue % 10;
-  return value === 1 ? singular : (absValueMod10 === 2 || absValueMod10 === 3 || absValueMod10 === 4) && absValue !== 12 && absValue !== 13 && absValue !== 14 ? plural2 : plural5;
+// src/nnn/pl_ural.ts
+var pl_ural = (singular, plural_2, plural_5, value) => {
+  const abs_value = Math.abs(value);
+  const abs_value_mod_10 = abs_value % 10;
+  return value === 1 ? singular : (abs_value_mod_10 === 2 || abs_value_mod_10 === 3 || abs_value_mod_10 === 4) && abs_value !== 12 && abs_value !== 13 && abs_value !== 14 ? plural_2 : plural_5;
 };
 // src/nnn/pro.ts
 var pro = (ref) => new Proxy(ref, {
   get(target, key) {
-    return pro(target[key] = target[key] ?? {});
+    return pro(target[key] ??= {});
   }
 });
-// src/nnn/uuid1.ts
+// src/nnn/uuid_v1.ts
 var ZEROS = "0".repeat(16);
 var counter = 0;
-var uuid1 = (date = new Date, node = Math.random().toString(16).slice(2)) => {
+var uuid_v1 = (date = new Date, node = Math.random().toString(16).slice(2)) => {
   const time = ZEROS + (1e4 * (+date + 12219292800000)).toString(16);
   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));
 };
 export {
-  uuid1,
-  svgUse,
+  uuid_v1,
+  svg_use,
   s,
   pro,
-  plUral,
+  pl_ural,
   pick,
   omit,
-  nanolightJs,
+  nanolight_js,
   nanolight,
-  jsOnParse,
-  isString,
-  isRecord,
-  isNumber,
-  isArray,
-  hasOwn,
+  js_on_parse,
+  is_string,
+  is_record,
+  is_number,
+  is_finite_number,
+  is_array,
+  has_own,
   h,
-  fixTypography,
-  escapeValues,
+  fix_typography,
+  escape_values,
   escape,
-  csvParseRaw,
-  csvParse,
+  csv_parse,
   c
 };

package/package.json

@@ -5,7 +5,7 @@
     "c",
     "CSS-in-JS",
     "CSV",
-    "csvParse",
+    "csv_parse",
     "DOM",
     "escape",
     "h",
@@ -14,13 +14,14 @@
     "HyperScript",
     "in",
     "is",
-    "isArray",
-    "isNumber",
-    "isRecord",
-    "isString",
+    "is_array",
+    "is_finite_number",
+    "is_number",
+    "is_record",
+    "is_string",
     "JS-to-CSS",
     "JSON",
-    "jsOnParse",
+    "js_on_parse",
     "nanolight",
     "nnn",
     "omit",
@@ -28,7 +29,6 @@
     "SVG",
     "typography",
     "uuid",
-    "uuid1",
     "uuidv1"
   ],
   "license": "MIT",
@@ -36,5 +36,5 @@
   "name": "@jackens/nnn",
   "type": "module",
   "types": "nnn.d.ts",
-  "version": "2025.6.14"
+  "version": "2025.9.3"
 }

package/readme.md

@@ -28,72 +28,72 @@ import { «something» } from './node_modules/@jackens/nnn/nnn.js'
 
 ## Exports
 
-- `CNode`: The type of arguments of the `c` helper.
-- `CRoot`: The type of arguments of the `c` helper.
-- `EscapeMap`: The type of arguments of the `escapeValues` and `escape` helpers.
-- `HArgs`: The type of arguments of the `h` and `s` helpers.
-- `HArgs1`: The type of arguments of the `h` and `s` helpers.
+- `C_Node`: The type of arguments of the `c` helper.
+- `C_Root`: The type of arguments of the `c` helper.
+- `Escape_Map`: The type of arguments of the `escape_values` and `escape` helpers.
+- `H_Args`: The type of arguments of the `h` and `s` helpers.
+- `H_Args_1`: The type of arguments of the `h` and `s` helpers.
 - `c`: A simple JS-to-CSS (aka CSS-in-JS) helper.
-- `csvParse`: A tiny helper for parsing CSV.
-- `csvParseRaw`: A tiny helper for parsing CSV.
-- `escape`: A generic helper for escaping `values` by given `escapeMap` (in *TemplateStrings* flavor).
-- `escapeValues`: A generic helper for escaping `values` by given `escapeMap`.
-- `fixTypography`: A helper that implements typographic corrections specific to Polish typography.
+- `csv_parse`: A tiny helper for parsing CSV.
+- `escape`: A generic helper for escaping `values` by given `escape_map` (in *TemplateStrings* flavor).
+- `escape_values`: A generic helper for escaping `values` by given `escape_map`.
+- `fix_typography`: A helper that implements typographic corrections specific to Polish typography.
 - `h`: A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style helper for creating and modifying `HTMLElement`s (see also `s`).
-- `hasOwn`: A replacement for the `in` operator (not to be confused with the `for-in` loop) that works properly.
-- `isArray`: A helper that checks if the given argument is of type `any[]`.
-- `isNumber`: A helper that checks if the given argument is of type `number`.
-- `isRecord`: A helper that checks if the given argument is of type `Record<PropertyKey, unknown>`.
-- `isString`: A helper that checks if the given argument is of type `string`.
-- `jsOnParse`: `JSON.parse` with “JavaScript turned on”.
-- `nanolight`: A generic helper for syntax highlighting (see also `nanolightJs`).
-- `nanolightJs`: A helper for highlighting JavaScript (see also `nanolight`).
+- `has_own`: A replacement for the `in` operator (not to be confused with the `for-in` loop) that works properly.
+- `is_array`: A helper that checks if the given argument is of type `any[]`.
+- `is_finite_number`: A helper that checks if the given argument is of type `number` but not `±Infinity` nor `NaN`.
+- `is_number`: A helper that checks if the given argument is of type `number`.
+- `is_record`: A helper that checks if the given argument is of type `Record<PropertyKey, unknown>`.
+- `is_string`: A helper that checks if the given argument is of type `string`.
+- `js_on_parse`: `JSON.parse` with “JavaScript turned on”.
+- `nanolight`: A generic helper for syntax highlighting (see also `nanolight_js`).
+- `nanolight_js`: A helper for highlighting JavaScript (see also `nanolight`).
 - `omit`: A helper that implements TypeScript’s `Omit` utility type (see also `pick`).
 - `pick`: A helper that implements TypeScript’s `Pick` utility type (see also `omit`).
-- `plUral`: A helper for choosing the correct singular and plural.
+- `pl_ural`: A helper for choosing the correct singular and plural.
 - `pro`: A helper that protects calls to nested properties by a `Proxy` that initializes non-existent values with an empty object.
 - `s`: A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style helper for creating and modifying `SVGElement`s (see also `h`).
-- `svgUse`: A convenient shortcut for `s('svg', ['use', { 'xlink:href': '#' + id }], ...args)`.
-- `uuid1`: A helper that generates a UUID v1 identifier (with a creation timestamp).
+- `svg_use`: A convenient shortcut for `s('svg', ['use', { 'xlink:href': '#' + id }], ...args)`.
+- `uuid_v1`: A helper that generates a UUID v1 identifier (with a creation timestamp).
 
-### CNode
+### C_Node
 
 ```ts
-type CNode = {
-    [attributeOrSelector: string]: string | number | CNode | undefined;
+type C_Node = {
+    [attribute_or_selector: string]: string | number | C_Node | undefined;
 };
 ```
 
 The type of arguments of the `c` helper.
 
-### CRoot
+### C_Root
 
 ```ts
-type CRoot = Record<PropertyKey, CNode>;
+type C_Root = Record<PropertyKey, C_Node>;
 ```
 
 The type of arguments of the `c` helper.
 
-### EscapeMap
+### Escape_Map
 
 ```ts
-type EscapeMap = Map<unknown, (value?: unknown) => string>;
+type Escape_Map = Map<unknown, (value?: unknown) => string>;
 ```
 
-The type of arguments of the `escapeValues` and `escape` helpers.
+The type of arguments of the `escape_values` and `escape` helpers.
 
-### HArgs
+### H_Args
 
 ```ts
-type HArgs = [string | Node, ...HArgs1[]];
+type H_Args = [string | Node, ...H_Args_1[]];
 ```
 
 The type of arguments of the `h` and `s` helpers.
 
-### HArgs1
+### H_Args_1
 
 ```ts
-type HArgs1 = Record<PropertyKey, unknown> | null | undefined | Node | string | number | HArgs;
+type H_Args_1 = Record<PropertyKey, unknown> | null | undefined | Node | string | number | H_Args;
 ```
 
 The type of arguments of the `h` and `s` helpers.
@@ -101,7 +101,7 @@ The type of arguments of the `h` and `s` helpers.
 ### c
 
 ```ts
-const c: (root: CRoot, splitter?: string) => string;
+const c: (root: C_Root, splitter?: string) => string;
 ```
 
 A simple JS-to-CSS (aka CSS-in-JS) helper.
@@ -110,7 +110,7 @@ The `root` parameter provides a hierarchical description of CSS rules.
 
 - Keys of sub-objects whose values are NOT objects are treated as CSS attribute, and values are treated as values of those CSS attributes; the concatenation of keys of all parent objects is a CSS rule.
 - All keys ignore the part starting with a splitter (default: `$$`) sign until the end of the key (e.g. `src$$1` → `src`, `@font-face$$1` → `@font-face`).
-- In keys specifying CSS attribute, all uppercase letters are replaced by lowercase letters with an additional `-` character preceding them (e.g. `fontFamily` → `font-family`).
+- In keys specifying CSS attribute, all uppercase letters are replaced by lowercase letters with an additional `-` character preceding them (e.g. `fontFamily` → `font-family`), while all `_` characters are replaced by `-` character (e.g. `font_family` → `font-family`).
 - Commas in keys that makes a CSS rule cause it to “split” and create separate rules for each part (e.g. `{div:{margin:1,'.a,.b,.c':{margin:2}}}` → `div{margin:1}div.a,div.b,div.c{margin:2}`).
 - Top-level keys that begin with `@` are not concatenated with sub-object keys.
 
@@ -177,11 +177,11 @@ const actual = c({
     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_weight: 'normal',
+    'font-style': 'normal'
   },
   '@font-face$$2': {
-    fontFamily: 'C64',
+    font_family: 'C64',
     src: 'url(fonts/C64_Pro_Mono-STYLE.woff)'
   },
   '@keyframes spin': {
@@ -191,7 +191,7 @@ const actual = c({
   div: {
     border: 'solid red 1px',
     '.c1': { 'background-color': '#000' },
-    ' .c1': { backgroundColor: 'black' },
+    ' .c1': { background_color: 'black' },
     '.c2': { backgroundColor: 'rgb(0,0,0)' }
   },
   '@media(min-width:200px)': {
@@ -310,10 +310,10 @@ const expected = `
 expect(actual).to.deep.equal(expected)
 ```
 
-### csvParse
+### csv_parse
 
 ```ts
-const csvParse: (csv: string, separator?: string) => Record<PropertyKey, string>[];
+const csv_parse: (csv: string, separator?: string) => string[][];
 ```
 
 A tiny helper for parsing CSV.
@@ -329,38 +329,7 @@ yyy",zzz
  42 , "42" , 17
 
 `
-
-expect(csvParse(text)).to.deep.equal([{
-  'aaa\n"aaa"\naaa': 'xxx,xxx',
-  bbb: 'yyy\nyyy',
-  'ccc,ccc': 'zzz'
-}, {
-  'aaa\n"aaa"\naaa': ' 42 ',
-  bbb: '42',
-  'ccc,ccc': ' 17'
-}])
-```
-
-### csvParseRaw
-
-```ts
-const csvParseRaw: (csv: string, separator?: string) => string[][];
-```
-
-A tiny helper for parsing CSV.
-
-#### Usage Examples
-
-```ts
-const text = `"aaa
-""aaa""
-aaa",bbb, "ccc,ccc"
-"xxx,xxx", "yyy
-yyy",zzz
- 42 , "42" , 17
-
-`
-expect(csvParseRaw(text)).to.deep.equal([
+expect(csv_parse(text)).to.deep.equal([
   ['aaa\n"aaa"\naaa', 'bbb', 'ccc,ccc'],
   ['xxx,xxx', 'yyy\nyyy', 'zzz'],
   [' 42 ', '42', ' 17']
@@ -370,24 +339,24 @@ expect(csvParseRaw(text)).to.deep.equal([
 ### escape
 
 ```ts
-const escape: (escapeMap: EscapeMap, template: TemplateStringsArray, ...values: unknown[]) => string;
+const escape: (escape_map: Escape_Map, template: TemplateStringsArray, ...values: unknown[]) => string;
 ```
 
-A generic helper for escaping `values` by given `escapeMap` (in *TemplateStrings* flavor).
+A generic helper for escaping `values` by given `escape_map` (in *TemplateStrings* flavor).
 
 #### Usage Examples
 
 ```ts
-const escapeMap: EscapeMap = new Map([
+const escape_map: Escape_Map = new Map([
   [undefined, () => 'NULL'],
-  [Array, (values: unknown[]) => escapeValues(escapeMap, values).join(', ')],
+  [Array, (values: unknown[]) => escape_values(escape_map, values).join(', ')],
   [Boolean, (value: boolean) => `b'${+value}'`],
   [Date, (value: Date) => `'${value.toISOString().replace(/^(.+)T(.+)\..*$/, '$1 $2')}'`],
   [Number, (value: number) => `${value}`],
   [String, (value: string) => `'${value.replace(/'/g, "''")}'`]
 ])
 
-const sql = escape.bind(null, escapeMap)
+const sql = escape.bind(null, escape_map)
 
 const actual = sql`
   SELECT *
@@ -402,18 +371,18 @@ const expected = `
 expect(actual).to.deep.equal(expected)
 ```
 
-### escapeValues
+### escape_values
 
 ```ts
-const escapeValues: (escapeMap: EscapeMap, values: unknown[]) => string[];
+const escape_values: (escape_map: Escape_Map, values: unknown[]) => string[];
 ```
 
-A generic helper for escaping `values` by given `escapeMap`.
+A generic helper for escaping `values` by given `escape_map`.
 
-### fixTypography
+### fix_typography
 
 ```ts
-const fixTypography: (node: Node) => void;
+const fix_typography: (node: Node) => void;
 ```
 
 A helper that implements typographic corrections specific to Polish typography.
@@ -423,7 +392,7 @@ A helper that implements typographic corrections specific to Polish typography.
 ```ts
 const p = h('p', 'Pchnąć w tę łódź jeża lub ośm skrzyń fig (zob. https://pl.wikipedia.org/wiki/Pangram).')
 
-fixTypography(p)
+fix_typography(p)
 
 expect(p.innerHTML).to.deep.equal(
   'Pchnąć <span style="white-space:nowrap">w </span>tę łódź jeża lub ośm skrzyń fig ' +
@@ -434,9 +403,9 @@ expect(p.innerHTML).to.deep.equal(
 
 ```ts
 const h: {
-    <T extends keyof HTMLElementTagNameMap>(tag: T, ...args1: HArgs1[]): HTMLElementTagNameMap[T];
-    <N extends Node>(node: N, ...args1: HArgs1[]): N;
-    (tagOrNode: string | Node, ...args1: HArgs1[]): Node;
+    <T extends keyof HTMLElementTagNameMap>(tag: T, ...args1: H_Args_1[]): HTMLElementTagNameMap[T];
+    <N extends Node>(node: N, ...args1: H_Args_1[]): N;
+    (tag_or_node: string | Node, ...args1: H_Args_1[]): Node;
 };
 ```
 
@@ -518,10 +487,10 @@ h(div, { $key: { two: 2 } })
 expect(div.key).to.deep.equal({ one: 1, two: 2 })
 ```
 
-### hasOwn
+### has_own
 
 ```ts
-const hasOwn: (ref: unknown, key: unknown) => boolean;
+const has_own: (ref: unknown, key: unknown) => boolean;
 ```
 
 A replacement for the `in` operator (not to be confused with the `for-in` loop) that works properly.
@@ -532,69 +501,82 @@ A replacement for the `in` operator (not to be confused with the `for-in` loop)
 const obj = { 42: null, null: 'k,e,y', 'k,e,y': 42 }
 
 expect(42 in obj).to.be.true
-expect(hasOwn(obj, 42)).to.be.true
+expect(has_own(obj, 42)).to.be.true
 
 expect('42' in obj).to.be.true
-expect(hasOwn(obj, '42')).to.be.true
+expect(has_own(obj, '42')).to.be.true
 
 expect('null' in obj).to.be.true
-expect(hasOwn(obj, 'null')).to.be.true
+expect(has_own(obj, 'null')).to.be.true
 
 expect(null in obj).to.be.true
-expect(hasOwn(obj, null)).to.be.true
+expect(has_own(obj, null)).to.be.true
 
 expect('k,e,y' in obj).to.be.true
-expect(hasOwn(obj, 'k,e,y')).to.be.true
+expect(has_own(obj, 'k,e,y')).to.be.true
 
 expect(['k', 'e', 'y'] in obj).to.be.true
-expect(hasOwn(obj, ['k', 'e', 'y'])).to.be.true
+expect(has_own(obj, ['k', 'e', 'y'])).to.be.true
 
 expect('toString' in obj).to.be.true
-expect(hasOwn(obj, 'toString')).to.be.false
+expect(has_own(obj, 'toString')).to.be.false
 
 expect(() => 'key' in null).to.throw
-expect(hasOwn(null, 'key')).to.be.false
+expect(has_own(null, 'key')).to.be.false
 
 expect(() => 'key' in undefined).to.throw
-expect(hasOwn(undefined, 'key')).to.be.false
+expect(has_own(undefined, 'key')).to.be.false
 ```
 
-### isArray
+### is_array
 
 ```ts
-const isArray: (arg: any) => arg is any[];
+const is_array: (arg: any) => arg is any[];
+declare const FINITE_NUMBER: unique symbol;
+type Finite_Number = number & {
+    readonly [FINITE_NUMBER]: true;
+};
 ```
 
 A helper that checks if the given argument is of type `any[]`.
 
-### isNumber
+### is_finite_number
+
+```ts
+const is_finite_number: ((arg: unknown) => arg is Finite_Number);
+```
+
+A helper that checks if the given argument is of type `number` but not `±Infinity` nor `NaN`.
+
+### is_number
 
 ```ts
-const isNumber: (arg: any) => arg is number;
+const is_number: (arg: unknown) => arg is number;
 ```
 
 A helper that checks if the given argument is of type `number`.
 
-### isRecord
+### is_record
 
 ```ts
-const isRecord: (arg: any) => arg is Record<PropertyKey, unknown>;
+const is_record: (arg: unknown) => arg is Record<PropertyKey, unknown>;
 ```
 
 A helper that checks if the given argument is of type `Record<PropertyKey, unknown>`.
 
-### isString
+### is_string
 
 ```ts
-const isString: (arg: any) => arg is string;
+const is_string: (arg: unknown) => arg is string;
+export {};
 ```
 
 A helper that checks if the given argument is of type `string`.
 
-### jsOnParse
+### js_on_parse
 
 ```ts
-const jsOnParse: (handlers: Record<PropertyKey, Function>, text: string) => any;
+const js_on_parse: (handlers: Record<PropertyKey, Function>, text: string) => any;
 ```
 
 `JSON.parse` with “JavaScript turned on”.
@@ -602,13 +584,13 @@ const jsOnParse: (handlers: Record<PropertyKey, Function>, text: string) => any;
 Objects having *exactly* one property which is present in the `handlers` map, i.e. objects of the form:
 
 ```js
-{ "«handlerName»": [«params»] }
+{ "«handler_name»": [«params»] }
 ```
 
 are replaced by the result of call
 
 ```js
-handlers['«handlerName»'](...«params»)
+handlers['«handler_name»'](...«params»)
 ```
 
 #### Usage Examples
@@ -619,7 +601,7 @@ const handlers = {
   $foo: () => 'bar'
 }
 
-const actual = jsOnParse(handlers, `[
+const actual = js_on_parse(handlers, `[
   {
     "$hello": ["World"]
   },
@@ -661,15 +643,15 @@ expect(actual).to.deep.equal(expected)
 ### nanolight
 
 ```ts
-const nanolight: (pattern: RegExp, highlighters: ((chunk: string, index: number) => HArgs1)[], code: string) => HArgs1[];
+const nanolight: (pattern: RegExp, highlighters: ((chunk: string, index: number) => H_Args_1)[], code: string) => H_Args_1[];
 ```
 
-A generic helper for syntax highlighting (see also `nanolightJs`).
+A generic helper for syntax highlighting (see also `nanolight_js`).
 
-### nanolightJs
+### nanolight_js
 
 ```ts
-const nanolightJs: (code: string) => HArgs1[];
+const nanolight_js: (code: string) => H_Args_1[];
 ```
 
 A helper for highlighting JavaScript (see also `nanolight`).
@@ -677,9 +659,9 @@ A helper for highlighting JavaScript (see also `nanolight`).
 #### Usage Examples
 
 ```ts
-const codeJs = 'const answerToLifeTheUniverseAndEverything = 42'
+const code_js = 'const answerToLifeTheUniverseAndEverything = 42'
 
-expect(nanolightJs(codeJs)).to.deep.equal([
+expect(nanolight_js(code_js)).to.deep.equal([
   ['span', { class: 'keyword' }, 'const'],
   ' ',
   ['span', { class: 'literal' }, 'answerToLifeTheUniverseAndEverything'],
@@ -722,10 +704,10 @@ const obj = { a: 42, b: '42', c: 17 }
 expect(pick(obj, ['a', 'b'])).to.deep.equal({ a: 42, b: '42' })
 ```
 
-### plUral
+### pl_ural
 
 ```ts
-const plUral: (singular: string, plural2: string, plural5: string, value: number) => string;
+const pl_ural: (singular: string, plural_2: string, plural_5: string, value: number) => string;
 ```
 
 A helper for choosing the correct singular and plural.
@@ -733,14 +715,14 @@ A helper for choosing the correct singular and plural.
 #### Usage Examples
 
 ```ts
-const auto = plUral.bind(null, 'auto', 'auta', 'aut')
+const auto = pl_ural.bind(null, 'auto', 'auta', 'aut')
 
 expect(auto(0)).to.deep.equal('aut')
 expect(auto(1)).to.deep.equal('auto')
 expect(auto(17)).to.deep.equal('aut')
 expect(auto(42)).to.deep.equal('auta')
 
-const car = plUral.bind(null, 'car', 'cars', 'cars')
+const car = pl_ural.bind(null, 'car', 'cars', 'cars')
 
 expect(car(0)).to.deep.equal('cars')
 expect(car(1)).to.deep.equal('car')
@@ -790,9 +772,9 @@ expect(ref).to.deep.equal({ one: { two: { three: { four: 1234 } } } })
 
 ```ts
 const s: {
-    <T extends keyof SVGElementTagNameMap>(tag: T, ...args1: HArgs1[]): SVGElementTagNameMap[T];
-    <N extends Node>(node: N, ...args1: HArgs1[]): N;
-    (tagOrNode: string | Node, ...args1: HArgs1[]): Node;
+    <T extends keyof SVGElementTagNameMap>(tag: T, ...args1: H_Args_1[]): SVGElementTagNameMap[T];
+    <N extends Node>(node: N, ...args1: H_Args_1[]): N;
+    (tag_or_node: string | Node, ...args1: H_Args_1[]): Node;
 };
 ```
 
@@ -806,49 +788,24 @@ A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style help
 - 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.
 
-### svgUse
+### svg_use
 
 ```ts
-const svgUse: (id: string, ...args: HArgs1[]) => SVGSVGElement;
+const svg_use: (id: string, ...args: H_Args_1[]) => SVGSVGElement;
 ```
 
 A convenient shortcut for `s('svg', ['use', { 'xlink:href': '#' + id }], ...args)`.
 
-### uuid1
+### uuid_v1
 
 ```ts
-const uuid1: (date?: Date, node?: string) => string;
+const uuid_v1: (date?: Date, node?: string) => string;
 ```
 
 A helper that generates a UUID v1 identifier (with a creation timestamp).
 
 - The optional `node` parameter should have the format `/^[0123456789abcdef]+$/`. Its value will be trimmed to last 12 characters and left padded with zeros.
 
-#### Usage Examples
-
-```ts
-for (let i = 1; i <= 22136; ++i) {
-  const uuid = uuid1()
-
-  i === 1 && expect(uuid.split('-')[3]).to.deep.equal('8001')
-  i === 4095 && expect(uuid.split('-')[3]).to.deep.equal('8fff')
-  i === 4096 && expect(uuid.split('-')[3]).to.deep.equal('9000')
-  i === 9029 && expect(uuid.split('-')[3]).to.deep.equal('a345')
-  i === 13398 && expect(uuid.split('-')[3]).to.deep.equal('b456')
-  i === 16384 && expect(uuid.split('-')[3]).to.deep.equal('8000')
-  i === 17767 && expect(uuid.split('-')[3]).to.deep.equal('8567')
-}
-```
-
-```ts
-expect(uuid1(new Date(), '000123456789abc').split('-')[4]).to.deep.equal('123456789abc')
-expect(uuid1(new Date(), '123456789').split('-')[4]).to.deep.equal('000123456789')
-```
-
-```ts
-expect(uuid1(new Date(323325000000)).startsWith('c1399400-9a71-11bd')).to.be.true
-```
-
 ## License
 
 The MIT License (MIT)