@depup/jsdom 28.1.0-depup.1

package/lib/jsdom/living/file-api/Blob-impl.js

@@ -0,0 +1,125 @@
+"use strict";
+const { utf8Encode, utf8Decode } = require("../helpers/encoding");
+const Blob = require("../../../generated/idl/Blob");
+const { isArrayBuffer } = require("../../../generated/idl/utils");
+const { concatTypedArrays, copyToArrayBufferInTargetRealm } = require("../helpers/binary-data");
+
+function convertLineEndingsToNative(s) {
+  // jsdom always pretends to be *nix, for consistency.
+  // See also https://github.com/jsdom/jsdom/issues/2396.
+  return s.replace(/\r\n|\r|\n/g, "\n");
+}
+
+exports.implementation = class BlobImpl {
+  constructor(globalObject, [parts, properties], { fastPathArrayBufferToWrap } = {}) {
+    this._globalObject = globalObject;
+
+    this.type = properties.type;
+    if (/[^\u0020-\u007E]/.test(this.type)) {
+      this.type = "";
+    } else {
+      this.type = this.type.toLowerCase();
+    }
+
+    // A word about `this._bytes`:
+    //
+    // It is a `Uint8Array`. The realm of that `Uint8Array`, and/or the realm of its underlying `ArrayBuffer`, may be
+    // arbitrary. In particular, they likely do *not* match `this._globalObject`. The underlying `ArrayBuffer` may have
+    // been acquired from some other part of the system, e.g., the `ws` library, or aliased to another `BlobImpl`'s
+    // `_bytes`.
+    //
+    // This is fine, and indeed desirable, for efficiency. The key is that `Blob` is conceptually immutable, so users
+    // will never mutate the underlying `ArrayBuffer`. And, we never expose `this._bytes` or the underlying
+    // `ArrayBuffer` directly to the user: we always use something like `copyToArrayBufferInTargetRealm()` to ensure the
+    // result is in the realm appropriate for the user's request, and that if the user mutates the exposed bytes, this
+    // doesn't impact `this._bytes`.
+
+    // Used internally in jsdom when we receive an `ArrayBuffer` from elsewhere in the system and know we don't need to
+    // copy it because the user doesn't have any references to it. It's OK if `fastPathArrayBufferToWrap` is in the
+    // wrong realm even, because it never directly escapes the `BlobImpl` without a copy.
+    if (fastPathArrayBufferToWrap) {
+      this._bytes = new Uint8Array(fastPathArrayBufferToWrap);
+      return;
+    }
+
+    const chunks = [];
+    if (parts !== undefined) {
+      for (const part of parts) {
+        let chunk;
+        if (isArrayBuffer(part)) {
+          // Create a wrapper. The copying will happen in `concatTypedArrays()`.
+          chunk = new Uint8Array(part);
+        } else if (ArrayBuffer.isView(part)) {
+          // Use the part as-is. The copying will happen in `concatTypedArrays()`.
+          chunk = part;
+        } else if (Blob.isImpl(part)) {
+          // Use the existing `Uint8Array` as-is. The copying will happen in `concatTypedArrays()`.
+          chunk = part._bytes;
+        } else {
+          let s = part;
+          if (properties.endings === "native") {
+            s = convertLineEndingsToNative(s);
+          }
+          chunk = utf8Encode(s);
+        }
+        chunks.push(chunk);
+      }
+    }
+    this._bytes = concatTypedArrays(chunks);
+  }
+
+  get size() {
+    return this._bytes.length;
+  }
+
+  arrayBuffer() {
+    const ab = copyToArrayBufferInTargetRealm(this._bytes.buffer, this._globalObject);
+    return this._globalObject.Promise.resolve(ab);
+  }
+
+  bytes() {
+    const ab = copyToArrayBufferInTargetRealm(this._bytes.buffer, this._globalObject);
+    return this._globalObject.Promise.resolve(new this._globalObject.Uint8Array(ab));
+  }
+
+  text() {
+    return this._globalObject.Promise.resolve(utf8Decode(this._bytes));
+  }
+
+  slice(start, end, contentType) {
+    const { size } = this;
+
+    let relativeStart, relativeEnd, relativeContentType;
+
+    if (start === undefined) {
+      relativeStart = 0;
+    } else if (start < 0) {
+      relativeStart = Math.max(size + start, 0);
+    } else {
+      relativeStart = Math.min(start, size);
+    }
+    if (end === undefined) {
+      relativeEnd = size;
+    } else if (end < 0) {
+      relativeEnd = Math.max(size + end, 0);
+    } else {
+      relativeEnd = Math.min(end, size);
+    }
+
+    if (contentType === undefined) {
+      relativeContentType = "";
+    } else {
+      // sanitization (lower case and invalid char check) is done in the
+      // constructor
+      relativeContentType = contentType;
+    }
+
+    const span = Math.max(relativeEnd - relativeStart, 0);
+
+    const slicedBuffer = this._bytes.slice(relativeStart, relativeStart + span);
+
+    const blob = Blob.createImpl(this._globalObject, [[], { type: relativeContentType }], {});
+    blob._bytes = slicedBuffer;
+    return blob;
+  }
+};

