@node-core/utils 7.2.0 → 7.2.2

package/node_modules/whatwg-mimetype/LICENSE.txt

@@ -1,7 +0,0 @@
-Copyright © Domenic Denicola <d@domenic.me>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/node_modules/whatwg-mimetype/README.md

@@ -1,101 +0,0 @@
-# Parse, serialize, and manipulate MIME types
-
-This package will parse [MIME types](https://mimesniff.spec.whatwg.org/#understanding-mime-types) into a structured format, which can then be manipulated and serialized:
-
-```js
-const MIMEType = require("whatwg-mimetype");
-
-const mimeType = new MIMEType(`Text/HTML;Charset="utf-8"`);
-
-console.assert(mimeType.toString() === "text/html;charset=utf-8");
-
-console.assert(mimeType.type === "text");
-console.assert(mimeType.subtype === "html");
-console.assert(mimeType.essence === "text/html");
-console.assert(mimeType.parameters.get("charset") === "utf-8");
-
-mimeType.parameters.set("charset", "windows-1252");
-console.assert(mimeType.parameters.get("charset") === "windows-1252");
-console.assert(mimeType.toString() === "text/html;charset=windows-1252");
-
-console.assert(mimeType.isHTML() === true);
-console.assert(mimeType.isXML() === false);
-```
-
-Parsing is a fairly complex process; see [the specification](https://mimesniff.spec.whatwg.org/#parsing-a-mime-type) for details (and similarly [for serialization](https://mimesniff.spec.whatwg.org/#serializing-a-mime-type)).
-
-This package's algorithms conform to those of the WHATWG [MIME Sniffing Standard](https://mimesniff.spec.whatwg.org/), and is aligned up to commit [8e9a7dd](https://github.com/whatwg/mimesniff/commit/8e9a7dd90717c595a4e4d982cd216e4411d33736).
-
-## `MIMEType` API
-
-This package's main module's default export is a class, `MIMEType`. Its constructor takes a string which it will attempt to parse into a MIME type; if parsing fails, an `Error` will be thrown.
-
-### The `parse()` static factory method
-
-As an alternative to the constructor, you can use `MIMEType.parse(string)`. The only difference is that `parse()` will return `null` on failed parsing, whereas the constructor will throw. It thus makes the most sense to use the constructor in cases where unparseable MIME types would be exceptional, and use `parse()` when dealing with input from some unconstrained source.
-
-### Properties
-
-- `type`: the MIME type's [type](https://mimesniff.spec.whatwg.org/#mime-type-type), e.g. `"text"`
-- `subtype`: the MIME type's [subtype](https://mimesniff.spec.whatwg.org/#mime-type-subtype), e.g. `"html"`
-- `essence`: the MIME type's [essence](https://mimesniff.spec.whatwg.org/#mime-type-essence), e.g. `"text/html"`
-- `parameters`: an instance of `MIMETypeParameters`, containing this MIME type's [parameters](https://mimesniff.spec.whatwg.org/#mime-type-parameters)
-
-`type` and `subtype` can be changed. They will be validated to be non-empty and only contain [HTTP token code points](https://mimesniff.spec.whatwg.org/#http-token-code-point).
-
-`essence` is only a getter, and cannot be changed.
-
-`parameters` is also a getter, but the contents of the `MIMETypeParameters` object are mutable, as described below.
-
-### Methods
-
-- `toString()` serializes the MIME type to a string
-- `isHTML()`: returns true if this instance represents [a HTML MIME type](https://mimesniff.spec.whatwg.org/#html-mime-type)
-- `isXML()`: returns true if this instance represents [an XML MIME type](https://mimesniff.spec.whatwg.org/#xml-mime-type)
-- `isJavaScript({ prohibitParameters })`: returns true if this instance represents [a JavaScript MIME type](https://html.spec.whatwg.org/multipage/scripting.html#javascript-mime-type). `prohibitParameters` can be set to true to disallow any parameters, i.e. to test if the MIME type's serialization is a [JavaScript MIME type essence match](https://mimesniff.spec.whatwg.org/#javascript-mime-type-essence-match).
-
-_Note: the `isHTML()`, `isXML()`, and `isJavaScript()` methods are speculative, and may be removed or changed in future major versions. See [whatwg/mimesniff#48](https://github.com/whatwg/mimesniff/issues/48) for brainstorming in this area. Currently we implement these mainly because they are useful in jsdom._
-
-## `MIMETypeParameters` API
-
-The `MIMETypeParameters` class, instances of which are returned by `mimeType.parameters`, has equivalent surface API to a [JavaScript `Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map).
-
-However, `MIMETypeParameters` methods will always interpret their arguments as appropriate for MIME types, so e.g. parameter names will be lowercased, and attempting to set invalid characters will throw.
-
-Some examples:
-
-```js
-const mimeType = new MIMEType(`x/x;a=b;c=D;E="F"`);
-
-// Logs:
-// a b
-// c D
-// e F
-for (const [name, value] of mimeType.parameters) {
-  console.log(name, value);
-}
-
-console.assert(mimeType.parameters.has("a"));
-console.assert(mimeType.parameters.has("A"));
-console.assert(mimeType.parameters.get("A") === "b");
-
-mimeType.parameters.set("Q", "X");
-console.assert(mimeType.parameters.get("q") === "X");
-console.assert(mimeType.toString() === "x/x;a=b;c=d;e=F;q=X");
-
-// Throws:
-mimeType.parameters.set("@", "x");
-```
-
-## Raw parsing/serialization APIs
-
-If you want primitives on which to build your own API, you can get direct access to the parsing and serialization algorithms as follows:
-
-```js
-const parse = require("whatwg-mimetype/parser");
-const serialize = require("whatwg-mimetype/serialize");
-```
-
-`parse(string)` returns an object containing the `type` and `subtype` strings, plus `parameters`, which is a `Map`. This is roughly our equivalent of the spec's [MIME type record](https://mimesniff.spec.whatwg.org/#mime-type). If parsing fails, it instead returns `null`.
-
-`serialize(record)` operates on the such an object, giving back a string according to the serialization algorithm.

package/node_modules/whatwg-mimetype/lib/mime-type-parameters.js

@@ -1,70 +0,0 @@
-"use strict";
-const {
-  asciiLowercase,
-  solelyContainsHTTPTokenCodePoints,
-  soleyContainsHTTPQuotedStringTokenCodePoints
-} = require("./utils.js");
-
-module.exports = class MIMETypeParameters {
-  constructor(map) {
-    this._map = map;
-  }
-
-  get size() {
-    return this._map.size;
-  }
-
-  get(name) {
-    name = asciiLowercase(String(name));
-    return this._map.get(name);
-  }
-
-  has(name) {
-    name = asciiLowercase(String(name));
-    return this._map.has(name);
-  }
-
-  set(name, value) {
-    name = asciiLowercase(String(name));
-    value = String(value);
-
-    if (!solelyContainsHTTPTokenCodePoints(name)) {
-      throw new Error(`Invalid MIME type parameter name "${name}": only HTTP token code points are valid.`);
-    }
-    if (!soleyContainsHTTPQuotedStringTokenCodePoints(value)) {
-      throw new Error(`Invalid MIME type parameter value "${value}": only HTTP quoted-string token code points are ` +
-                      `valid.`);
-    }
-
-    return this._map.set(name, value);
-  }
-
-  clear() {
-    this._map.clear();
-  }
-
-  delete(name) {
-    name = asciiLowercase(String(name));
-    return this._map.delete(name);
-  }
-
-  forEach(callbackFn, thisArg) {
-    this._map.forEach(callbackFn, thisArg);
-  }
-
-  keys() {
-    return this._map.keys();
-  }
-
-  values() {
-    return this._map.values();
-  }
-
-  entries() {
-    return this._map.entries();
-  }
-
-  [Symbol.iterator]() {
-    return this._map[Symbol.iterator]();
-  }
-};

package/node_modules/whatwg-mimetype/lib/mime-type.js

@@ -1,127 +0,0 @@
-"use strict";
-const MIMETypeParameters = require("./mime-type-parameters.js");
-const parse = require("./parser.js");
-const serialize = require("./serializer.js");
-const {
-  asciiLowercase,
-  solelyContainsHTTPTokenCodePoints
-} = require("./utils.js");
-
-module.exports = class MIMEType {
-  constructor(string) {
-    string = String(string);
-    const result = parse(string);
-    if (result === null) {
-      throw new Error(`Could not parse MIME type string "${string}"`);
-    }
-
-    this._type = result.type;
-    this._subtype = result.subtype;
-    this._parameters = new MIMETypeParameters(result.parameters);
-  }
-
-  static parse(string) {
-    try {
-      return new this(string);
-    } catch (e) {
-      return null;
-    }
-  }
-
-  get essence() {
-    return `${this.type}/${this.subtype}`;
-  }
-
-  get type() {
-    return this._type;
-  }
-
-  set type(value) {
-    value = asciiLowercase(String(value));
-
-    if (value.length === 0) {
-      throw new Error("Invalid type: must be a non-empty string");
-    }
-    if (!solelyContainsHTTPTokenCodePoints(value)) {
-      throw new Error(`Invalid type ${value}: must contain only HTTP token code points`);
-    }
-
-    this._type = value;
-  }
-
-  get subtype() {
-    return this._subtype;
-  }
-
-  set subtype(value) {
-    value = asciiLowercase(String(value));
-
-    if (value.length === 0) {
-      throw new Error("Invalid subtype: must be a non-empty string");
-    }
-    if (!solelyContainsHTTPTokenCodePoints(value)) {
-      throw new Error(`Invalid subtype ${value}: must contain only HTTP token code points`);
-    }
-
-    this._subtype = value;
-  }
-
-  get parameters() {
-    return this._parameters;
-  }
-
-  toString() {
-    // The serialize function works on both "MIME type records" (i.e. the results of parse) and on this class, since
-    // this class's interface is identical.
-    return serialize(this);
-  }
-
-  isJavaScript({ prohibitParameters = false } = {}) {
-    switch (this._type) {
-      case "text": {
-        switch (this._subtype) {
-          case "ecmascript":
-          case "javascript":
-          case "javascript1.0":
-          case "javascript1.1":
-          case "javascript1.2":
-          case "javascript1.3":
-          case "javascript1.4":
-          case "javascript1.5":
-          case "jscript":
-          case "livescript":
-          case "x-ecmascript":
-          case "x-javascript": {
-            return !prohibitParameters || this._parameters.size === 0;
-          }
-          default: {
-            return false;
-          }
-        }
-      }
-      case "application": {
-        switch (this._subtype) {
-          case "ecmascript":
-          case "javascript":
-          case "x-ecmascript":
-          case "x-javascript": {
-            return !prohibitParameters || this._parameters.size === 0;
-          }
-          default: {
-            return false;
-          }
-        }
-      }
-      default: {
-        return false;
-      }
-    }
-  }
-  isXML() {
-    return (this._subtype === "xml" && (this._type === "text" || this._type === "application")) ||
-           this._subtype.endsWith("+xml");
-  }
-  isHTML() {
-    return this._subtype === "html" && this._type === "text";
-  }
-};

package/node_modules/whatwg-mimetype/lib/parser.js

@@ -1,105 +0,0 @@
-"use strict";
-const {
-  removeLeadingAndTrailingHTTPWhitespace,
-  removeTrailingHTTPWhitespace,
-  isHTTPWhitespaceChar,
-  solelyContainsHTTPTokenCodePoints,
-  soleyContainsHTTPQuotedStringTokenCodePoints,
-  asciiLowercase,
-  collectAnHTTPQuotedString
-} = require("./utils.js");
-
-module.exports = input => {
-  input = removeLeadingAndTrailingHTTPWhitespace(input);
-
-  let position = 0;
-  let type = "";
-  while (position < input.length && input[position] !== "/") {
-    type += input[position];
-    ++position;
-  }
-
-  if (type.length === 0 || !solelyContainsHTTPTokenCodePoints(type)) {
-    return null;
-  }
-
-  if (position >= input.length) {
-    return null;
-  }
-
-  // Skips past "/"
-  ++position;
-
-  let subtype = "";
-  while (position < input.length && input[position] !== ";") {
-    subtype += input[position];
-    ++position;
-  }
-
-  subtype = removeTrailingHTTPWhitespace(subtype);
-
-  if (subtype.length === 0 || !solelyContainsHTTPTokenCodePoints(subtype)) {
-    return null;
-  }
-
-  const mimeType = {
-    type: asciiLowercase(type),
-    subtype: asciiLowercase(subtype),
-    parameters: new Map()
-  };
-
-  while (position < input.length) {
-    // Skip past ";"
-    ++position;
-
-    while (isHTTPWhitespaceChar(input[position])) {
-      ++position;
-    }
-
-    let parameterName = "";
-    while (position < input.length && input[position] !== ";" && input[position] !== "=") {
-      parameterName += input[position];
-      ++position;
-    }
-    parameterName = asciiLowercase(parameterName);
-
-    if (position < input.length) {
-      if (input[position] === ";") {
-        continue;
-      }
-
-      // Skip past "="
-      ++position;
-    }
-
-    let parameterValue = null;
-    if (input[position] === "\"") {
-      [parameterValue, position] = collectAnHTTPQuotedString(input, position);
-
-      while (position < input.length && input[position] !== ";") {
-        ++position;
-      }
-    } else {
-      parameterValue = "";
-      while (position < input.length && input[position] !== ";") {
-        parameterValue += input[position];
-        ++position;
-      }
-
-      parameterValue = removeTrailingHTTPWhitespace(parameterValue);
-
-      if (parameterValue === "") {
-        continue;
-      }
-    }
-
-    if (parameterName.length > 0 &&
-        solelyContainsHTTPTokenCodePoints(parameterName) &&
-        soleyContainsHTTPQuotedStringTokenCodePoints(parameterValue) &&
-        !mimeType.parameters.has(parameterName)) {
-      mimeType.parameters.set(parameterName, parameterValue);
-    }
-  }
-
-  return mimeType;
-};

package/node_modules/whatwg-mimetype/lib/serializer.js

@@ -1,25 +0,0 @@
-"use strict";
-const { solelyContainsHTTPTokenCodePoints } = require("./utils.js");
-
-module.exports = mimeType => {
-  let serialization = `${mimeType.type}/${mimeType.subtype}`;
-
-  if (mimeType.parameters.size === 0) {
-    return serialization;
-  }
-
-  for (let [name, value] of mimeType.parameters) {
-    serialization += ";";
-    serialization += name;
-    serialization += "=";
-
-    if (!solelyContainsHTTPTokenCodePoints(value) || value.length === 0) {
-      value = value.replace(/(["\\])/ug, "\\$1");
-      value = `"${value}"`;
-    }
-
-    serialization += value;
-  }
-
-  return serialization;
-};

package/node_modules/whatwg-mimetype/lib/utils.js

@@ -1,60 +0,0 @@
-"use strict";
-
-exports.removeLeadingAndTrailingHTTPWhitespace = string => {
-  return string.replace(/^[ \t\n\r]+/u, "").replace(/[ \t\n\r]+$/u, "");
-};
-
-exports.removeTrailingHTTPWhitespace = string => {
-  return string.replace(/[ \t\n\r]+$/u, "");
-};
-
-exports.isHTTPWhitespaceChar = char => {
-  return char === " " || char === "\t" || char === "\n" || char === "\r";
-};
-
-exports.solelyContainsHTTPTokenCodePoints = string => {
-  return /^[-!#$%&'*+.^_`|~A-Za-z0-9]*$/u.test(string);
-};
-
-exports.soleyContainsHTTPQuotedStringTokenCodePoints = string => {
-  return /^[\t\u0020-\u007E\u0080-\u00FF]*$/u.test(string);
-};
-
-exports.asciiLowercase = string => {
-  return string.replace(/[A-Z]/ug, l => l.toLowerCase());
-};
-
-// This variant only implements it with the extract-value flag set.
-exports.collectAnHTTPQuotedString = (input, position) => {
-  let value = "";
-
-  position++;
-
-  while (true) {
-    while (position < input.length && input[position] !== "\"" && input[position] !== "\\") {
-      value += input[position];
-      ++position;
-    }
-
-    if (position >= input.length) {
-      break;
-    }
-
-    const quoteOrBackslash = input[position];
-    ++position;
-
-    if (quoteOrBackslash === "\\") {
-      if (position >= input.length) {
-        value += "\\";
-        break;
-      }
-
-      value += input[position];
-      ++position;
-    } else {
-      break;
-    }
-  }
-
-  return [value, position];
-};

package/node_modules/whatwg-mimetype/package.json

@@ -1,45 +0,0 @@
-{
-  "name": "whatwg-mimetype",
-  "description": "Parses, serializes, and manipulates MIME types, according to the WHATWG MIME Sniffing Standard",
-  "keywords": [
-    "content-type",
-    "mime type",
-    "mimesniff",
-    "http",
-    "whatwg"
-  ],
-  "version": "4.0.0",
-  "author": "Domenic Denicola <d@domenic.me> (https://domenic.me/)",
-  "license": "MIT",
-  "repository": "jsdom/whatwg-mimetype",
-  "main": "lib/mime-type.js",
-  "files": [
-    "lib/"
-  ],
-  "scripts": {
-    "test": "node --test",
-    "coverage": "c8 node --test --experimental-test-coverage",
-    "lint": "eslint .",
-    "pretest": "node scripts/get-latest-platform-tests.js"
-  },
-  "devDependencies": {
-    "@domenic/eslint-config": "^3.0.0",
-    "c8": "^8.0.1",
-    "eslint": "^8.53.0",
-    "printable-string": "^0.3.0",
-    "whatwg-encoding": "^3.0.0"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "c8": {
-    "reporter": [
-      "text",
-      "html"
-    ],
-    "exclude": [
-      "scripts/",
-      "test/"
-    ]
-  }
-}