@gsknnft/bigint-buffer 1.4.1 → 1.4.2

package/dist/types/conversion/src/ts/index.d.ts

@@ -0,0 +1,168 @@
+import { Buffer } from 'buffer';
+export declare let isNative: boolean;
+/**
+ * Convert a little-endian buffer into a BigInt.
+ * @param buf The little-endian buffer to convert
+ * @returns A BigInt with the little-endian representation of buf.
+ */
+export declare function toBigIntLE(buf: Buffer): bigint;
+export declare function validateBigIntBuffer(): boolean;
+/**
+ * Convert a big-endian buffer into a BigInt
+ * @param buf The big-endian buffer to convert.
+ * @returns A BigInt with the big-endian representation of buf.
+ */
+export declare function toBigIntBE(buf: Buffer): bigint;
+/**
+ * Convert a BigInt to a little-endian buffer.
+ * @param num   The BigInt to convert.
+ * @param width The number of bytes that the resulting buffer should be.
+ * @returns A little-endian buffer representation of num.
+ */
+export declare function toBufferLE(num: bigint, width: number): Buffer;
+/**
+ * Convert a BigInt to a big-endian buffer.
+ * @param num   The BigInt to convert.
+ * @param width The number of bytes that the resulting buffer should be.
+ * @returns A big-endian buffer representation of num.
+ */
+export declare function toBufferBE(num: bigint, width: number): Buffer;
+export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+/**
+ * Parses a hexadecimal string for correctness and returns it with or without
+ * '0x' prefix, and/or with the specified byte length
+ * @param a - the string with an hexadecimal number to be parsed
+ * @param prefix0x - set to true to prefix the output with '0x'
+ * @param byteLength - pad the output to have the desired byte length. Notice
+ * that the hex length is double the byte length.
+ *
+ * @returns
+ *
+ * @throws {@link RangeError} if input string does not hold an hexadecimal number
+ * @throws {@link RangeError} if requested byte length is less than the input byte length
+ */
+export declare function parseHex(a: string, prefix0x?: boolean, byteLength?: number): string;
+/**
+ * Converts an arbitrary-size non-negative bigint to an ArrayBuffer or a Buffer
+ * (default for Node.js)
+ *
+ * @param a
+ * @param returnArrayBuffer - In Node.js, it forces the output to be an
+ * ArrayBuffer instead of a Buffer.
+ *
+ * @returns an ArrayBuffer or a Buffer with a binary representation of the input
+ * bigint
+ *
+ * @throws {@link RangeError} if a < 0.
+ */
+export declare function bigintToBuf(a: bigint, returnArrayBuffer?: boolean): ArrayBuffer | Buffer;
+/**
+ * Converts an ArrayBuffer, TypedArray or Buffer (node.js) to a bigint
+ * @param buf
+ * @returns a bigint
+ */
+export declare function bufToBigint(buf: ArrayBuffer | TypedArray | Buffer): bigint;
+/**
+ * Converts a non-negative bigint to a hexadecimal string
+ * @param a - a non negative bigint
+ * @param prefix0x - set to true to prefix the output with '0x'
+ * @param byteLength - pad the output to have the desired byte length. Notice
+ * that the hex length is double the byte length.
+ *
+ * @returns hexadecimal representation of the input bigint
+ *
+ * @throws {@link RangeError} if a < 0
+ */
+export declare function bigintToHex(a: bigint, prefix0x?: boolean, byteLength?: number): string;
+/**
+ * Converts a hexadecimal string to a bigint
+ *
+ * @param hexStr
+ *
+ * @returns a bigint
+ *
+ * @throws {@link RangeError} if input string does not hold an hexadecimal number
+ */
+export declare function hexToBigint(hexStr: string): bigint;
+/**
+ * Converts a non-negative bigint representing a binary array of utf-8 encoded
+ * text to a string of utf-8 text
+ *
+ * @param a - A non-negative bigint representing a binary array of utf-8 encoded
+ * text.
+ *
+ * @returns a string text with utf-8 encoding
+ *
+ * @throws {@link RangeError} if a < 0.
+ */
+export declare function bigintToText(a: bigint): string;
+/**
+ * Converts a utf-8 string to a bigint (from its binary representaion)
+ *
+ * @param text - A string text with utf-8 encoding
+ *
+ * @returns a bigint representing a binary array of the input utf-8 encoded text
+ */
+export declare function textToBigint(text: string): bigint;
+/**
+ * Converts an ArrayBuffer, TypedArray or Buffer (in Node.js) containing utf-8
+ * encoded text to a string of utf-8 text
+ *
+ * @param buf - A buffer containing utf-8 encoded text
+ *
+ * @returns a string text with utf-8 encoding
+ */
+export declare function bufToText(buf: ArrayBuffer | TypedArray | Buffer): string;
+/**
+ * Converts a string of utf-8 encoded text to an ArrayBuffer or a Buffer
+ * (default in Node.js)
+ *
+ * @param str - A string of text (with utf-8 encoding)
+ * @param returnArrayBuffer - When invoked in Node.js, it can force the output
+ * to be an ArrayBuffer instead of a Buffer.
+ *
+ * @returns an ArrayBuffer or a Buffer containing the utf-8 encoded text
+ */
+export declare function textToBuf(str: string, returnArrayBuffer?: boolean): ArrayBuffer | Buffer;
+/**
+ * Returns the hexadecimal representation of a buffer.
+ *
+ * @param buf
+ * @param prefix0x - set to true to prefix the output with '0x'
+ * @param byteLength - pad the output to have the desired byte length. Notice
+ * that the hex length is double the byte length.
+ *
+ * @returns a string with a hexadecimal representation of the input buffer
+ */
+export declare function bufToHex(buf: ArrayBuffer | TypedArray | Buffer, prefix0x?: boolean, byteLength?: number): string;
+/**
+ * Converts a hexadecimal string to a buffer
+ *
+ * @param hexStr - A string representing a number with hexadecimal notation
+ * @param returnArrayBuffer - In Node.js, it forces the output to be an
+ * ArrayBuffer instead of a Buffer.
+ *
+ * @returns An ArrayBuffer or a Buffer
+ *
+ * @throws {@link RangeError} if input string does not hold an hexadecimal number
+ */
+export declare function hexToBuf(hexStr: string, returnArrayBuffer?: boolean): ArrayBuffer | Buffer;
+/**
+ * Converts an arbitrary-size non-negative bigint to a base64 string
+ * @param a - a non negative bigint
+ * @param urlsafe - if true Base64 URL encoding is used ('+' and '/' are
+ * replaced by '-', '_')
+ * @param padding - if false, padding (trailing '=') is removed
+ * @returns a base64 representation of the input bigint
+ *
+ * @throws {RangeError}
+ * Thrown if a < 0
+ */
+export declare function bigintToBase64(a: bigint, urlsafe?: boolean, padding?: boolean): string;
+/**
+ * Converts a base64 string to bigint.
+ * @param a base64 string. It accepts standard and URL-safe base64 with and
+ * without padding
+ * @returns a bigint
+ */
+export declare function base64ToBigint(a: string): bigint;

