refactor: Modernise polyfills with Object.hasOwn and ES2024 features

- Implement `Object.hasOwn` polyfill and use it for internal property checks.
- Add [`Promise.withResolvers`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers) (ES2024) to the standard library.
- Optimise `prepend`, `replaceWith`, and `toggleAttribute` for performance and spec compliance.
- Set polyfilled methods to non-enumerable to match native behavior.
- Introduce robust `createTextNode` and `createDocumentFragment` utility helpers.
- Improve performance by replacing `Array.slice` on arguments with manual loops.

(AI generated commit message)

Author: Autist1Coder

src/lib/polyfill.js

@@ -1,46 +1,62 @@
 (function () {
+	// polyfill for Object.hasOwn
+
+	(function () {
+		var oldHasOwn = Function.prototype.call.bind(
+			Object.prototype.hasOwnProperty,
+		);
+		if (oldHasOwn(Object, "hasOwn")) return;
+		Object.defineProperty(Object, "hasOwn", {
+			configurable: true,
+			enumerable: false,
+			writable: true,
+			value: function hasOwn(obj, prop) {
+				return oldHasOwn(obj, prop);
+			},
+		});
+		Object.hasOwn.prototype = null;
+	})();
+
 	// polyfill for prepend
 
 	(function (arr) {
 		arr.forEach(function (item) {
-			if (item.hasOwnProperty("prepend")) {
-				return;
-			}
+			if (Object.hasOwn(item, "prepend")) return;
 			Object.defineProperty(item, "prepend", {
 				configurable: true,
-				enumerable: true,
+				enumerable: false,
 				writable: true,
 				value: function prepend() {
-					var argArr = Array.prototype.slice.call(arguments),
-						docFrag = document.createDocumentFragment();
+					var docFrag = createDocumentFragment();
 
-					argArr.forEach(function (argItem) {
-						var node =
-							argItem instanceof Node
-								? argItem
-								: document.createTextNode(String(argItem));
-						docFrag.appendChild(node);
-					});
+					var argLength = arguments.length;
+					for (var i = 0; i < argLength; i++) {
+						var argItem = arguments[i];
+						docFrag.appendChild(
+							argItem instanceof Node ? argItem : createTextNode(argItem + ""),
+						);
+					}
 
 					this.insertBefore(docFrag, this.firstChild);
 				},
 			});
+			item.prepend.prototype = null;
 		});
 	})([Element.prototype, Document.prototype, DocumentFragment.prototype]);
 
 	// polyfill for closest
 
 	(function (arr) {
 		arr.forEach(function (item) {
-			if (item.hasOwnProperty("closest")) {
-				return;
-			}
+			if (Object.hasOwn(item, "closest")) return;
 			Object.defineProperty(item, "closest", {
 				configurable: true,
-				enumerable: true,
+				enumerable: false,
 				writable: true,
 				value: function closest(s) {
-					var matches = (this.document || this.ownerDocument).querySelectorAll(s),
+					var matches = (this.document || this.ownerDocument).querySelectorAll(
+							s,
+						),
 						i,
 						el = this;
 					do {
@@ -50,68 +66,78 @@
 					return el;
 				},
 			});
+			item.closest.prototype = null;
 		});
 	})([Element.prototype]);
 
 	// polyfill for replaceWith
 
 	(function (arr) {
 		arr.forEach(function (item) {
-			if (item.hasOwnProperty("replaceWith")) {
-				return;
-			}
+			if (Object.hasOwn(item, "replaceWith")) return;
 			Object.defineProperty(item, "replaceWith", {
 				configurable: true,
-				enumerable: true,
+				enumerable: false,
 				writable: true,
 				value: function replaceWith() {
-					var parent = this.parentNode,
-						i = arguments.length,
-						currentNode;
+					var parent = this.parentNode;
 					if (!parent) return;
-					if (!i)
-						// if there are no arguments
-						parent.removeChild(this);
-					while (i--) {
-						// i-- decrements i and returns the value of i before the decrement
-						currentNode = arguments[i];
+					var viableNextSibling = this.nextSibling;
+					var argLength = arguments.length;
+					while (viableNextSibling) {
+						var inArgs = false;
+						for (var j = 0; j < argLength; j++) {
+							if (arguments[j] === viableNextSibling) { inArgs = true; break; }
+						}
+						if (!inArgs) break;
+						viableNextSibling = viableNextSibling.nextSibling;
+					}
+					var docFrag = createDocumentFragment();
+					for (var i = 0; i < argLength; i++) {
+						var currentNode = arguments[i];
 						if (typeof currentNode !== "object") {
-							currentNode = this.ownerDocument.createTextNode(currentNode);
+							currentNode = createTextNode(currentNode, this.ownerDocument);
 						} else if (currentNode.parentNode) {
 							currentNode.parentNode.removeChild(currentNode);
 						}
-						// the value of "i" below is after the decrement
-						if (!i)
-							// if currentNode is the first argument (currentNode === arguments[0])
-							parent.replaceChild(currentNode, this);
-						// if currentNode isn't the first
-						else parent.insertBefore(this.previousSibling, currentNode);
+						docFrag.appendChild(currentNode);
+					}
+					if (argLength >= 1) {
+						if (viableNextSibling) {
+							parent.insertBefore(docFrag, viableNextSibling);
+						} else {
+							parent.appendChild(docFrag);
+						}
+					} else {
+						parent.removeChild(this);
 					}
 				},
 			});
+			item.replaceWith.prototype = null;
 		});
 	})([Element.prototype, CharacterData.prototype, DocumentType.prototype]);
 
 	// polyfill for toggleAttribute
 
 	(function (arr) {
 		arr.forEach(function (item) {
-			if (item.hasOwnProperty("toggleAttribute")) {
-				return;
-			}
+			if (Object.hasOwn(item, "toggleAttribute")) return;
 			Object.defineProperty(item, "toggleAttribute", {
 				configurable: true,
-				enumerable: true,
+				enumerable: false,
 				writable: true,
 				value: function toggleAttribute() {
 					var attr = arguments[0];
 					if (this.hasAttribute(attr)) {
 						this.removeAttribute(attr);
+						return false;
 					} else {
-						this.setAttribute(attr, arguments[1] || "");
+						this.setAttribute(attr, arguments.length >= 2 ? arguments[1] : "");
+						return true;
 					}
 				},
 			});
+			item.toggleAttribute.prototype = null;
 		});
 	})([Element.prototype]);
 
@@ -141,4 +167,49 @@
 			};
 		}
 	})();
+
+	// polyfill for Promise.withResolvers
+
+	if (!Object.hasOwn(Promise, "withResolvers")) {
+		Object.defineProperty(Promise, "withResolvers", {
+			configurable: true,
+			enumerable: false,
+			writable: true,
+			value: function withResolvers() {
+				var resolve, reject;
+				var promise = new this(function (_resolve, _reject) {
+					resolve = _resolve;
+					reject = _reject;
+				});
+				if (typeof resolve !== "function" || typeof reject !== "function") {
+					throw new TypeError(
+						"Promise resolve or reject function is not callable",
+					);
+				}
+				return {
+					promise: promise,
+					resolve: resolve,
+					reject: reject,
+				};
+			},
+		});
+		Promise.withResolvers.prototype = null;
+	}
+
+	// utils
+
+	function createTextNode(text, doc) {
+		if (doc === undefined) doc = document;
+		if (doc !== document) try {
+			return new Text(text);
+		} catch (_) {}
+		return doc.createTextNode(text);
+	}
+	function createDocumentFragment() {
+		try {
+			return new DocumentFragment();
+		} catch (_) {
+			return document.createDocumentFragment();
+		}
+	}
 })();