@depup/jsdom 28.1.0-depup.1

package/lib/jsdom/browser/default-stylesheet.css

@@ -0,0 +1,415 @@
+/* Omitting the below because of https://github.com/jsdom/cssstyle/issues/193.
+   And we don't implement namespace constraints anyway.
+
+@namespace "http://www.w3.org/1999/xhtml";
+*/
+
+/* https://html.spec.whatwg.org/multipage/rendering.html#the-page */
+
+html, body { display: block; }
+
+/* https://html.spec.whatwg.org/multipage/rendering.html#flow-content-3
+  - Omits presentational hints
+  - Omits quirks mode
+*/
+
+address, blockquote, center, dialog, div, figure, figcaption, footer, form,
+header, hr, legend, listing, main, p, plaintext, pre, search, xmp {
+  display: block;
+}
+
+blockquote, figure, listing, p, plaintext, pre, xmp {
+  margin-block: 1em;
+}
+
+blockquote, figure { margin-inline: 40px; }
+
+address { font-style: italic; }
+listing, plaintext, pre, xmp {
+  font-family: monospace; white-space: pre;
+}
+
+dialog:not([open]) { display: none; }
+dialog {
+  position: absolute;
+  inset-inline-start: 0; inset-inline-end: 0;
+  width: fit-content;
+  height: fit-content;
+  margin: auto;
+  border: solid;
+  padding: 1em;
+  background-color: Canvas;
+  color: CanvasText;
+}
+dialog:modal {
+  position: fixed;
+  overflow: auto;
+  inset-block: 0;
+  max-width: calc(100% - 6px - 2em);
+  max-height: calc(100% - 6px - 2em);
+}
+dialog::backdrop {
+  background: rgba(0,0,0,0.1);
+}
+
+[popover]:not(:popover-open):not(dialog[open]) {
+  display:none;
+}
+
+dialog:popover-open {
+  display:block;
+}
+
+[popover] {
+  position: fixed;
+  inset: 0;
+  width: fit-content;
+  height: fit-content;
+  margin: auto;
+  border: solid;
+  padding: 0.25em;
+  overflow: auto;
+  color: CanvasText;
+  background-color: Canvas;
+}
+
+:popover-open::backdrop {
+  position: fixed;
+  inset: 0;
+  pointer-events: none !important;
+  background-color: transparent;
+}
+
+slot {
+  display: contents;
+}
+
+/* https://html.spec.whatwg.org/multipage/rendering.html#phrasing-content-3
+  - Omits presentational hints
+*/
+
+
+cite, dfn, em, i, var { font-style: italic; }
+b, strong { font-weight: bolder; }
+code, kbd, samp, tt { font-family: monospace; }
+big { font-size: larger; }
+small { font-size: smaller; }
+
+sub { vertical-align: sub; }
+sup { vertical-align: super; }
+sub, sup { line-height: normal; font-size: smaller; }
+
+ruby { display: ruby; }
+rt { display: ruby-text; }
+
+:link { color: #0000EE; }
+:visited { color: #551A8B; }
+:link:active, :visited:active { color: #FF0000; }
+:link, :visited { text-decoration: underline; cursor: pointer; }
+
+:focus-visible { outline: auto; }
+
+mark { background: yellow; color: black; } /* this color is just a suggestion and can be changed based on implementation feedback */
+
+abbr[title], acronym[title] { text-decoration: dotted underline; }
+ins, u { text-decoration: underline; }
+del, s, strike { text-decoration: line-through; }
+
+q::before { content: open-quote; }
+q::after { content: close-quote; }
+
+br { display-outside: newline; } /* this also has bidi implications */
+nobr { white-space: nowrap; }
+wbr { display-outside: break-opportunity; } /* this also has bidi implications */
+nobr wbr { white-space: normal; }
+
+/* https://html.spec.whatwg.org/multipage/rendering.html#bidi-rendering
+  - Omits ISO-8859-8
+*/
+
+[dir]:dir(ltr), bdi:dir(ltr), input[type=tel i]:dir(ltr) { direction: ltr; }
+[dir]:dir(rtl), bdi:dir(rtl) { direction: rtl; }
+
+address, blockquote, center, div, figure, figcaption, footer, form, header, hr,
+legend, listing, main, p, plaintext, pre, summary, xmp, article, aside, h1, h2,
+h3, h4, h5, h6, hgroup, nav, section, search, table, caption, colgroup, col,
+thead, tbody, tfoot, tr, td, th, dir, dd, dl, dt, menu, ol, ul, li, bdi, output,
+[dir=ltr i], [dir=rtl i], [dir=auto i] {
+  unicode-bidi: isolate;
+}
+
+bdo, bdo[dir] { unicode-bidi: isolate-override; }
+
+input[dir=auto i]:is([type=search i], [type=tel i], [type=url i],
+[type=email i]), textarea[dir=auto i], pre[dir=auto i] {
+  unicode-bidi: plaintext;
+}
+/* see prose for input elements whose type attribute is in the Text state */
+
+/* the rules setting the 'content' property on br and wbr elements also has bidi implications */
+
+/* https://html.spec.whatwg.org/multipage/rendering.html#sections-and-headings
+  - Special h1 styles removed per upcoming change: https://github.com/whatwg/html/pull/11102
+*/
+
+article, aside, h1, h2, h3, h4, h5, h6, hgroup, nav, section {
+  display: block;
+}
+
+h1 { margin-block: 0.67em; font-size: 2.00em; font-weight: bold; }
+h2 { margin-block: 0.83em; font-size: 1.50em; font-weight: bold; }
+h3 { margin-block: 1.00em; font-size: 1.17em; font-weight: bold; }
+h4 { margin-block: 1.33em; font-size: 1.00em; font-weight: bold; }
+h5 { margin-block: 1.67em; font-size: 0.83em; font-weight: bold; }
+h6 { margin-block: 2.33em; font-size: 0.67em; font-weight: bold; }
+
+/* https://html.spec.whatwg.org/multipage/rendering.html#lists
+  - Omit presentational hints
+  - Omit quirks mode
+*/
+
+dir, dd, dl, dt, menu, ol, ul { display: block; }
+li { display: list-item; text-align: match-parent; }
+
+dir, dl, menu, ol, ul { margin-block: 1em; }
+
+:is(dir, dl, menu, ol, ul) :is(dir, dl, menu, ol, ul) {
+  margin-block: 0;
+}
+
+dd { margin-inline-start: 40px; }
+dir, menu, ol, ul { padding-inline-start: 40px; }
+
+ol, ul, menu { counter-reset: list-item; }
+ol { list-style-type: decimal; }
+
+dir, menu, ul {
+  list-style-type: disc;
+}
+:is(dir, menu, ol, ul) :is(dir, menu, ul) {
+  list-style-type: circle;
+}
+:is(dir, menu, ol, ul) :is(dir, menu, ol, ul) :is(dir, menu, ul) {
+  list-style-type: square;
+}
+
+/* https://html.spec.whatwg.org/multipage/rendering.html#tables-2
+  - Omit presentational hints
+  - Omit quirks mode
+  - Omit HTML documents
+*/
+
+table { display: table; }
+caption { display: table-caption; }
+colgroup, colgroup[hidden] { display: table-column-group; }
+col, col[hidden] { display: table-column; }
+thead, thead[hidden] { display: table-header-group; }
+tbody, tbody[hidden] { display: table-row-group; }
+tfoot, tfoot[hidden] { display: table-footer-group; }
+tr, tr[hidden] { display: table-row; }
+td, th { display: table-cell; }
+
+colgroup[hidden], col[hidden], thead[hidden], tbody[hidden],
+tfoot[hidden], tr[hidden] {
+  visibility: collapse;
+}
+
+table {
+  box-sizing: border-box;
+  border-spacing: 2px;
+  border-collapse: separate;
+  text-indent: initial;
+}
+td, th { padding: 1px; }
+th { font-weight: bold; }
+
+caption { text-align: center; }
+thead, tbody, tfoot, table > tr { vertical-align: middle; }
+tr, td, th { vertical-align: inherit; }
+
+thead, tbody, tfoot, tr { border-color: inherit; }
+table[rules=none i], table[rules=groups i], table[rules=rows i],
+table[rules=cols i], table[rules=all i], table[frame=void i],
+table[frame=above i], table[frame=below i], table[frame=hsides i],
+table[frame=lhs i], table[frame=rhs i], table[frame=vsides i],
+table[frame=box i], table[frame=border i],
+table[rules=none i] > tr > td, table[rules=none i] > tr > th,
+table[rules=groups i] > tr > td, table[rules=groups i] > tr > th,
+table[rules=rows i] > tr > td, table[rules=rows i] > tr > th,
+table[rules=cols i] > tr > td, table[rules=cols i] > tr > th,
+table[rules=all i] > tr > td, table[rules=all i] > tr > th,
+table[rules=none i] > thead > tr > td, table[rules=none i] > thead > tr > th,
+table[rules=groups i] > thead > tr > td, table[rules=groups i] > thead > tr > th,
+table[rules=rows i] > thead > tr > td, table[rules=rows i] > thead > tr > th,
+table[rules=cols i] > thead > tr > td, table[rules=cols i] > thead > tr > th,
+table[rules=all i] > thead > tr > td, table[rules=all i] > thead > tr > th,
+table[rules=none i] > tbody > tr > td, table[rules=none i] > tbody > tr > th,
+table[rules=groups i] > tbody > tr > td, table[rules=groups i] > tbody > tr > th,
+table[rules=rows i] > tbody > tr > td, table[rules=rows i] > tbody > tr > th,
+table[rules=cols i] > tbody > tr > td, table[rules=cols i] > tbody > tr > th,
+table[rules=all i] > tbody > tr > td, table[rules=all i] > tbody > tr > th,
+table[rules=none i] > tfoot > tr > td, table[rules=none i] > tfoot > tr > th,
+table[rules=groups i] > tfoot > tr > td, table[rules=groups i] > tfoot > tr > th,
+table[rules=rows i] > tfoot > tr > td, table[rules=rows i] > tfoot > tr > th,
+table[rules=cols i] > tfoot > tr > td, table[rules=cols i] > tfoot > tr > th,
+table[rules=all i] > tfoot > tr > td, table[rules=all i] > tfoot > tr > th {
+  border-color: black;
+}
+
+/* https://html.spec.whatwg.org/multipage/rendering.html#form-controls
+  - Omit quirks mode
+*/
+
+input, select, button, textarea {
+  letter-spacing: initial;
+  word-spacing: initial;
+  line-height: initial;
+  text-transform: initial;
+  text-indent: initial;
+  text-shadow: initial;
+  appearance: auto;
+}
+
+input:not([type=image i], [type=range i], [type=checkbox i], [type=radio i]) {
+  overflow: clip !important;
+  overflow-clip-margin: 0 !important;
+}
+
+input, select, textarea {
+  text-align: initial;
+}
+
+:autofill {
+  field-sizing: fixed !important;
+}
+
+input:is([type=reset i], [type=button i], [type=submit i]), button {
+  text-align: center;
+}
+
+input, button {
+  display: inline-block;
+}
+
+input[type=hidden i], input[type=file i], input[type=image i] {
+  appearance: none;
+}
+
+input:is([type=radio i], [type=checkbox i], [type=reset i], [type=button i],
+[type=submit i], [type=color i], [type=search i]), select, button {
+  box-sizing: border-box;
+}
+
+textarea { white-space: pre-wrap; }
+
+/* https://html.spec.whatwg.org/multipage/rendering.html#the-hr-element-2
+  - Omit presentational hints
+*/
+
+hr {
+  color: gray;
+  border-style: inset;
+  border-width: 1px;
+  margin-block: 0.5em;
+  margin-inline: auto;
+  overflow: hidden;
+}
+
+/* https://html.spec.whatwg.org/multipage/rendering.html#the-fieldset-and-legend-elements */
+
+fieldset {
+  display: block;
+  margin-inline: 2px;
+  border: groove 2px ThreeDFace;
+  padding-block: 0.35em 0.625em;
+  padding-inline: 0.75em;
+  min-inline-size: min-content;
+}
+
+legend {
+  padding-inline: 2px;
+}
+
+legend[align=left i] {
+  justify-self: left;
+}
+
+legend[align=center i] {
+  justify-self: center;
+}
+
+legend[align=right i] {
+  justify-self: right;
+}
+
+/* https://html.spec.whatwg.org/multipage/rendering.html#embedded-content-rendering-rules */
+
+iframe { border: 2px inset; }
+video { object-fit: contain; }
+
+/* https://html.spec.whatwg.org/multipage/rendering.html#images-3
+- Omit quirks mode
+*/
+
+img:is([sizes="auto" i], [sizes^="auto," i]) {
+  contain: size !important;
+  contain-intrinsic-size: 300px 150px;
+}
+
+/* https://html.spec.whatwg.org/multipage/rendering.html#the-details-and-summary-elements
+- Omit internal shadow tree styles
+*/
+
+details, summary {
+  display: block;
+}
+details > summary:first-of-type {
+  display: list-item;
+  counter-increment: list-item 0;
+  list-style: disclosure-closed inside;
+}
+details[open] > summary:first-of-type {
+  list-style-type: disclosure-open;
+}
+
+/* https://html.spec.whatwg.org/multipage/rendering.html#the-marquee-element-2 */
+
+marquee {
+  display: inline-block;
+  text-align: initial;
+  overflow: hidden !important;
+}
+
+/* https://html.spec.whatwg.org/multipage/rendering.html#the-meter-element-2 */
+
+meter { appearance: auto; }
+
+/* https://html.spec.whatwg.org/multipage/rendering.html#the-progress-element-2 */
+
+progress { appearance: auto; }
+
+/* https://html.spec.whatwg.org/multipage/rendering.html#hidden-elements
+- Moved to the bottom because our lack of specificity support causes tag name `display: block` and the below [hidden]
+  `display: none` to be last-one-wins.
+*/
+
+area, base, basefont, datalist, head, link, meta, noembed,
+noframes, param, rp, script, style, template, title {
+  display: none;
+}
+
+[hidden]:not([hidden=until-found i]):not(embed) {
+  display: none;
+}
+
+[hidden=until-found i]:not(embed) {
+  content-visibility: hidden;
+}
+
+embed[hidden] { display: inline; height: 0; width: 0; }
+
+input[type=hidden i] { display: none !important; }
+
+@media (scripting) {
+  noscript { display: none !important; }
+}

package/lib/jsdom/browser/not-implemented.js

@@ -0,0 +1,20 @@
+"use strict";
+
+exports.notImplementedMethod = (window, className, methodName, specialCircumstances) => {
+  exports.notImplemented(
+    window,
+    `${className}'s ${methodName}() method${specialCircumstances ? `: ${specialCircumstances}` : ""}`
+  );
+};
+
+exports.notImplemented = (window, message) => {
+  if (!window) {
+    // Do nothing for window-less documents.
+    return;
+  }
+
+  const error = new Error(`Not implemented: ${message}`);
+  error.type = "not-implemented";
+
+  window._virtualConsole.emit("jsdomError", error);
+};

package/lib/jsdom/browser/parser/html.js

@@ -0,0 +1,208 @@
+"use strict";
+
+const parse5 = require("parse5");
+
+const { createElement } = require("../../living/helpers/create-element");
+const { HTML_NS } = require("../../living/helpers/namespaces");
+
+const DocumentType = require("../../../generated/idl/DocumentType");
+const DocumentFragment = require("../../../generated/idl/DocumentFragment");
+const Text = require("../../../generated/idl/Text");
+const Comment = require("../../../generated/idl/Comment");
+
+const attributes = require("../../living/attributes");
+const nodeTypes = require("../../living/node-type");
+
+const serializationAdapter = require("../../living/domparsing/parse5-adapter-serialization");
+const {
+  customElementReactionsStack, invokeCEReactions, lookupCEDefinition
+} = require("../../living/helpers/custom-elements");
+
+
+class JSDOMParse5Adapter {
+  constructor(documentImpl, options = {}) {
+    this._documentImpl = documentImpl;
+    this._globalObject = documentImpl._globalObject;
+    this._fragment = options.fragment || false;
+
+    // Since the createElement hook doesn't provide the parent element, we keep track of this using _currentElement:
+    // https://github.com/inikulin/parse5/issues/285.
+    this._currentElement = undefined;
+  }
+
+  _ownerDocument() {
+    const { _currentElement } = this;
+
+    // The _currentElement is undefined when parsing elements at the root of the document.
+    if (_currentElement) {
+      return _currentElement.localName === "template" && _currentElement.namespaceURI === HTML_NS ?
+        _currentElement.content._ownerDocument :
+        _currentElement._ownerDocument;
+    }
+
+    return this._documentImpl;
+  }
+
+  createDocument() {
+    // parse5's model assumes that parse(html) will call into here to create the new Document, then return it. However,
+    // jsdom's model assumes we can create a Window (and through that create an empty Document), do some other setup
+    // stuff, and then parse, stuffing nodes into that Document as we go. So to adapt between these two models, we just
+    // return the already-created Document when asked by parse5 to "create" a Document.
+    return this._documentImpl;
+  }
+
+  createDocumentFragment() {
+    const ownerDocument = this._ownerDocument();
+    return DocumentFragment.createImpl(this._globalObject, [], { ownerDocument });
+  }
+
+  // https://html.spec.whatwg.org/#create-an-element-for-the-token
+  createElement(localName, namespace, attrs) {
+    const ownerDocument = this._ownerDocument();
+
+    const isAttribute = attrs.find(attr => attr.name === "is");
+    const isValue = isAttribute ? isAttribute.value : null;
+
+    const definition = lookupCEDefinition(ownerDocument, namespace, localName);
+
+    let willExecuteScript = false;
+    if (definition !== null && !this._fragment) {
+      willExecuteScript = true;
+    }
+
+    if (willExecuteScript) {
+      ownerDocument._throwOnDynamicMarkupInsertionCounter++;
+      customElementReactionsStack.push([]);
+    }
+
+    const element = createElement(ownerDocument, localName, namespace, null, isValue, willExecuteScript);
+    this.adoptAttributes(element, attrs);
+
+    if (willExecuteScript) {
+      const queue = customElementReactionsStack.pop();
+      invokeCEReactions(queue);
+      ownerDocument._throwOnDynamicMarkupInsertionCounter--;
+    }
+
+    if ("_parserInserted" in element) {
+      element._parserInserted = true;
+    }
+
+    return element;
+  }
+
+  createCommentNode(data) {
+    const ownerDocument = this._ownerDocument();
+    return Comment.createImpl(this._globalObject, [], { data, ownerDocument });
+  }
+
+  appendChild(parentNode, newNode) {
+    parentNode._append(newNode);
+  }
+
+  insertBefore(parentNode, newNode, referenceNode) {
+    parentNode._insert(newNode, referenceNode);
+  }
+
+  setTemplateContent(templateElement, contentFragment) {
+    // This code makes the glue between jsdom and parse5 HTMLTemplateElement parsing:
+    //
+    // * jsdom during the construction of the HTMLTemplateElement (for example when create via
+    //   `document.createElement("template")`), creates a DocumentFragment and set it into _templateContents.
+    // * parse5 when parsing a <template> tag creates an HTMLTemplateElement (`createElement` adapter hook) and also
+    //   create a DocumentFragment (`createDocumentFragment` adapter hook).
+    //
+    // At this point we now have to replace the one created in jsdom with one created by parse5.
+    const { _ownerDocument, _host } = templateElement._templateContents;
+    contentFragment._ownerDocument = _ownerDocument;
+    contentFragment._host = _host;
+
+    templateElement._templateContents = contentFragment;
+  }
+
+  setDocumentType(document, name, publicId, systemId) {
+    const ownerDocument = this._ownerDocument();
+    const documentType = DocumentType.createImpl(this._globalObject, [], { name, publicId, systemId, ownerDocument });
+
+    document._append(documentType);
+  }
+
+  setDocumentMode(document, mode) {
+    // TODO: the rest of jsdom ignores this
+    document._mode = mode;
+  }
+
+  detachNode(node) {
+    node.remove();
+  }
+
+  insertText(parentNode, text) {
+    const { lastChild } = parentNode;
+    if (lastChild && lastChild.nodeType === nodeTypes.TEXT_NODE) {
+      lastChild.data += text;
+    } else {
+      const ownerDocument = this._ownerDocument();
+      const textNode = Text.createImpl(this._globalObject, [], { data: text, ownerDocument });
+      parentNode._append(textNode);
+    }
+  }
+
+  insertTextBefore(parentNode, text, referenceNode) {
+    const { previousSibling } = referenceNode;
+    if (previousSibling && previousSibling.nodeType === nodeTypes.TEXT_NODE) {
+      previousSibling.data += text;
+    } else {
+      const ownerDocument = this._ownerDocument();
+      const textNode = Text.createImpl(this._globalObject, [], { data: text, ownerDocument });
+      parentNode._append(textNode, referenceNode);
+    }
+  }
+
+  adoptAttributes(element, attrs) {
+    for (const attr of attrs) {
+      const prefix = attr.prefix === "" ? null : attr.prefix;
+      attributes.setAttributeValue(element, attr.name, attr.value, prefix, attr.namespace);
+    }
+  }
+
+  onItemPush(after) {
+    this._currentElement = after;
+    after._pushedOnStackOfOpenElements?.();
+  }
+
+  onItemPop(before, newTop) {
+    this._currentElement = newTop;
+    before._poppedOffStackOfOpenElements?.();
+  }
+}
+
+// Assign shared adapters with serializer.
+Object.assign(JSDOMParse5Adapter.prototype, serializationAdapter);
+
+function parseFragment(markup, contextElement) {
+  const ownerDocument = contextElement.localName === "template" && contextElement.namespaceURI === HTML_NS ?
+    contextElement.content._ownerDocument :
+    contextElement._ownerDocument;
+
+  const config = {
+    ...ownerDocument._parseOptions,
+    sourceCodeLocationInfo: false,
+    treeAdapter: new JSDOMParse5Adapter(ownerDocument, { fragment: true })
+  };
+
+  return parse5.parseFragment(contextElement, markup, config);
+}
+
+function parseIntoDocument(markup, ownerDocument) {
+  const config = {
+    ...ownerDocument._parseOptions,
+    treeAdapter: new JSDOMParse5Adapter(ownerDocument)
+  };
+
+  return parse5.parse(markup, config);
+}
+
+module.exports = {
+  parseFragment,
+  parseIntoDocument
+};

package/lib/jsdom/browser/parser/index.js

@@ -0,0 +1,37 @@
+"use strict";
+
+const xmlParser = require("./xml");
+const htmlParser = require("./html");
+
+// https://w3c.github.io/DOM-Parsing/#dfn-fragment-parsing-algorithm
+function parseFragment(markup, contextElement) {
+  const { _parsingMode } = contextElement._ownerDocument;
+
+  let parseAlgorithm;
+  if (_parsingMode === "html") {
+    parseAlgorithm = htmlParser.parseFragment;
+  } else if (_parsingMode === "xml") {
+    parseAlgorithm = xmlParser.parseFragment;
+  }
+
+  // Note: HTML and XML fragment parsing algorithm already return a document fragments; no need to do steps 3 and 4
+  return parseAlgorithm(markup, contextElement);
+}
+
+function parseIntoDocument(markup, ownerDocument) {
+  const { _parsingMode } = ownerDocument;
+
+  let parseAlgorithm;
+  if (_parsingMode === "html") {
+    parseAlgorithm = htmlParser.parseIntoDocument;
+  } else if (_parsingMode === "xml") {
+    parseAlgorithm = xmlParser.parseIntoDocument;
+  }
+
+  return parseAlgorithm(markup, ownerDocument);
+}
+
+module.exports = {
+  parseFragment,
+  parseIntoDocument
+};