@vlasky/zongji 0.6.1 → 0.7.1

package/lib/common.js

@@ -1,7 +1,6 @@
 import iconv from 'iconv-lite';
-import decodeJson from './json_decode.js';
+import decodeJson, { convertBigInts, jsonToText } from './json_decode.js';
 import * as dtDecode from './datetime_decode.js';
-import bigInt from 'big-integer';
 
 export const MysqlTypes = {
   DECIMAL: 0,
@@ -40,7 +39,27 @@ export const MysqlTypes = {
 };
 
 const TWO_TO_POWER_THIRTY_TWO = Math.pow(2, 32);
-const TWO_TO_POWER_SIXTY_THREE = '9223372036854775808'; // Math.pow(2, 63) or 1 << 63
+const TWO_TO_POWER_SIXTY_THREE = 2n ** 63n;
+const TWO_TO_POWER_SIXTY_FOUR = 2n ** 64n;
+const MAX_SAFE_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+const MIN_SAFE_BIGINT = BigInt(Number.MIN_SAFE_INTEGER);
+
+// Combine two unsigned 32-bit halves into an exact unsigned 64-bit value.
+// Returns a Number when at or below 2^53 - 1, otherwise an exact string.
+export function unsignedInt64ToNumberOrString(high, low) {
+  const value = (BigInt(high) << 32n) | BigInt(low);
+  return value <= MAX_SAFE_BIGINT ? Number(value) : value.toString();
+}
+
+// Combine two unsigned 32-bit halves into an exact signed (two's
+// complement) 64-bit value. Returns a Number when within the safe integer
+// range, otherwise an exact string.
+export function signedInt64ToNumberOrString(high, low) {
+  const value = BigInt.asIntN(64, (BigInt(high) << 32n) | BigInt(low));
+  return (value >= MIN_SAFE_BIGINT && value <= MAX_SAFE_BIGINT) ?
+    Number(value) : value.toString();
+}
+
 // This function will return a Number
 // if the result < Math.MAX_SAFE_INTEGER or result > Math.MIN_SAFE_INTEGER,
 // otherwise, will return a string.
@@ -48,11 +67,11 @@ export const parseUInt64 = function(parser) {
   const low = parser.parseUnsignedNumber(4);
   const high = parser.parseUnsignedNumber(4);
 
-  if (high >>> 21) { // using bigint here
-    return bigInt(TWO_TO_POWER_THIRTY_TWO).multiply(high).add(low).toString();
+  if (high >>> 21) { // value is 2^53 or more, exceeds safe Number range
+    return unsignedInt64ToNumberOrString(high, low);
   }
 
-  return (high * Math.pow(2,32)) + low;
+  return (high * TWO_TO_POWER_THIRTY_TWO) + low;
 };
 
 export function parseUInt48(parser) {
@@ -115,12 +134,6 @@ export const parseIEEE754Float = function(high, low) {
   }
 };
 
-export function getUInt32Value(input) {
-  // Last bit is not sign, it is part of value!
-  if (input & (1 << 31)) return Math.pow(2, 31) + (input & ((1 << 31) -1));
-  else return input;
-};
-
 const parseAnyInt = function(parser, column, columnSchema) {
   let result, size;
   switch (column.type) {
@@ -151,16 +164,13 @@ const parseAnyInt = function(parser, column, columnSchema) {
     // Flip bits on negative signed integer
     if (!int64 && (result & (1 << (length - 1)))) {
       result = ((result ^ (Math.pow(2, length) - 1)) * -1) - 1;
-    } else if (int64 && bigInt(result).greaterOrEquals(bigInt(TWO_TO_POWER_SIXTY_THREE))) {
-      const Max64BitNumber = bigInt('18446744073709551615'); // 2^64 - 1
-      result = bigInt(result).xor(Max64BitNumber).add(1).multiply(-1);
-      // Javascript integers only support 2^53, if not within the range, return a String
-      if (result.greater(Number.MAX_SAFE_INTEGER) || result.lesser(Number.MIN_SAFE_INTEGER)) {
-        result = result.toString();
-      }
-      // Otherwise return a Number
-      else {
-        result = result.toJSNumber();
+    } else if (int64) {
+      const unsigned = BigInt(result);
+      if (unsigned >= TWO_TO_POWER_SIXTY_THREE) {
+        const signed = unsigned - TWO_TO_POWER_SIXTY_FOUR;
+        // Javascript Numbers only cover +-(2^53 - 1); return an exact
+        // string outside that range
+        result = signed >= MIN_SAFE_BIGINT ? Number(signed) : signed.toString();
       }
     }
   }
@@ -185,7 +195,11 @@ const readIntBE = function(buf, offset, length, noAssert) {
 // https://github.com/jeremycole/mysql_binlog/blob/master/lib/mysql_binlog/binlog_field_parser.rb
 // Some more information about DECIMAL types:
 // http://dev.mysql.com/doc/refman/5.5/en/precision-math-decimal-characteristics.html
-const parseNewDecimal = function(parser, column) {
+// Returns the exact decimal value as a string (matching mysql2's default
+// treatment of DECIMAL columns), or as a Number if the connection was
+// configured with the mysql2 `decimalNumbers` option (which may lose
+// precision beyond 15 significant digits).
+const parseNewDecimal = function(parser, column, zongji) {
   // Constants of format
   const digitsPerInteger = 9;
   const compressedBytes = [0, 1, 1, 2, 2, 3, 3, 4, 4, 4];
@@ -197,38 +211,37 @@ const parseNewDecimal = function(parser, column) {
   const compIntegral = integral - (uncompIntegral * digitsPerInteger);
   const compFractional = scale - (uncompFractional * digitsPerInteger);
 
-  // Grab buffer portion
+  // Copy buffer portion: the sign bit is flipped in place below and the
+  // underlying packet buffer must not be mutated
   const size = (uncompIntegral * 4) + compressedBytes[compIntegral] +
              (uncompFractional * 4) + compressedBytes[compFractional];
-  const buffer = parser._buffer.slice(parser._offset, parser._offset + size);
+  const buffer = Buffer.from(
+    parser._buffer.subarray(parser._offset, parser._offset + size));
   parser._offset += size; // Move binlog parser position forward
 
-  let str, mask;
   let pos = 0;
   const isPositive = (buffer.readUInt8(0) & (1 << 7)) === 128;
   buffer.writeUInt8(buffer.readUInt8(0) ^ (1 << 7), 0);
-  if (isPositive) {
-    // Positive number
-    str = '';
-    mask = 0;
-  } else {
-    // Negative number
-    str = '-';
-    mask = -1;
-  }
+  // Negative numbers are stored with all bits flipped
+  const mask = isPositive ? 0 : -1;
 
   // Build integer digits
+  let intDigits = '';
   const compIntegralSize = compressedBytes[compIntegral];
   if (compIntegralSize > 0) {
-    str += (readIntBE(buffer, 0, compIntegralSize) ^ mask).toString(10);
+    intDigits += (readIntBE(buffer, 0, compIntegralSize) ^ mask).toString(10);
     pos += compIntegralSize;
   }
 
   for (let i = 0; i < uncompIntegral; i++) {
-    str += zeroPad((buffer.readInt32BE(pos) ^ mask).toString(10), 9);
+    intDigits += zeroPad((buffer.readInt32BE(pos) ^ mask).toString(10), 9);
     pos += 4;
   }
 
+  // Strip leading zeros, keeping at least one digit
+  intDigits = intDigits.replace(/^0+(?=\d)/, '');
+  if (intDigits === '') intDigits = '0';
+
   // Build fractional digits
   let fractionDigits = '';
 
@@ -242,10 +255,13 @@ const parseNewDecimal = function(parser, column) {
     fractionDigits += zeroPad((readIntBE(buffer, pos, compFractionalSize) ^ mask).toString(10), compFractional);
   }
 
-  // Fractional digits may have leading zeros
-  str += '.' + fractionDigits;
+  let str = (isPositive ? '' : '-') + intDigits;
+  if (scale > 0) {
+    str += '.' + fractionDigits;
+  }
 
-  return parseFloat(str);
+  const config = zongji && zongji.connection && zongji.connection.config;
+  return config && config.decimalNumbers ? parseFloat(str) : str;
 };
 
 // Did not work in place. Function cribbed from lines 311-363 of
@@ -380,7 +396,7 @@ export function readMysqlValue(
       result = parseIEEE754Float(high, low);
       break;
     case MysqlTypes.NEWDECIMAL:
-      result = parseNewDecimal(parser, column);
+      result = parseNewDecimal(parser, column, zongji);
       break;
     case MysqlTypes.SET:
       if (column.metadata.size === 8) {
@@ -454,12 +470,24 @@ export function readMysqlValue(
         }
       }
       break;
-    case MysqlTypes.JSON:
+    case MysqlTypes.JSON: {
       lengthSize = column.metadata['length_size'];
       size = parser.parseUnsignedNumber(lengthSize);
       buffer = parser.parseBuffer(size);
-      result = buffer.length === 0 ? null : decodeJson(buffer);
+      if (buffer.length === 0) {
+        result = null;
+      } else {
+        // Match mysql2 semantics: parsed JavaScript value by default,
+        // raw JSON text with the jsonStrings connection option. 64-bit
+        // integers stay exact: raw numerals in text mode, Numbers within
+        // the safe range (exact strings beyond it) in parsed mode.
+        const decoded = decodeJson(buffer);
+        const config = zongji && zongji.connection && zongji.connection.config;
+        result = config && config.jsonStrings ?
+          jsonToText(decoded) : convertBigInts(decoded);
+      }
       break;
+    }
     case MysqlTypes.GEOMETRY:
       lengthSize = column.metadata['length_size'];
       size = parser.parseUnsignedNumber(lengthSize);

package/lib/json_decode.js

@@ -21,11 +21,62 @@ const JSONB_LITERALS = [ null, true, false ];
 // node-mysql prefixes binary string values
 const VAR_STRING_PREFIX = 'base64:type253:';
 
+// Decodes a JSONB binary buffer into JavaScript values (object, array,
+// string, number, boolean, BigInt for 64-bit integers, or null). The
+// caller converts BigInts and decides whether to serialise back to a JSON
+// string (mysql2 `jsonStrings` option) via the helpers below.
 export default function decodeJson(input) {
-  // Value must be JSON string to match node-mysql results
-  // Related to this node-mysql PR:
-  // https://github.com/felixge/node-mysql/pull/1299
-  return JSON.stringify(parseBinaryBuffer(input));
+  return parseBinaryBuffer(input);
+}
+
+const MAX_SAFE_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+const MIN_SAFE_BIGINT = BigInt(Number.MIN_SAFE_INTEGER);
+
+// For parsed-value output: BigInts become Numbers when within the safe
+// integer range, exact strings otherwise. Mutates objects/arrays in place
+// (they were freshly created by parseBinaryBuffer).
+export function convertBigInts(value) {
+  if (typeof value === 'bigint') {
+    return (value >= MIN_SAFE_BIGINT && value <= MAX_SAFE_BIGINT) ?
+      Number(value) : value.toString();
+  }
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      value[i] = convertBigInts(value[i]);
+    }
+    return value;
+  }
+  if (value !== null && typeof value === 'object') {
+    for (const key of Object.keys(value)) {
+      value[key] = convertBigInts(value[key]);
+    }
+    return value;
+  }
+  return value;
+}
+
+// For jsonStrings output: serialise to JSON text with 64-bit integers as
+// raw numerals (JSON.stringify cannot represent BigInt), so the text
+// matches what the server would print for the column.
+export function jsonToText(value) {
+  if (value === null) {
+    return 'null';
+  }
+  switch (typeof value) {
+    case 'bigint':
+    case 'number':
+    case 'boolean':
+      return String(value);
+    case 'string':
+      return JSON.stringify(value);
+    default:
+      if (Array.isArray(value)) {
+        return '[' + value.map(jsonToText).join(', ') + ']';
+      }
+      return '{' + Object.keys(value).map(key =>
+        JSON.stringify(key) + ': ' + jsonToText(value[key])
+      ).join(', ') + '}';
+  }
 }
 
 /*
@@ -112,25 +163,17 @@ function parseBinaryBuffer(input, offset, parentValueOffset, readUInt, isLarge)
       result = isLarge ? input.readUInt32LE(offset + 1) : input.readUInt32LE(valueOffset + 1);
       break;
     case JSONB_TYPE_INT64: {
-      let low = input.readUInt32LE(valueOffset + 1);
-      let high = input.readUInt32LE(valueOffset + 5);
-      if (high & (1 << 31)) {
-        // Javascript integers only support 2^53 not 2^64, must trim bits!
-        // 64-53 = 11, 32-11 = 21, so grab first 21 bits of high word only
-        const mask = Math.pow(2, 32) - 1;
-        high = common.sliceBits(high ^ mask, 0, 21);
-        low = low ^ mask;
-        result =
-          ((high * Math.pow(2, 32)) * - 1) - common.getUInt32Value(low) - 1;
-      } else {
-        result = (high * Math.pow(2,32)) + low;
-      }
+      const low = input.readUInt32LE(valueOffset + 1);
+      const high = input.readUInt32LE(valueOffset + 5);
+      // Exact; converted to Number / string / raw JSON numeral by the
+      // consumers below
+      result = BigInt.asIntN(64, (BigInt(high) << 32n) | BigInt(low));
       break;
     }
     case JSONB_TYPE_UINT64: {
       const low = input.readUInt32LE(valueOffset + 1);
       const high = input.readUInt32LE(valueOffset + 5);
-      result = (high * Math.pow(2,32)) + low;
+      result = (BigInt(high) << 32n) | BigInt(low);
       break;
     }
     case JSONB_TYPE_OPAQUE: {

package/lib/packet/binlog.js

@@ -32,6 +32,13 @@ export default function initBinlogPacketClass(zongji) {
       const EventClass = getEventClass(eventType);
       this.eventName = EventClass.name;
 
+      // Warn (once per instance) about event types that carry row changes
+      // zongji cannot decode. This must happen before event filtering so
+      // the data loss is loud even when the type is not included.
+      if (EventClass.unsupportedReason) {
+        zongji._warnUnsupportedEvent(EventClass);
+      }
+
       yield;
 
       try {

package/lib/reader.js

@@ -1,145 +1,6 @@
-// Constants for variable length encoded binary
-export const NULL_COLUMN = 251;
-export const UNSIGNED_CHAR_COLUMN = 251;
-export const UNSIGNED_SHORT_COLUMN = 252;
-export const UNSIGNED_INT24_COLUMN = 253;
-export const UNSIGNED_INT64_COLUMN = 254;
-
-const padWith = function(val, length) {
-  const bits = val.split('');
-  if (bits.length < length) {
-    const left = length - bits.length;
-    for (let j = left - 1; j >= 0; j--) {
-      bits.unshift('0');
-    }
-    val = bits.join('');
-  }
-
-  return val;
-};
-
-class BufferReader {
-  constructor(buffer) {
-    this.buffer = buffer;
-    this.position = 0;
-  }
-
-  readUInt8() {
-    const pos = this.position;
-    this.position += 1;
-
-    return this.buffer.readUInt8(pos);
-  }
-
-  readUInt16() {
-    const pos = this.position;
-    this.position += 2;
-
-    return this.buffer.readUInt16LE(pos);
-  }
-
-  readUInt32() {
-    const pos = this.position;
-    this.position += 4;
-
-    return this.buffer.readUInt32LE(pos);
-  }
-
-  readUInt24() {
-    const low = this.readUInt16();
-    const high = this.readUInt8();
-    return (high << 16) + low;
-  }
-
-  readUInt64() {
-    const pos = this.position;
-    this.position += 8;
-
-    // from http://stackoverflow.com/questions/17687307/convert-a-64bit-little-endian-integer-to-number
-    return this.buffer.readInt32LE(pos) +
-      0x100000000 * this.buffer.readUInt32LE(pos + 4);
-  }
-
-  readString() {
-    const strBuf = this.buffer.slice(this.position);
-    this.position = this.buffer.length;
-
-    return strBuf.toString('ascii');
-  }
-
-  readStringInBytes(length) {
-    const strBuf = this.buffer.slice(this.position, this.position + length);
-    this.position += length;
-
-    return strBuf.toString('ascii');
-  }
-
-  readHexInBytes(length) {
-    const buf = this.buffer.slice(this.position, this.position + length);
-    this.position += length;
-
-    return buf.toString('hex');
-  }
-
-  readBytesArray(length) {
-    const result = [];
-    const hexString = this.readHexInBytes(length);
-    for (let i = 0; i < hexString.length; i = i + 2) {
-      result.push(parseInt(hexString.substr(i, 2), 16));
-    }
-    return result;
-  }
-
-  // Read a variable-length "Length Coded Binary" integer. This is derived
-  // from the MySQL protocol, and re-used in the binary log format. This
-  // format uses the first byte to alternately store the actual value for
-  // integer values <= 250, or to encode the number of following bytes
-  // used to store the actual value, which can be 2, 3, or 8. It also
-  // includes support for SQL NULL as a special case.
-  readVariant() {
-    let result = null;
-    const firstByte = this.readUInt8();
-
-    if (firstByte < UNSIGNED_CHAR_COLUMN) {
-      result = firstByte;
-    } else if (firstByte === NULL_COLUMN) {
-      result = null;
-    } else if (firstByte === UNSIGNED_SHORT_COLUMN) {
-      result = this.readUInt16();
-    } else if (firstByte === UNSIGNED_INT24_COLUMN) {
-      result = this.readUInt24();
-    } else if (firstByte === UNSIGNED_INT64_COLUMN) {
-      result = this.readUInt64();
-    } else {
-      throw new Error('Invalid variable-length integer');
-    }
-
-    return result;
-  }
-
-  // Read an arbitrary-length bitmap, provided its length.
-  // Returns an array of true/false values.
-  readBitArray(length) {
-    const size = Math.floor((length + 7) / 8);
-
-    const bytes = [];
-    for (let i = size - 1; i >= 0; i--) {
-      bytes.unshift(this.readUInt8());
-    }
-
-    const bitmap = [];
-    const bitmapStr = bytes.map(function(aByte) {
-      return padWith(aByte.toString(2), 8);
-    }).join('');
-
-    for (let k = bitmapStr.length - 1; k >= 0; k--) {
-      bitmap.push(bitmapStr[k] === '1');
-    }
-
-    return bitmap.slice(0, length);
-  }
-}
-
+// Minimal parser over a mysql2 packet (or a bare buffer via append()),
+// providing the subset of the node-mysql Parser interface that the binlog
+// event classes consume.
 class Parser {
   constructor(packet) {
     this.packet = null;
@@ -244,4 +105,4 @@ class Parser {
   }
 }
 
-export { BufferReader, Parser };
+export { Parser };

package/lib/sequence/binlog.js

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'events';
-import { initBinlogPacketClass } from '../packet/index.js';
+import initBinlogPacketClass from '../packet/binlog.js';
 import { Parser } from '../reader.js';
 
 const BINLOG_DUMP_COMMAND = 0x12;
@@ -137,16 +137,41 @@ export default function initBinlogClass(zongji) {
         const eventName = binlogPacket.eventName
           ? binlogPacket.eventName.toLowerCase()
           : 'unknown';
-        if (zongji._skipEvent(eventName)) {
-          return Binlog.prototype.binlogData;
-        }
 
         let event;
         let error;
-        try {
-          event = binlogPacket.getEvent();
-        } catch (err) {
-          error = err;
+
+        // Track the current transaction GTID before event filtering, so
+        // subsequent events can carry event.gtid even when 'gtid' events
+        // themselves are excluded by includeEvents
+        const isGtidEvent =
+          eventName === 'gtid' || eventName === 'anonymousgtid';
+        if (isGtidEvent) {
+          try {
+            event = binlogPacket.getEvent();
+            // Anonymous transactions have no usable GTID; do not let a
+            // previous transaction's GTID leak onto their events
+            zongji._currentGtid =
+              eventName === 'gtid' ? event.gtid : undefined;
+          } catch (err) {
+            zongji._currentGtid = undefined;
+            error = err;
+          }
+        }
+
+        // A GTID parse failure corrupts transaction attribution for the
+        // whole following transaction, so it must surface even when the
+        // event type itself is filtered out
+        if (zongji._skipEvent(eventName) && !error) {
+          return Binlog.prototype.binlogData;
+        }
+
+        if (!isGtidEvent && !error) {
+          try {
+            event = binlogPacket.getEvent();
+          } catch (err) {
+            error = err;
+          }
         }
         this._callback.call(this, error, event);
       }

package/package.json

@@ -1,16 +1,20 @@
 {
   "name": "@vlasky/zongji",
-  "version": "0.6.1",
+  "version": "0.7.1",
   "description": "MySQL binlog-based change data capture (CDC) for Node.js",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",
-  "directories": {
-    "test": "test"
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    }
   },
   "scripts": {
     "pretest": "bash scripts/start-mysql.sh",
     "test": "tap --bail --disable-coverage --jobs=1 test/*.js",
+    "test:only": "tap --bail --disable-coverage --jobs=1 test/*.js",
     "lint": "eslint .",
     "checkjs": "tsc --project jsconfig.json"
   },
@@ -42,8 +46,7 @@
     "tap": "^21.5.0"
   },
   "dependencies": {
-    "big-integer": "1.6.52",
     "iconv-lite": "0.7.2",
-    "mysql2": "^3.17.1"
+    "mysql2": "^3.22.5"
   }
 }

package/.travis.yml

@@ -1,15 +0,0 @@
-language: node_js
-sudo: required
-dist: trusty
-node_js:
-  - "8"
-  - "12"
-services:
-  - docker
-before_script:
-  - npm run lint
-  - docker run -p 3355:3306 --name mysql-55 -e MYSQL_ROOT_PASSWORD=numtel -d mysql:5.5 --server-id=1 --log-bin=/var/lib/mysql/mysql-bin.log --binlog-format=row
-  - docker run -p 3356:3306 --name mysql-56 -e MYSQL_ROOT_PASSWORD=numtel -d mysql:5.6 --server-id=1 --log-bin=/var/lib/mysql/mysql-bin.log --binlog-format=row
-  - docker run -p 3357:3306 --name mysql-57 -e MYSQL_ROOT_PASSWORD=numtel -d mysql:5.7 --server-id=1 --log-bin=/var/lib/mysql/mysql-bin.log --binlog-format=row
-script:
-  - ./test/travis/runner.sh

package/docker-compose.yml

@@ -1,33 +0,0 @@
----
-services:
-  mysql57:
-    image: mysql:5.7
-    command: [ "--server-id=1", "--log-bin=/var/lib/mysql/mysql-bin.log", "--binlog-format=row"]
-    networks:
-      default:
-        aliases:
-          - mysql57
-    environment:
-      MYSQL_ROOT_PASSWORD: secret
-
-  mysql80:
-    image: mysql:8.0
-    command: [ "--server-id=1", "--log-bin=/var/lib/mysql/mysql-bin.log", "--binlog-format=row"]
-    networks:
-      default:
-        aliases:
-          - mysql80
-    environment:
-      MYSQL_ROOT_PASSWORD: secret
-
-  mysql84:
-    image: mysql:8.4
-    command: [ "--server-id=1", "--log-bin=/var/lib/mysql/mysql-bin.log", "--binlog-format=row"]
-    ports:
-      - "3306:3306"
-    networks:
-      default:
-        aliases:
-          - mysql84
-    environment:
-      MYSQL_ROOT_PASSWORD: secret

package/docker-test.sh

@@ -1,11 +0,0 @@
-#!/bin/bash
-MYSQL_HOSTS="mysql57 mysql80 mysql84"
-
-for hostname in ${MYSQL_HOSTS}; do
-  echo $hostname + node 18
-  docker run -it --network=zongji_default -e MYSQL_HOST=$hostname -w /build -v $PWD:/build node:18 npm test
-  echo $hostname + node 20
-  docker run -it --network=zongji_default -e MYSQL_HOST=$hostname -w /build -v $PWD:/build node:20 npm test
-  echo $hostname + node 22
-  docker run -it --network=zongji_default -e MYSQL_HOST=$hostname -w /build -v $PWD:/build node:22 npm test
-done

package/eslint.config.js

@@ -1,35 +0,0 @@
-import js from '@eslint/js';
-
-export default [
-  { ignores: ['.tap/'] },
-  js.configs.recommended,
-  {
-    languageOptions: {
-      ecmaVersion: 2022,
-      sourceType: 'module',
-      globals: {
-        Buffer: 'readonly',
-        clearImmediate: 'readonly',
-        clearInterval: 'readonly',
-        clearTimeout: 'readonly',
-        console: 'readonly',
-        process: 'readonly',
-        setImmediate: 'readonly',
-        setInterval: 'readonly',
-        setTimeout: 'readonly',
-      },
-    },
-    rules: {
-      'comma-dangle': ['warn', 'only-multiline'],
-      'eol-last': ['error'],
-      'keyword-spacing': ['error', { before: true }],
-      'no-console': 'off',
-      'no-trailing-spaces': ['error', { skipBlankLines: true }],
-      'no-unused-vars': 'warn',
-      'no-var': 'warn',
-      'quotes': ['warn', 'single', 'avoid-escape'],
-      'semi': ['error', 'always'],
-      'space-before-blocks': 'error',
-    },
-  },
-];

package/jsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "checkJs": true,
-    "allowJs": true,
-    "noEmit": true,
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "skipDefaultLibCheck": true,
-    "maxNodeModuleJsDepth": 0,
-    "types": ["node"]
-  },
-  "include": ["index.js", "index.d.ts", "lib/**/*.js"],
-  "exclude": ["node_modules", ".tap"]
-}