package/lib/jsdom/living/file-api/File-impl.js

@@ -0,0 +1,12 @@
+"use strict";
+
+const BlobImpl = require("./Blob-impl").implementation;
+
+exports.implementation = class FileImpl extends BlobImpl {
+  constructor(globalObject, [fileBits, fileName, options], privateData) {
+    super(globalObject, [fileBits, options], privateData);
+
+    this.name = fileName;
+    this.lastModified = "lastModified" in options ? options.lastModified : Date.now();
+  }
+};

package/lib/jsdom/living/file-api/FileList-impl.js

@@ -0,0 +1,15 @@
+"use strict";
+
+const idlUtils = require("../../../generated/idl/utils.js");
+
+exports.implementation = class FileListImpl extends Array {
+  constructor() {
+    super(0);
+  }
+  item(index) {
+    return this[index] || null;
+  }
+  get [idlUtils.supportedPropertyIndices]() {
+    return this.keys();
+  }
+};

package/lib/jsdom/living/file-api/FileReader-impl.js

@@ -0,0 +1,148 @@
+"use strict";
+
+const { labelToName, legacyHookDecode } = require("@exodus/bytes/encoding.js");
+const { toBase64 } = require("@exodus/bytes/base64.js");
+const { MIMEType } = require("whatwg-mimetype");
+const DOMException = require("../../../generated/idl/DOMException");
+const EventTargetImpl = require("../events/EventTarget-impl").implementation;
+const ProgressEvent = require("../../../generated/idl/ProgressEvent");
+const { setupForSimpleEventAccessors } = require("../helpers/create-event-accessor");
+const { fireAnEvent } = require("../helpers/events");
+const { copyToArrayBufferInTargetRealm } = require("../helpers/binary-data");
+
+const READY_STATES = Object.freeze({
+  EMPTY: 0,
+  LOADING: 1,
+  DONE: 2
+});
+
+const events = ["loadstart", "progress", "load", "abort", "error", "loadend"];
+
+class FileReaderImpl extends EventTargetImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this.error = null;
+    this.readyState = READY_STATES.EMPTY;
+    this.result = null;
+
+    this._globalObject = globalObject;
+    this._ownerDocument = globalObject.document;
+    this._terminated = false;
+  }
+
+  readAsArrayBuffer(file) {
+    this._readFile(file, "buffer");
+  }
+  readAsBinaryString(file) {
+    this._readFile(file, "binaryString");
+  }
+  readAsDataURL(file) {
+    this._readFile(file, "dataURL");
+  }
+  readAsText(file, encodingLabel) {
+    this._readFile(file, "text", labelToName(encodingLabel) || "UTF-8");
+  }
+
+  abort() {
+    if (this.readyState === READY_STATES.EMPTY || this.readyState === READY_STATES.DONE) {
+      this.result = null;
+      return;
+    }
+
+    if (this.readyState === READY_STATES.LOADING) {
+      this.readyState = READY_STATES.DONE;
+      this.result = null;
+    }
+
+    this._terminated = true;
+    this._fireProgressEvent("abort");
+    this._fireProgressEvent("loadend");
+  }
+
+  _fireProgressEvent(name, props) {
+    fireAnEvent(name, this, ProgressEvent, props);
+  }
+
+  _readFile(file, format, encodingLabel) {
+    if (this.readyState === READY_STATES.LOADING) {
+      throw DOMException.create(this._globalObject, [
+        "The object is in an invalid state.",
+        "InvalidStateError"
+      ]);
+    }
+
+    this.readyState = READY_STATES.LOADING;
+    this.result = null;
+    this.error = null;
+
+    // Multiple separate tasks are necessary to match the spec's separate "queue a task" invocations.
+    setImmediate(() => {
+      if (this._terminated) {
+        this._terminated = false;
+        return;
+      }
+
+      this._fireProgressEvent("loadstart");
+
+      setImmediate(() => {
+        if (this._terminated) {
+          this._terminated = false;
+          return;
+        }
+
+        if (file._bytes.length > 0) {
+          this._fireProgressEvent("progress", {
+            lengthComputable: !isNaN(file.size),
+            total: file.size,
+            loaded: file._bytes.length
+          });
+        }
+
+        setImmediate(() => {
+          if (this._terminated) {
+            this._terminated = false;
+            return;
+          }
+
+          this._setResult(file, format, encodingLabel);
+          this.readyState = READY_STATES.DONE;
+          this._fireProgressEvent("load");
+          this._fireProgressEvent("loadend");
+        });
+      });
+    });
+  }
+
+  _setResult(file, format, encodingLabel) {
+    switch (format) {
+      case "binaryString": {
+        // Convert Uint8Array to binary string (each byte as a code point)
+        let binaryString = "";
+        for (let i = 0; i < file._bytes.length; i++) {
+          binaryString += String.fromCharCode(file._bytes[i]);
+        }
+        this.result = binaryString;
+        break;
+      }
+      case "dataURL": {
+        // Spec seems very unclear here; see https://github.com/w3c/FileAPI/issues/104.
+        const contentType = MIMEType.parse(file.type) || "application/octet-stream";
+        this.result = `data:${contentType};base64,${toBase64(file._bytes)}`;
+        break;
+      }
+      case "text": {
+        this.result = legacyHookDecode(file._bytes, encodingLabel);
+        break;
+      }
+      case "buffer":
+      default: {
+        this.result = copyToArrayBufferInTargetRealm(file._bytes.buffer, this._globalObject);
+        break;
+      }
+    }
+  }
+}
+setupForSimpleEventAccessors(FileReaderImpl.prototype, events);
+
+exports.implementation = FileReaderImpl;

