whatwg-mimetype 2.0.0 → 2.3.0

package/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright © 2017 Domenic Denicola <d@domenic.me>
+Copyright © 2017–2018 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:
 

package/README.md

@@ -3,7 +3,7 @@
 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("content-type-parser");
+const MIMEType = require("whatwg-mimetype");
 
 const mimeType = new MIMEType(`Text/HTML;Charset="utf-8"`);
 
@@ -24,14 +24,16 @@ 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)).
 
-If the passed string cannot be parsed as a MIME type, the `MIMEType` constructor will throw.
-
-This package's algorithms conform to those of the WHATWG [MIME Sniffing Standard](https://mimesniff.spec.whatwg.org/), and is aligned up to commit [cc81ec4](https://github.com/whatwg/mimesniff/commit/cc81ec48288944562c4554069da1d74a71e199fb).
+This package's algorithms conform to those of the WHATWG [MIME Sniffing Standard](https://mimesniff.spec.whatwg.org/), and is aligned up to commit [126286a](https://github.com/whatwg/mimesniff/commit/126286ab2dcf3e2d541349ed93539a88bf394ad5).
 
 ## `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"`
@@ -50,8 +52,9 @@ This package's main module's default export is a class, `MIMEType`. Its construc
 - `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({ allowParameters })`: returns true if this instance represents [a JavaScript MIME type](https://html.spec.whatwg.org/multipage/scripting.html#javascript-mime-type); `allowParameters` can be set to true to allow arbitrary parameters, instead of their presence causing the method to return `false`
 
-_Note: the `isHTML()` and `isXML()` 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._
+_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
 
@@ -89,8 +92,8 @@ mimeType.parameters.set("@", "x");
 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("content-type-parser/parser");
-const serialize = require("content-type-parser/serialize");
+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`.

package/lib/mime-type.js

@@ -20,6 +20,14 @@ module.exports = class MIMEType {
     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}`;
   }
@@ -68,6 +76,47 @@ module.exports = class MIMEType {
     return serialize(this);
   }
 