package/dist/types/conversion/test/bigintToBase64.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/conversion/test/bigintToBuf.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/conversion/test/bigintToHex.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/conversion/test/bigintToText.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/conversion/test/bufToBigint.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/conversion/test/hexToBigint.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/conversion/test/hexToBuf.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/conversion/test/parseHex.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/conversion/test/setup.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/conversion/test/textToBuf.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gsknnft/bigint-buffer",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "description": "bigint to buffer conversion with native support and built-in conversion helpers",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -17,7 +17,40 @@
       "require": "./dist/conversion/index.cjs"
     }
   },
+  "files": [
+    "dist/",
+    "helper/",
+    "src/",
+    "binding.gyp",
+    "build/",
+    "README.md",
+    "LICENSE"
+  ],
   "workspaces": [],
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "coverage": "vitest cover ./test/index.js",
+    "lint": "gts check",
+    "install": "node-gyp rebuild",
+    "prepublishOnly": "rm -rf build/Makefile; rm build/gyp-*; rm build/*.mk; rm build/*.Makefile; rm *.tgz",
+    "clean:js": "npm clean && rm -rf build/* dist/*",
+    "test:browser": "vite test --browser",
+    "test:node": "mocha build/src/**/*.spec.js --timeout 40000",
+    "declare": "tsc -p . --declaration --emitDeclarationOnly --outDir dist/types",
+    "benchmark": "node -r ts-node/register src/index.bench.ts",
+    "typedoc": "typedoc --out docs $(pwd)/src $(pwd)/helper --target es6 --mode file --tsconfig ./tsconfig.json --excludePrivate --excludeProtected --excludeNotExported --exclude '**/*+(spec|bench).ts'",
+    "rebuild:native": "node-gyp rebuild",
+    "build": "vite build && npm run declare && tsc -p . && cpy \"index.d.ts\" ../dist --cwd dist/types && cpy \"conversion/index.d.ts\" ../dist/conversion --cwd dist/types",
+    "compile": "vite build && npm run declare && tsc -p . && cpy \"index.d.ts\" ../dist/types --cwd dist/types && cpy \"conversion/index.d.ts\" ../dist/conversion --cwd dist/types",
+    "check": "eslint src/**/*.ts src/conversion/**/*.ts src/index.spec.ts src/conversion/test/**/*.ts",
+    "test:vitest": "vitest",
+    "test:all": "pnpm run test && pnpm run benchmark",
+    "clean": "gts clean",
+    "fix": "gts fix",
+    "pretest": "npm run compile",
+    "posttest": "npm run check"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/gsknnft/bigint-buffer.git"
@@ -33,11 +66,15 @@
     "napi"
   ],
   "license": "Apache-2.0",
