recoder-code 2.4.1 → 2.4.2

package/packages/cli/node_modules/jsdom/lib/jsdom/living/helpers/runtime-script-errors.js

@@ -1,76 +0,0 @@
-"use strict";
-const util = require("util");
-const idlUtils = require("../generated/utils");
-const ErrorEvent = require("../generated/ErrorEvent");
-const { createAnEvent } = require("../helpers/events");
-
-const errorReportingMode = Symbol("error reporting mode");
-
-// https://html.spec.whatwg.org/multipage/webappapis.html#report-the-error
-// Omits script parameter and any check for muted errors.
-// Takes target as an EventTarget impl.
-// Takes error object, message, and location as params, unlike the spec.
-// Returns whether the event was handled or not.
-function reportAnError(line, col, target, errorObject, message, location) {
-  if (target[errorReportingMode]) {
-    return false;
-  }
-
-  target[errorReportingMode] = true;
-
-  if (typeof message !== "string") {
-    message = "uncaught exception: " + util.inspect(errorObject);
-  }
-
-  const event = createAnEvent("error", target._globalObject, ErrorEvent, {
-    cancelable: true,
-    message,
-    filename: location,
-    lineno: line,
-    colno: col,
-    error: errorObject
-  });
-
-  try {
-    target._dispatch(event);
-  } finally {
-    target[errorReportingMode] = false;
-    return event.defaultPrevented;
-  }
-}
-
-module.exports = function reportException(window, error, filenameHint) {
-  // This function will give good results on real Error objects with stacks; poor ones otherwise
-
-  const stack = error && error.stack;
-  const lines = stack && stack.split("\n");
-
-  // Find the first line that matches; important for multi-line messages
-  let pieces;
-  if (lines) {
-    for (let i = 1; i < lines.length && !pieces; ++i) {
-      pieces = lines[i].match(/at (?:(.+)\s+)?\(?(?:(.+?):(\d+):(\d+)|([^)]+))\)?/);
-    }
-  }
-
-  const fileName = (pieces && pieces[2]) || filenameHint || window._document.URL;
-  const lineNumber = (pieces && parseInt(pieces[3])) || 0;
-  const columnNumber = (pieces && parseInt(pieces[4])) || 0;
-
-  const windowImpl = idlUtils.implForWrapper(window);
-
-  const handled = reportAnError(lineNumber, columnNumber, windowImpl, error, error && error.message, fileName);
-
-  if (!handled) {
-    const errorString = shouldBeDisplayedAsError(error) ? `[${error.name}: ${error.message}]` : util.inspect(error);
-    const jsdomError = new Error(`Uncaught ${errorString}`);
-    jsdomError.detail = error;
-    jsdomError.type = "unhandled exception";
-
-    window._virtualConsole.emit("jsdomError", jsdomError);
-  }
-};
-
-function shouldBeDisplayedAsError(x) {
-  return x && x.name && x.message !== undefined && x.stack;
-}

package/packages/cli/node_modules/jsdom/lib/jsdom/living/helpers/selectors.js

@@ -1,47 +0,0 @@
-"use strict";
-
-const nwsapi = require("nwsapi");
-
-const idlUtils = require("../generated/utils");
-
-function initNwsapi(node) {
-  const { _globalObject, _ownerDocument } = node;
-
-  return nwsapi({
-    document: idlUtils.wrapperForImpl(_ownerDocument),
-    DOMException: _globalObject.DOMException
-  });
-}
-
-exports.matchesDontThrow = (elImpl, selector) => {
-  const document = elImpl._ownerDocument;
-
-  if (!document._nwsapiDontThrow) {
-    document._nwsapiDontThrow = initNwsapi(elImpl);
-    document._nwsapiDontThrow.configure({
-      LOGERRORS: false,
-      VERBOSITY: false,
-      IDS_DUPES: true,
-      MIXEDCASE: true
-    });
-  }
-
-  return document._nwsapiDontThrow.match(selector, idlUtils.wrapperForImpl(elImpl));
-};
-
-// nwsapi gets `document.documentElement` at creation-time, so we have to initialize lazily, since in the initial
-// stages of Document initialization, there is no documentElement present yet.
-exports.addNwsapi = parentNode => {
-  const document = parentNode._ownerDocument;
-
-  if (!document._nwsapi) {
-    document._nwsapi = initNwsapi(parentNode);
-    document._nwsapi.configure({
-      LOGERRORS: false,
-      IDS_DUPES: true,
-      MIXEDCASE: true
-    });
-  }
-
-  return document._nwsapi;
-};