+  isJavaScript({ allowParameters = 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 allowParameters || this._parameters.size === 0;
+          }
+          default: {
+            return false;
+          }
+        }
+      }
+      case "application": {
+        switch (this._subtype) {
+          case "ecmascript":
+          case "javascript":
+          case "x-ecmascript":
+          case "x-javascript": {
+            return allowParameters || 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");

package/lib/parser.js

@@ -1,15 +1,15 @@
 "use strict";
 const {
-  removeLeadingAndTrailingASCIIWhitespace,
-  removeTrailingASCIIWhitespace,
-  isASCIIWhitespaceChar,
+  removeLeadingAndTrailingHTTPWhitespace,
+  removeTrailingHTTPWhitespace,
+  isHTTPWhitespaceChar,
   solelyContainsHTTPTokenCodePoints,
   soleyContainsHTTPQuotedStringTokenCodePoints,
   asciiLowercase
 } = require("./utils.js");
 
 module.exports = input => {
-  input = removeLeadingAndTrailingASCIIWhitespace(input);
+  input = removeLeadingAndTrailingHTTPWhitespace(input);
 
   let position = 0;
   let type = "";
@@ -35,7 +35,7 @@ module.exports = input => {
     ++position;
   }
 
-  subtype = removeTrailingASCIIWhitespace(subtype);
+  subtype = removeTrailingHTTPWhitespace(subtype);
 
   if (subtype.length === 0 || !solelyContainsHTTPTokenCodePoints(subtype)) {
     return null;
@@ -51,7 +51,7 @@ module.exports = input => {
     // Skip past ";"
     ++position;
 
-    while (isASCIIWhitespaceChar(input[position])) {
+    while (isHTTPWhitespaceChar(input[position])) {
       ++position;
     }
 
@@ -72,46 +72,47 @@ module.exports = input => {
     }
 
     let parameterValue = "";
-    if (position < input.length) {
-      if (input[position] === "\"") {
-        ++position;
+    if (input[position] === "\"") {
+      ++position;
 
-        while (true) {
-          while (position < input.length && input[position] !== "\"" && input[position] !== "\\") {
-            parameterValue += input[position];
-            ++position;
-          }
+      while (true) {
+        while (position < input.length && input[position] !== "\"" && input[position] !== "\\") {
+          parameterValue += input[position];
+          ++position;
+        }
 
-          if (position < input.length && input[position] === "\\") {
+        if (position < input.length && input[position] === "\\") {
+          ++position;
+          if (position < input.length) {
+            parameterValue += input[position];
             ++position;
-            if (position < input.length) {
-              parameterValue += input[position];
-              ++position;
-              continue;
-            } else {
-              parameterValue += "\\";
-              break;
-            }
+            continue;
           } else {
+            parameterValue += "\\";
             break;
           }
+        } else {
+          break;
         }
+      }
 
-        while (position < input.length && input[position] !== ";") {
-          ++position;
-        }
-      } else {
-        while (position < input.length && input[position] !== ";") {
-          parameterValue += input[position];
-          ++position;
-        }
+      while (position < input.length && input[position] !== ";") {
+        ++position;
+      }
+    } else {
+      while (position < input.length && input[position] !== ";") {
+        parameterValue += input[position];
+        ++position;
+      }
 
-        parameterValue = removeTrailingASCIIWhitespace(parameterValue);
+      parameterValue = removeTrailingHTTPWhitespace(parameterValue);
+
+      if (parameterValue === "") {
+        continue;
       }
     }
 
     if (parameterName.length > 0 &&
-        parameterValue.length > 0 &&
         solelyContainsHTTPTokenCodePoints(parameterName) &&
         soleyContainsHTTPQuotedStringTokenCodePoints(parameterValue) &&
         !mimeType.parameters.has(parameterName)) {

package/lib/serializer.js

@@ -13,7 +13,7 @@ module.exports = mimeType => {
     serialization += name;
     serialization += "=";
 
-    if (!solelyContainsHTTPTokenCodePoints(value)) {
+    if (!solelyContainsHTTPTokenCodePoints(value) || value.length === 0) {
       value = value.replace(/(["\\])/g, "\\$1");
       value = `"${value}"`;
     }

package/lib/utils.js

@@ -1,23 +1,23 @@
 "use strict";
 
-exports.removeLeadingAndTrailingASCIIWhitespace = string => {
-  return string.replace(/^[ \t\n\f\r]+/, "").replace(/[ \t\n\f\r]+$/, "");
+exports.removeLeadingAndTrailingHTTPWhitespace = string => {
+  return string.replace(/^[ \t\n\r]+/, "").replace(/[ \t\n\r]+$/, "");
 };
 
-exports.removeTrailingASCIIWhitespace = string => {
-  return string.replace(/[ \t\n\f\r]+$/, "");
+exports.removeTrailingHTTPWhitespace = string => {
+  return string.replace(/[ \t\n\r]+$/, "");
 };
 
-exports.isASCIIWhitespaceChar = char => {
-  return char === " " || char === "\t" || char === "\n" || char === "\f" || char === "\r";
+exports.isHTTPWhitespaceChar = char => {
+  return char === " " || char === "\t" || char === "\n" || char === "\r";
 };
 
 exports.solelyContainsHTTPTokenCodePoints = string => {
-  return /^[-!#$%&'*+.^_`|~A-Za-z0-9]+$/.test(string);
+  return /^[-!#$%&'*+.^_`|~A-Za-z0-9]*$/.test(string);
 };
 
 exports.soleyContainsHTTPQuotedStringTokenCodePoints = string => {
-  return /^[\t\u0020-\u007E\u0080-\u00FF]+$/.test(string);
+  return /^[\t\u0020-\u007E\u0080-\u00FF]*$/.test(string);
 };
 
 exports.asciiLowercase = string => {

package/package.json

@@ -8,7 +8,7 @@
     "http",
     "whatwg"
   ],
-  "version": "2.0.0",
+  "version": "2.3.0",
   "author": "Domenic Denicola <d@domenic.me> (https://domenic.me/)",
   "license": "MIT",
   "repository": "jsdom/whatwg-mimetype",
@@ -23,11 +23,11 @@
     "pretest": "node scripts/get-latest-platform-tests.js"
   },
   "devDependencies": {
-    "eslint": "^4.12.1",
-    "jest": "^21.2.1",
+    "eslint": "^5.9.0",
+    "jest": "^23.6.0",
     "printable-string": "^0.3.0",
-    "request": "^2.83.0",
-    "whatwg-encoding": "^1.0.3"
+    "request": "^2.88.0",
+    "whatwg-encoding": "^1.0.5"
   },
   "jest": {
     "coverageDirectory": "coverage",