package/lib/jsdom/living/geometry/DOMRect-impl.js

@@ -0,0 +1,39 @@
+"use strict";
+const DOMRectReadOnlyImpl = require("./DOMRectReadOnly-impl").implementation;
+const DOMRect = require("../../../generated/idl/DOMRect");
+
+class DOMRectImpl extends DOMRectReadOnlyImpl {
+  static fromRect(globalObject, other) {
+    return DOMRect.createImpl(globalObject, [other.x, other.y, other.width, other.height]);
+  }
+
+  get x() {
+    return super.x;
+  }
+  set x(newX) {
+    this._x = newX;
+  }
+
+  get y() {
+    return super.y;
+  }
+  set y(newY) {
+    this._y = newY;
+  }
+
+  get width() {
+    return super.width;
+  }
+  set width(newWidth) {
+    this._width = newWidth;
+  }
+
+  get height() {
+    return super.height;
+  }
+  set height(newHeight) {
+    this._height = newHeight;
+  }
+}
+
+exports.implementation = DOMRectImpl;

package/lib/jsdom/living/geometry/DOMRectReadOnly-impl.js

@@ -0,0 +1,72 @@
+"use strict";
+const DOMRectReadOnly = require("../../../generated/idl/DOMRectReadOnly");
+
+class DOMRectReadOnlyImpl {
+  constructor(globalObject, [x = 0, y = 0, width = 0, height = 0]) {
+    this._globalObject = globalObject;
+    this._x = x;
+    this._y = y;
+    this._width = width;
+    this._height = height;
+  }
+
+  static fromRect(globalObject, other) {
+    return DOMRectReadOnly.createImpl(globalObject, [other.x, other.y, other.width, other.height]);
+  }
+
+  get x() {
+    return this._x;
+  }
+
+  get y() {
+    return this._y;
+  }
+
+  get width() {
+    return this._width;
+  }
+
+  get height() {
+    return this._height;
+  }
+
+  get top() {
+    const { height, y } = this;
+    // We use Math.min's built-in NaN handling: https://github.com/w3c/fxtf-drafts/issues/222
+    return Math.min(y, y + height);
+  }
+
+  get right() {
+    const { width, x } = this;
+    // We use Math.max's built-in NaN handling: https://github.com/w3c/fxtf-drafts/issues/222
+    return Math.max(x, x + width);
+  }
+
+  get bottom() {
+    const { height, y } = this;
+    // We use Math.max's built-in NaN handling: https://github.com/w3c/fxtf-drafts/issues/222
+    return Math.max(y, y + height);
+  }
+
+  get left() {
+    const { width, x } = this;
+    // We use Math.min's built-in NaN handling: https://github.com/w3c/fxtf-drafts/issues/222
+    return Math.min(x, x + width);
+  }
+
+  // Could be removed after https://github.com/jsdom/webidl2js/issues/185 gets fixed.
+  toJSON() {
+    return {
+      x: this.x,
+      y: this.y,
+      width: this.width,
+      height: this.height,
+      top: this.top,
+      right: this.right,
+      bottom: this.bottom,
+      left: this.left
+    };
+  }
+}
+
+exports.implementation = DOMRectReadOnlyImpl;