+  "pnpm": {
+    "overrides": {
+      "tmp": "0.2.5"
+    }
+  },
   "optionalDependencies": {
     "bindings": "^1.5.0"
   },
   "devDependencies": {
-    "jiti": "^2.6.1",
     "@rollup/plugin-commonjs": "^29.0.0",
     "@rollup/plugin-esm-shim": "0.1.8",
     "@rollup/plugin-json": "^6.1.0",
@@ -59,6 +96,7 @@
     "eslint": "^9.39.1",
     "globals": "^16.5.0",
     "gts": "^6.0.2",
+    "jiti": "^2.6.1",
     "karma": "^6.4.4",
     "karma-chrome-launcher": "^3.2.0",
     "karma-env-preprocessor": "^0.1.1",
@@ -88,28 +126,5 @@
   "contributors": [
     "Gordon Skinner <gsknnft@gmail.com> (https://github.com/gsknnft)",
     "Michael Wei <mwei@vmware.com> (https://github.com/no2chem)"
-  ],
-  "scripts": {
-    "test": "vitest run",
-    "test:watch": "vitest watch",
-    "coverage": "vitest cover ./test/index.js",
-    "lint": "gts check",
-    "install": "node-gyp rebuild",
-    "clean:js": "npm clean && rm -rf build/* dist/*",
-    "test:browser": "vite test --browser",
-    "test:node": "mocha build/src/**/*.spec.js --timeout 40000",
-    "declare": "tsc -p . --declaration --emitDeclarationOnly --outDir dist/types",
-    "benchmark": "node -r ts-node/register src/index.bench.ts",
-    "typedoc": "typedoc --out docs $(pwd)/src $(pwd)/helper --target es6 --mode file --tsconfig ./tsconfig.json --excludePrivate --excludeProtected --excludeNotExported --exclude '**/*+(spec|bench).ts'",
-    "rebuild:native": "node-gyp rebuild",
-    "build": "vite build && npm run declare && tsc -p . && cpy \"index.d.ts\" ../dist --cwd dist/types && cpy \"conversion/index.d.ts\" ../dist/conversion --cwd dist/types",
-    "compile": "vite build && npm run declare && tsc -p . && cpy \"index.d.ts\" ../dist/types --cwd dist/types && cpy \"conversion/index.d.ts\" ../dist/conversion --cwd dist/types",
-    "check": "eslint src/**/*.ts src/conversion/**/*.ts src/index.spec.ts src/conversion/test/**/*.ts",
-    "test:vitest": "vitest",
-    "test:all": "pnpm run test && pnpm run benchmark",
-    "clean": "gts clean",
-    "fix": "gts fix",
-    "pretest": "npm run compile",
-    "posttest": "npm run check"
-  }
-}
+  ]
+}