package/packages/cli/node_modules/jsdom/lib/jsdom/living/helpers/shadow-dom.js

@@ -1,285 +0,0 @@
-"use strict";
-
-const NODE_TYPE = require("../node-type");
-
-const { nodeRoot } = require("./node");
-const { HTML_NS } = require("./namespaces");
-const { domSymbolTree } = require("./internal-constants");
-const { signalSlotList, queueMutationObserverMicrotask } = require("./mutation-observers");
-
-// Valid host element for ShadowRoot.
-// Defined in: https://dom.spec.whatwg.org/#dom-element-attachshadow
-const VALID_HOST_ELEMENT_NAME = new Set([
-  "article",
-  "aside",
-  "blockquote",
-  "body",
-  "div",
-  "footer",
-  "h1",
-  "h2",
-  "h3",
-  "h4",
-  "h5",
-  "h6",
-  "header",
-  "main",
-  "nav",
-  "p",
-  "section",
-  "span"
-]);
-
-function isValidHostElementName(name) {
-  return VALID_HOST_ELEMENT_NAME.has(name);
-}
-
-// Use an approximation by checking the presence of nodeType instead of instead of using the isImpl from
-// "../generated/Node" to avoid introduction of circular dependencies.
-function isNode(nodeImpl) {
-  return Boolean(nodeImpl && "nodeType" in nodeImpl);
-}
-
-// Use an approximation by checking the value of nodeType and presence of nodeType host instead of instead
-// of using the isImpl from "../generated/ShadowRoot" to avoid introduction of circular dependencies.
-function isShadowRoot(nodeImpl) {
-  return Boolean(nodeImpl && nodeImpl.nodeType === NODE_TYPE.DOCUMENT_FRAGMENT_NODE && "host" in nodeImpl);
-}
-
-// https://dom.spec.whatwg.org/#concept-slotable
-function isSlotable(nodeImpl) {
-  return nodeImpl && (nodeImpl.nodeType === NODE_TYPE.ELEMENT_NODE || nodeImpl.nodeType === NODE_TYPE.TEXT_NODE);
-}
-
-function isSlot(nodeImpl) {
-  return nodeImpl && nodeImpl.localName === "slot" && nodeImpl._namespaceURI === HTML_NS;
-}
-
-// https://dom.spec.whatwg.org/#concept-shadow-including-inclusive-ancestor
-function isShadowInclusiveAncestor(ancestor, node) {
-  while (isNode(node)) {
-    if (node === ancestor) {
-      return true;
-    }
-
-    if (isShadowRoot(node)) {
-      node = node.host;
-    } else {
-      node = domSymbolTree.parent(node);
-    }
-  }
-
-  return false;
-}
-
-// https://dom.spec.whatwg.org/#retarget
-function retarget(a, b) {
-  while (true) {
-    if (!isNode(a)) {
-      return a;
-    }
-
-    const aRoot = nodeRoot(a);
-    if (
-      !isShadowRoot(aRoot) ||
-      (isNode(b) && isShadowInclusiveAncestor(aRoot, b))
-    ) {
-      return a;
-    }
-
-    a = nodeRoot(a).host;
-  }
-}
-
-// https://dom.spec.whatwg.org/#get-the-parent
-function getEventTargetParent(eventTarget, event) {
-  // _getTheParent will be missing for Window, since it doesn't have an impl class and we don't want to pollute the
-  // user-visible global scope with a _getTheParent value. TODO: remove this entire function and use _getTheParent
-  // directly, once Window gets split into impl/wrapper.
-  return eventTarget._getTheParent ? eventTarget._getTheParent(event) : null;
-}
-
-// https://dom.spec.whatwg.org/#concept-shadow-including-root
-function shadowIncludingRoot(node) {
-  const root = nodeRoot(node);
-  return isShadowRoot(root) ? shadowIncludingRoot(root.host) : root;
-}
-
-// https://dom.spec.whatwg.org/#assign-a-slot
-function assignSlot(slotable) {
-  const slot = findSlot(slotable);
-
-  if (slot) {
-    assignSlotable(slot);
-  }
-}
-
-// https://dom.spec.whatwg.org/#assign-slotables
-function assignSlotable(slot) {
-  const slotables = findSlotable(slot);
-
-  let shouldFireSlotChange = false;
-
-  if (slotables.length !== slot._assignedNodes.length) {
-    shouldFireSlotChange = true;
-  } else {
-    for (let i = 0; i < slotables.length; i++) {
-      if (slotables[i] !== slot._assignedNodes[i]) {
-        shouldFireSlotChange = true;
-        break;
-      }
-    }
-  }
-
-  if (shouldFireSlotChange) {
-    signalSlotChange(slot);
-  }
-
-  slot._assignedNodes = slotables;
-
-  for (const slotable of slotables) {
-    slotable._assignedSlot = slot;
-  }
-}
-
-// https://dom.spec.whatwg.org/#assign-slotables-for-a-tree
-function assignSlotableForTree(root) {
-  for (const slot of domSymbolTree.treeIterator(root)) {
-    if (isSlot(slot)) {
-      assignSlotable(slot);
-    }
-  }
-}
-
-// https://dom.spec.whatwg.org/#find-slotables
-function findSlotable(slot) {
-  const result = [];
-
-  const root = nodeRoot(slot);
-  if (!isShadowRoot(root)) {
-    return result;
-  }
-
-  for (const slotable of domSymbolTree.treeIterator(root.host)) {
-    const foundSlot = findSlot(slotable);
-
-    if (foundSlot === slot) {
-      result.push(slotable);
-    }
-  }
-
-  return result;
-}
-
-// https://dom.spec.whatwg.org/#find-flattened-slotables
-function findFlattenedSlotables(slot) {
-  const result = [];
-
-  const root = nodeRoot(slot);
-  if (!isShadowRoot(root)) {
-    return result;
-  }
-
-  const slotables = findSlotable(slot);
-
-  if (slotables.length === 0) {
-    for (const child of domSymbolTree.childrenIterator(slot)) {
-      if (isSlotable(child)) {
-        slotables.push(child);
-      }
-    }
-  }
-
-  for (const node of slotables) {
-    if (isSlot(node) && isShadowRoot(nodeRoot(node))) {
-      const temporaryResult = findFlattenedSlotables(node);
-      result.push(...temporaryResult);
-    } else {
-      result.push(node);
-    }
-  }
-
-  return result;
-}
-
-// https://dom.spec.whatwg.org/#find-a-slot
-function findSlot(slotable, openFlag) {
-  const { parentNode: parent } = slotable;
-
-  if (!parent) {
-    return null;
-  }
-
-  const shadow = parent._shadowRoot;
-
-  if (!shadow || (openFlag && shadow.mode !== "open")) {
-    return null;
-  }
-
-  for (const child of domSymbolTree.treeIterator(shadow)) {
-    if (isSlot(child) && child.name === slotable._slotableName) {
-      return child;
-    }
-  }
-
-  return null;
-}
-
-// https://dom.spec.whatwg.org/#signal-a-slot-change
-function signalSlotChange(slot) {
-  if (!signalSlotList.some(entry => entry === slot)) {
-    signalSlotList.push(slot);
-  }
-
-  queueMutationObserverMicrotask();
-}
-
-// https://dom.spec.whatwg.org/#concept-shadow-including-descendant
-function* shadowIncludingInclusiveDescendantsIterator(node) {
-  yield node;
-
-  if (node._shadowRoot) {
-    yield* shadowIncludingInclusiveDescendantsIterator(node._shadowRoot);
-  }
-
-  for (const child of domSymbolTree.childrenIterator(node)) {
-    yield* shadowIncludingInclusiveDescendantsIterator(child);
-  }
-}
-
-// https://dom.spec.whatwg.org/#concept-shadow-including-descendant
-function* shadowIncludingDescendantsIterator(node) {
-  if (node._shadowRoot) {
-    yield* shadowIncludingInclusiveDescendantsIterator(node._shadowRoot);
-  }
-
-  for (const child of domSymbolTree.childrenIterator(node)) {
-    yield* shadowIncludingInclusiveDescendantsIterator(child);
-  }
-}
-
-module.exports = {
-  isValidHostElementName,
-
-  isNode,
-  isSlotable,
-  isSlot,
-  isShadowRoot,
-
-  isShadowInclusiveAncestor,
-  retarget,
-  getEventTargetParent,
-  shadowIncludingRoot,
-
-  assignSlot,
-  assignSlotable,
-  assignSlotableForTree,
-
-  findSlot,
-  findFlattenedSlotables,
-
-  signalSlotChange,
-
-  shadowIncludingInclusiveDescendantsIterator,
-  shadowIncludingDescendantsIterator
-};