package/lib/jsdom/living/helpers/binary-data.js

@@ -0,0 +1,63 @@
+"use strict";
+
+/**
+ * Concatenate the given typed arrays into a single `Uint8Array`.
+ *
+ * @param {Array<TypedArray>} arrays - An array of typed arrays. They can be of any type (but not `DataView` or
+ * `ArrayBuffer`).
+ * @returns {Uint8Array} - A new `Uint8Array` containing a copy of the concatenated data.
+ * @see {@link https://github.com/tc39/proposal-typedarray-concat}
+ */
+exports.concatTypedArrays = arrays => {
+  const totalLength = arrays.reduce((sum, arr) => sum + arr.byteLength, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrays) {
+    const toSet = arr instanceof Uint8Array ? arr : new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+    result.set(toSet, offset);
+    offset += arr.byteLength;
+  }
+  return result;
+};
+
+/**
+ * Create a copy of the data in a given `ArrayBuffer`, in a new `ArrayBuffer` created in the target realm.
+ *
+ * Used when we have some internal data, usually in the Node.js realm, and we need to copy it to the target realm.
+ * Compared to {@link copyToArrayBufferInTargetRealmDestructively}, use this when we need to keep the original data
+ * around, such as when exposing the data from inside the `Blob` implementation to the user.
+ *
+ * @param {ArrayBuffer} arrayBuffer - The `ArrayBuffer` to copy the data from.
+ * @param {object} newRealm - The target realm's global object, which has `ArrayBuffer` and `Uint8Array` constructor
+ * properties.
+ * @returns {ArrayBuffer} - A new `ArrayBuffer` containing a copy of the data, using the `ArrayBuffer` constructor from
+ * `newRealm`.
+ */
+exports.copyToArrayBufferInTargetRealm = (arrayBuffer, newRealm) => {
+  const newAB = new newRealm.ArrayBuffer(arrayBuffer.byteLength);
+  const view = new newRealm.Uint8Array(newAB);
+  view.set(new newRealm.Uint8Array(arrayBuffer));
+  return newAB;
+};
+
+/**
+ * Create a copy of the data in a given `ArrayBuffer`, in a new `ArrayBuffer` created in the target realm. The original
+ * `ArrayBuffer` is transferred in the process, so its data is no longer usable.
+ *
+ * Used when we have some internal data, usually in the Node.js realm, and we need to copy it to the target realm.
+ * Compared to {@link copyToArrayBufferInTargetRealm}, use this when we don't need to keep the original data around,
+ * such as when copying data from the Node.js network or `WebSocket` stack to the jsdom user.
+ *
+ * @param {ArrayBuffer} arrayBuffer - The `ArrayBuffer` to extract the data from. After calling this function,
+ * `arrayBuffer` is no longer usable.
+ * @param {object} newRealm - The target realm's global object, which has an `ArrayBuffer` constructor property.
+ * @returns {ArrayBuffer} - A new `ArrayBuffer` containing the original data data, using the `ArrayBuffer` constructor
+ * from `newRealm`.
+ */
+exports.copyToArrayBufferInTargetRealmDestructively = (arrayBuffer, newRealm) => {
+  if (!newRealm.ArrayBuffer.prototype.transfer) {
+    return exports.copyToArrayBufferInTargetRealm(arrayBuffer, newRealm);
+  }
+
+  return newRealm.ArrayBuffer.prototype.transfer.call(arrayBuffer);
+};

