fix: added node v18 polyfills and set engines

Author: titanism

package.json

@@ -16,6 +16,9 @@
     "@types/node": "^22.0.2",
     "typescript": "^5.4.3"
   },
+  "engines": {
+    "node": ">= 18"
+  },
   "homepage": "https://github.com/cleandns-inc/tool-whois#readme",
   "license": "ISC",
   "main": "dist/index.js",

src/index.test.ts

@@ -1,5 +1,9 @@
 import { describe, it } from "node:test";
 import assert from "node:assert";
+
+// Import polyfills first
+import "./polyfills.js";
+
 import { toArray, escapeRegex, validateDomain } from "./index.js";
 
 // ============================================================================
@@ -358,3 +362,77 @@ describe("IP response parsing", () => {
     assert.strictEqual(response.registrar.name, "ARIN");
   });
 });
+
+
+// ============================================================================
+// String.prototype.toWellFormed polyfill tests (Node.js 18 compatibility)
+// ============================================================================
+
+describe("String.prototype.toWellFormed polyfill", () => {
+  it("toWellFormed is available as a function", () => {
+    assert.strictEqual(typeof "".toWellFormed, "function");
+  });
+
+  it("returns same string for well-formed input", () => {
+    const str = "Hello, World!";
+    assert.strictEqual(str.toWellFormed(), str);
+  });
+
+  it("handles empty string", () => {
+    assert.strictEqual("".toWellFormed(), "");
+  });
+
+  it("handles valid surrogate pairs (emoji)", () => {
+    const emoji = "😀"; // U+1F600 = \uD83D\uDE00
+    assert.strictEqual(emoji.toWellFormed(), emoji);
+  });
+
+  it("replaces lone high surrogate with U+FFFD", () => {
+    const loneHigh = "abc\uD800def";
+    assert.strictEqual(loneHigh.toWellFormed(), "abc\uFFFDdef");
+  });
+
+  it("replaces lone low surrogate with U+FFFD", () => {
+    const loneLow = "abc\uDC00def";
+    assert.strictEqual(loneLow.toWellFormed(), "abc\uFFFDdef");
+  });
+
+  it("replaces lone high surrogate at end", () => {
+    const str = "test\uD800";
+    assert.strictEqual(str.toWellFormed(), "test\uFFFD");
+  });
+
+  it("handles multiple lone surrogates", () => {
+    const str = "\uD800\uD800";
+    assert.strictEqual(str.toWellFormed(), "\uFFFD\uFFFD");
+  });
+
+  it("preserves valid surrogate pairs among lone surrogates", () => {
+    const str = "\uD800\uD83D\uDE00\uDC00"; // lone high, valid pair, lone low
+    assert.strictEqual(str.toWellFormed(), "\uFFFD😀\uFFFD");
+  });
+});
+
+describe("String.prototype.isWellFormed polyfill", () => {
+  it("isWellFormed is available as a function", () => {
+    assert.strictEqual(typeof "".isWellFormed, "function");
+  });
+
+  it("returns true for well-formed strings", () => {
+    assert.strictEqual("Hello".isWellFormed(), true);
+    assert.strictEqual("".isWellFormed(), true);
+    assert.strictEqual("😀".isWellFormed(), true);
+  });
+
+  it("returns false for lone high surrogate", () => {
+    assert.strictEqual("test\uD800".isWellFormed(), false);
+  });
+
+  it("returns false for lone low surrogate", () => {
+    assert.strictEqual("test\uDC00".isWellFormed(), false);
+  });
+
+  it("returns true for valid surrogate pair", () => {
+    assert.strictEqual("\uD83D\uDE00".isWellFormed(), true);
+  });
+});

src/index.ts

@@ -1,3 +1,6 @@
+// Polyfills for Node.js 18 compatibility
+import "./polyfills.js";
+
 import { WhoisOptions, WhoisResponse, WhoisTimestampFields } from "../whois.js";
 import { parseIpResponse } from "./ip.js";
 import { determinePort43Domain, port43 } from "./port43.js";

src/polyfills.ts

@@ -0,0 +1,76 @@
+/**
+ * Polyfills for Node.js 18 compatibility.
+ * String.prototype.toWellFormed was added in Node.js 20.
+ */
+
+// Extend String interface for TypeScript
+declare global {
+  interface String {
+    toWellFormed(): string;
+    isWellFormed(): boolean;
+  }
+}
+
+// Polyfill for String.prototype.toWellFormed (ES2024)
+// Replaces lone surrogates with U+FFFD (replacement character)
+if (typeof String.prototype.toWellFormed !== 'function') {
+  String.prototype.toWellFormed = function () {
+    const str = String(this);
+    const len = str.length;
+    let result = '';
+
+    for (let i = 0; i < len; i++) {
+      const code = str.charCodeAt(i);
+
+      // Check for lone surrogates
+      if (code >= 0xD800 && code <= 0xDBFF) {
+        // High surrogate
+        if (i + 1 < len) {
+          const next = str.charCodeAt(i + 1);
+          if (next >= 0xDC00 && next <= 0xDFFF) {
+            // Valid surrogate pair
+            result += str[i] + str[i + 1];
+            i++;
+            continue;
+          }
+        }
+        // Lone high surrogate - replace with U+FFFD
+        result += '\uFFFD';
+      } else if (code >= 0xDC00 && code <= 0xDFFF) {
+        // Lone low surrogate - replace with U+FFFD
+        result += '\uFFFD';
+      } else {
+        result += str[i];
+      }
+    }
+
+    return result;
+  };
+}
+
+// Polyfill for String.prototype.isWellFormed (ES2024)
+if (typeof String.prototype.isWellFormed !== 'function') {
+  String.prototype.isWellFormed = function () {
+    const str = String(this);
+    const len = str.length;
+
+    for (let i = 0; i < len; i++) {
+      const code = str.charCodeAt(i);
+
+      if (code >= 0xD800 && code <= 0xDBFF) {
+        // High surrogate - check for valid pair
+        if (i + 1 >= len) return false;
+        const next = str.charCodeAt(i + 1);
+        if (next < 0xDC00 || next > 0xDFFF) return false;
+        i++; // Skip the low surrogate
+      } else if (code >= 0xDC00 && code <= 0xDFFF) {
+        // Lone low surrogate
+        return false;
+      }
+    }
+
+    return true;
+  };
+}
+
+export {};