package/src/bigint-buffer.c

@@ -0,0 +1,203 @@
+
+#define NAPI_EXPERIMENTAL
+#include <node_api.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <limits.h> 
+
+#define BIT_MASK(n) (~( ((~0ull) << ((n)-1)) << 1 ))
+
+// The maximum size we'll store on the stack. If we need a larger temporary
+// buffer malloc will be called.
+#define BUFFER_STACK_SIZE 32
+
+#if defined(_WIN16) || defined(_WIN32) || defined(_WIN64)
+#define bswap64(x) _byteswap_uint64(x)
+#else
+#define bswap64(x) __builtin_bswap64(x)
+#endif
+
+/**
+ * Converts a Buffer to bigint.
+ * node param 0: buffer
+ * node param 1: big_endian (optional boolean)
+ * 
+ * returns bigint
+ */
+napi_value toBigInt (napi_env env, napi_callback_info info) {
+  napi_value argv[2];
+  napi_status status;
+  size_t argc = 2;
+
+  status = napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  assert(status == napi_ok);
+
+  if (argc < 1) {
+    napi_throw_error(env, "EINVAL", "Too few arguments");
+    return NULL;
+  }
+
+  bool big_endian;
+  status = napi_get_value_bool(env, argv[1], &big_endian);
+  if (status == napi_boolean_expected) { big_endian = false; }
+
+  uint8_t* buffer;
+  size_t len;
+  status = napi_get_buffer_info(env, argv[0], (void**) &buffer, &len);
+  assert(status == napi_ok);
+
+  // If len is not divisible by 8 bytes, we'll need to copy
+  bool not_64_aligned = (len & 7) != 0;
+  size_t overflow_len = not_64_aligned ? 8 - (len & 0x7) : 0;
+  // Buffer is managed by VM, so copy it out (TODO: perhaps we can increase refcount?)
+  size_t aligned_len = len + overflow_len;
+  size_t len_in_words = not_64_aligned ? (len >> 3) + 1 : (len >> 3);
+  bool fits_in_stack = aligned_len <= BUFFER_STACK_SIZE;
+
+  uint8_t copy[BUFFER_STACK_SIZE];
+  uint8_t* bufTemp = fits_in_stack ? copy : malloc(aligned_len);
+  if (overflow_len > 0) {
+    memset(bufTemp + len, 0, overflow_len);
+  }
+  memcpy(bufTemp, buffer, len);
+  uint64_t* as_64_aligned = (uint64_t*) bufTemp;
+  size_t overflow_in_bits = overflow_len << 3; // == overflow_len * 8
+
+  napi_value out;
+  // swap
+  if (big_endian) {
+    if (len_in_words == 1) {
+        as_64_aligned[0] = not_64_aligned ? bswap64(as_64_aligned[0]) >> overflow_in_bits :  bswap64(as_64_aligned[0]);
+    } else {
+        uint64_t temp;
+        size_t last_word = len_in_words - 1;
+        size_t end_ptr = last_word;
+        int32_t offset;
+        for (offset = 0; offset < (int32_t)(len_in_words / 2); offset++) {
+            temp = as_64_aligned[offset];
+            as_64_aligned[offset] = as_64_aligned[end_ptr];
+            as_64_aligned[end_ptr] = temp;
+            end_ptr--;
+        } 
+        uint64_t prev_overflow = 0;
+        for (offset = last_word; offset >= 0; offset--) {
+            uint64_t as_little_endian = bswap64(as_64_aligned[offset]);
+            uint64_t overflow = as_little_endian & BIT_MASK(overflow_in_bits);
+            as_64_aligned[offset] = not_64_aligned ? (as_little_endian >> overflow_in_bits) | prev_overflow : as_little_endian;
+            prev_overflow = overflow << (64 - overflow_in_bits);
+        }
+    }
+  }
+
+  status = napi_create_bigint_words(env, 0, len_in_words, as_64_aligned , &out);
+  assert(status == napi_ok);
+
+  if (!fits_in_stack) {
+      free(bufTemp);
+  }
+
+  return out;
+}
+
+/**
+ * Converts a BigInt to a Buffer
+ * node param 0: BigInt
+ * node param 1: buffer
+ * node param 2: big_endian (optional boolean)
+ * 
+ * returns bigint
+ */
+napi_value fromBigInt (napi_env env, napi_callback_info info) {
+  napi_value argv[3];
+  napi_status status;
+  size_t argc = 3;
+
+  status = napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  assert(status == napi_ok);
+
+  if (argc < 1) {
+    napi_throw_error(env, "EINVAL", "Too few arguments");
+    return NULL;
+  }
+
+  size_t byte_width;
+  bool big_endian;
+  status = napi_get_value_bool(env, argv[2], &big_endian);
+  if (status == napi_boolean_expected) { big_endian = false; }
+
+  size_t word_count;
+  status = napi_get_value_bigint_words(env, argv[0], NULL, &word_count, NULL);
+  assert(status == napi_ok);
+
+  uint8_t* raw_buffer;
+  status = napi_get_buffer_info(env, argv[1], (void**) &raw_buffer, &byte_width);
+  assert(status == napi_ok);
+
+  if (word_count == 0) {
+      memset(raw_buffer, 0, byte_width);
+      return argv[1];
+  }
+
+  int sign_bit = 0;
+  
+  bool not_64_aligned = (byte_width & 7) != 0;
+  size_t overflow_len = not_64_aligned ? 8 - (byte_width & 0x7) : 0;
+  size_t word_width = (byte_width >> 3) + (not_64_aligned ? 1 : 0);
+  size_t original_word_width = word_width;
+  if (word_count > word_width) {
+      word_count = word_width;
+  }
+  size_t word_width_bytes = (word_count << 3);
+  bool fits_in_stack = word_width_bytes <= BUFFER_STACK_SIZE;
+
+  uint64_t* conv_buffer = (uint64_t*) raw_buffer;
+  uint64_t stack_buffer[BUFFER_STACK_SIZE];
+  if (not_64_aligned) {
+      conv_buffer = fits_in_stack ? stack_buffer : malloc(byte_width + overflow_len);
+  }
+  
+  memset(conv_buffer, 0, byte_width + overflow_len);
+  status = napi_get_value_bigint_words(env, argv[0], &sign_bit, &word_count, conv_buffer);
+  assert(status == napi_ok);
+
+  if (big_endian) {
+        uint64_t temp;
+        size_t conv_words = original_word_width;
+        size_t last_word = conv_words - 1;
+        size_t end_ptr = last_word;
+        int32_t offset;
+        for (offset = 0; offset < (int32_t)(conv_words / 2); offset++) {
+            temp = bswap64(conv_buffer[offset]);
+            conv_buffer[offset] = bswap64(conv_buffer[end_ptr]);
+            conv_buffer[end_ptr] = temp;
+            end_ptr--;
+        } 
+        if (conv_words & 1) {
+            conv_buffer[conv_words / 2] = bswap64(conv_buffer[conv_words / 2]);;
+        }
+  }
+  if (not_64_aligned) {
+      memcpy(raw_buffer, big_endian ? (uint64_t*)(((uint8_t*)conv_buffer) + (8-(byte_width & 7))) : conv_buffer, byte_width);
+      if (!fits_in_stack) {
+          free(conv_buffer);
+      }
+  }
+  return argv[1];
+}
+
+napi_value init_all (napi_env env, napi_value exports) {
+  napi_value bigint_fn;
+  napi_value frombigint_fn;
+
+  napi_create_function(env, NULL, 0, toBigInt, NULL, &bigint_fn);
+  napi_create_function(env, NULL, 0, fromBigInt, NULL, &frombigint_fn);
+
+  napi_set_named_property(env, exports, "toBigInt", bigint_fn);
+  napi_set_named_property(env, exports, "fromBigInt", frombigint_fn);
+
+  return exports;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, init_all);