package/lib/jsdom/living/helpers/by-id-cache.js

@@ -0,0 +1,67 @@
+"use strict";
+
+const NODE_TYPE = require("../node-type");
+const { domSymbolTree } = require("./internal-constants");
+
+// For use in implementing getElementById(). Notably it ensures that when you get the result, you will always get the
+// first in tree order, not the most- or least-recently-inserted. Somewhat modeled after
+// https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/dom/tree_ordered_map.h.
+
+module.exports = class ByIdCache {
+  constructor(root) {
+    this._root = root;
+
+    // Keys are IDs (strings).
+    // Values are `{ element, count }` tuples, where `element` can be `null` indicating we need to recompute.
+    // `count` tracks the count of times `add()` was called for this ID. We need to track it because it lets us
+    // determine what to do when calling `delete()`: a count of 0 means we can remove the entry, whereas any other
+    // count means we need to set `element` to `null` for future recomputation.
+    this._map = new Map();
+  }
+
+  add(id, element) {
+    const value = this._map.get(id);
+    if (!value) {
+      this._map.set(id, { element, count: 1 });
+    } else {
+      value.element = null;
+      ++value.count;
+    }
+  }
+
+  delete(id, element) {
+    const value = this._map.get(id);
+    if (!value) {
+      return;
+    }
+
+    --value.count;
+    if (value.count === 0) {
+      this._map.delete(id);
+    } else if (value.element === element) {
+      value.element = null;
+    }
+  }
+
+  get(id) {
+    const value = this._map.get(id);
+    if (!value) {
+      return null;
+    }
+
+    if (value.element) {
+      return value.element;
+    }
+
+    for (const descendant of domSymbolTree.treeIterator(this._root)) {
+      if (descendant.nodeType === NODE_TYPE.ELEMENT_NODE && descendant.getAttributeNS(null, "id") === id) {
+        value.element = descendant;
+        return descendant;
+      }
+    }
+
+    // If we didn't find any elements for this key, we can remove it.
+    this._map.delete(id);
+    return null;
+  }
+};