package/packages/cli/node_modules/jsdom/lib/jsdom/living/helpers/strings.js

@@ -1,162 +0,0 @@
-"use strict";
-
-// https://infra.spec.whatwg.org/#ascii-whitespace
-const asciiWhitespaceRe = /^[\t\n\f\r ]$/;
-exports.asciiWhitespaceRe = asciiWhitespaceRe;
-
-// https://infra.spec.whatwg.org/#ascii-lowercase
-exports.asciiLowercase = s => {
-  const len = s.length;
-  const out = new Array(len);
-  for (let i = 0; i < len; i++) {
-    const code = s.charCodeAt(i);
-    // If the character is between 'A' (65) and 'Z' (90), convert using bitwise OR with 32
-    out[i] = code >= 65 && code <= 90 ? String.fromCharCode(code | 32) : s[i];
-  }
-  return out.join("");
-};
-
-// https://infra.spec.whatwg.org/#ascii-uppercase
-exports.asciiUppercase = s => {
-  const len = s.length;
-  const out = new Array(len);
-  for (let i = 0; i < len; i++) {
-    const code = s.charCodeAt(i);
-    // If the character is between 'a' (97) and 'z' (122), convert using bitwise AND with ~32
-    out[i] = code >= 97 && code <= 122 ? String.fromCharCode(code & ~32) : s[i];
-  }
-  return out.join("");
-};
-
-// https://infra.spec.whatwg.org/#strip-newlines
-exports.stripNewlines = s => {
-  return s.replace(/[\n\r]+/g, "");
-};
-
-// https://infra.spec.whatwg.org/#strip-leading-and-trailing-ascii-whitespace
-exports.stripLeadingAndTrailingASCIIWhitespace = s => {
-  return s.replace(/^[ \t\n\f\r]+/, "").replace(/[ \t\n\f\r]+$/, "");
-};
-
-// https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace
-exports.stripAndCollapseASCIIWhitespace = s => {
-  return s.replace(/[ \t\n\f\r]+/g, " ").replace(/^[ \t\n\f\r]+/, "").replace(/[ \t\n\f\r]+$/, "");
-};
-
-// https://html.spec.whatwg.org/multipage/infrastructure.html#valid-simple-colour
-exports.isValidSimpleColor = s => {
-  return /^#[a-fA-F\d]{6}$/.test(s);
-};
-
-// https://infra.spec.whatwg.org/#ascii-case-insensitive
-exports.asciiCaseInsensitiveMatch = (a, b) => {
-  if (a.length !== b.length) {
-    return false;
-  }
-
-  for (let i = 0; i < a.length; ++i) {
-    if ((a.charCodeAt(i) | 32) !== (b.charCodeAt(i) | 32)) {
-      return false;
-    }
-  }
-
-  return true;
-};
-
-// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#rules-for-parsing-integers
-// Error is represented as null.
-const parseInteger = exports.parseInteger = input => {
-  // The implementation here is slightly different from the spec's. We want to use parseInt(), but parseInt() trims
-  // Unicode whitespace in addition to just ASCII ones, so we make sure that the trimmed prefix contains only ASCII
-  // whitespace ourselves.
-  const numWhitespace = input.length - input.trimStart().length;
-  if (/[^\t\n\f\r ]/.test(input.slice(0, numWhitespace))) {
-    return null;
-  }
-  // We don't allow hexadecimal numbers here.
-  // eslint-disable-next-line radix
-  const value = parseInt(input, 10);
-  if (Number.isNaN(value)) {
-    return null;
-  }
-  // parseInt() returns -0 for "-0". Normalize that here.
-  return value === 0 ? 0 : value;
-};
-
-// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#rules-for-parsing-non-negative-integers
-// Error is represented as null.
-exports.parseNonNegativeInteger = input => {
-  const value = parseInteger(input);
-  if (value === null) {
-    return null;
-  }
-  if (value < 0) {
-    return null;
-  }
-  return value;
-};
-
-// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#valid-floating-point-number
-const floatingPointNumRe = /^-?(?:\d+|\d*\.\d+)(?:[eE][-+]?\d+)?$/;
-exports.isValidFloatingPointNumber = str => floatingPointNumRe.test(str);
-
-// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#rules-for-parsing-floating-point-number-values
-// Error is represented as null.
-exports.parseFloatingPointNumber = str => {
-  // The implementation here is slightly different from the spec's. We need to use parseFloat() in order to retain
-  // accuracy, but parseFloat() trims Unicode whitespace in addition to just ASCII ones, so we make sure that the
-  // trimmed prefix contains only ASCII whitespace ourselves.
-  const numWhitespace = str.length - str.trimStart().length;
-  if (/[^\t\n\f\r ]/.test(str.slice(0, numWhitespace))) {
-    return null;
-  }
-  const parsed = parseFloat(str);
-  return isFinite(parsed) ? parsed : null;
-};
-
-// https://infra.spec.whatwg.org/#split-on-ascii-whitespace
-exports.splitOnASCIIWhitespace = str => {
-  let position = 0;
-  const tokens = [];
-  while (position < str.length && asciiWhitespaceRe.test(str[position])) {
-    position++;
-  }
-  if (position === str.length) {
-    return tokens;
-  }
-  while (position < str.length) {
-    const start = position;
-    while (position < str.length && !asciiWhitespaceRe.test(str[position])) {
-      position++;
-    }
-    tokens.push(str.slice(start, position));
-    while (position < str.length && asciiWhitespaceRe.test(str[position])) {
-      position++;
-    }
-  }
-  return tokens;
-};
-
-// https://infra.spec.whatwg.org/#split-on-commas
-exports.splitOnCommas = str => {
-  let position = 0;
-  const tokens = [];
-  while (position < str.length) {
-    let start = position;
-    while (position < str.length && str[position] !== ",") {
-      position++;
-    }
-    let end = position;
-    while (start < str.length && asciiWhitespaceRe.test(str[start])) {
-      start++;
-    }
-    while (end > start && asciiWhitespaceRe.test(str[end - 1])) {
-      end--;
-    }
-    tokens.push(str.slice(start, end));
-    if (position < str.length) {
-      position++;
-    }
-  }
-  return tokens;
-};