package/src/bigint-buffer.test.ts

@@ -0,0 +1,11 @@
+import {describe, expect, it} from 'vitest';
+
+describe('bigint-buffer', () => {
+  it('should convert bigint to buffer and back', () => {
+    // Example test, replace with real logic
+    const big = BigInt('12345678901234567890');
+    const buf = Buffer.from(big.toString(16), 'hex');
+    const result = BigInt('0x' + buf.toString('hex'));
+    expect(result).toBe(big);
+  });
+});

package/src/conversion/.github/workflows/build-and-test.yml

@@ -0,0 +1,116 @@
+# name: build, test (node and browser), coverage, publish to NPM
+
+# on:
+#   push:
+#     tags:
+#       - "v*.*.*"
+#   workflow_dispatch:
+
+# jobs:
+#   build:
+#     name: build
+#     runs-on: ubuntu-latest
+#     steps:
+#       - name: Git checkout
+#         uses: actions/checkout@v3
+
+#       - name: Use Node.js 24
+#         uses: actions/setup-node@v3
+#         with:
+#           node-version: 24.x
+#           registry-url: "https://registry.npmjs.org"
+
+#       - name: install
+#         run: pnpm ci
+      
+#       - name: build
+#         run: pnpm run build
+
+#   nodetests:
+#     name: tests in Node.js
+#     needs: [build]
+#     runs-on: ${{ matrix.os }}
+#     strategy:
+#       matrix:
+#         os: [ubuntu-latest, windows-latest, macos-latest]
+#         node-version: [18.x, 20.x, 21.x]
+#       # When set to true, GitHub cancels all in-progress jobs if any matrix job fails.
+#       fail-fast: false
+#       # The maximum number of jobs that can run simultaneously. Set to 1 if you can't run tests in parallel
+#       # max-parallel: 1
+#     steps:
+#       - name: Git checkout
+#         uses: actions/checkout@v3
+
+#       - name: Use Node.js ${{ matrix.node-version }}
+#         uses: actions/setup-node@v3
+#         with:
+#           node-version: ${{ matrix.node-version }}
+#           registry-url: "https://registry.npmjs.org"
+
+#       - name: install
+#         run: pnpm i
+
+#       - name: node esm tests
+#         run: pnpm run test:node-esm
+#         # env:
+#         #   VARIABLE1: ${{ secrets.VARIABLE1 }}
+#         #   VARIABLE2: ${{ secrets.VARIABLE2 }}
+      
+#       - name: node cjs tests
+#         run: pnpm run test:node-cjs
+#         # env:
+#         #   VARIABLE1: ${{ secrets.VARIABLE1 }}
+#         #   VARIABLE2: ${{ secrets.VARIABLE2 }}
+
+#   browsertests:
+#     needs: [build]
+#     name: tests in browser
+#     runs-on: ubuntu-latest
+#     steps:
+#       - name: Git checkout
+#         uses: actions/checkout@v3
+
+#       - name: Use Node.js 20
+#         uses: actions/setup-node@v3
+#         with:
+#           node-version: 20.x
+#           registry-url: "https://registry.npmjs.org"
+
+#       - name: install
+#         run: npm ci
+
+#       - name: browser tests
+#         run: npm run test:browser-headless
+#         # env:
+#         #   VARIABLE1: ${{ secrets.VARIABLE1 }}
+#         #   VARIABLE2: ${{ secrets.VARIABLE2 }}
+
+#   publish:
+#     needs: [nodetests, browsertests]
+#     runs-on: ubuntu-latest
+#     steps:
+#       - name: Git checkout
+#         uses: actions/checkout@v3
+
+#       - name: Install Node.js
+#         uses: actions/setup-node@v3
+#         with:
+#           node-version: "20.x"
+#           registry-url: "https://registry.npmjs.org"
+
+#       - name: install
+#         run: npm ci
+        
+#       - name: coverage
+#         run: npm run coverage
+
+#       - name: send report to coveralls.io
+#         uses: coverallsapp/github-action@master
+#         with:
+#           github-token: ${{ secrets.GITHUB_TOKEN }}
+
+#       - name: NPM publish
+#         run: npm publish --access public
+#         env:
+#           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}