@node-core/utils 7.2.1 → 7.2.3

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/"
-    ]
-  }
-}