Add parameters option to parse

README.md

@@ -20,7 +20,7 @@ npm install content-type
 const contentType = require("content-type");
 ```
 
-### contentType.parse(string)
+### contentType.parse(string, options?)
 
 ```js
 const obj = contentType.parse("image/svg+xml; charset=utf-8");
@@ -33,6 +33,10 @@ Parse a `Content-Type` header. This will return an object with the following pro
 
 The parser is lenient, but will throw a `TypeError` when unable to parse a parameter due to ambiguity. E.g. `foo="` where the quote is unterminated.
 
+#### Options
+
+- `parameters` (default: `true`): Set to `false` to skip parsing parameters, only returns `type`.
+
 ### contentType.format(obj)
 
 ```js

src/index.bench.ts

@@ -21,6 +21,10 @@ describe("parse", () => {
     parse(PARAMS_HEADER);
   });
 
+  bench("simple parameters (options.parameters = false)", () => {
+    parse(PARAMS_HEADER, { parameters: false });
+  });
+
   bench("quoted and escaped parameters", () => {
     parse(QUOTED_HEADER);
   });

src/index.ts

@@ -55,20 +55,27 @@ export function format(obj: ContentType): string {
   return result;
 }
 
+/**
+ * Options for parsing a `Content-Type` header.
+ */
+export interface ParseOptions {
+  parameters?: boolean;
+}
+
 /**
  * Parse a `Content-Type` header.
  */
-export function parse(header: string): ContentType {
+export function parse(header: string, options?: ParseOptions): ContentType {
   const len = header.length;
   const semiIndex = header.indexOf(";");
   const end = semiIndex !== -1 ? semiIndex : len;
   const valueStart = skipOWS(header, 0, end);
   const valueEnd = trailingOWS(header, valueStart, end);
   const type = header.slice(valueStart, valueEnd).toLowerCase();
 
-  if (semiIndex === -1) return { type };
+  if (semiIndex === -1 || options?.parameters === false) return { type };
 
-  const parameters = parseParameters(header, end, len);
+  const parameters = parseParameters(header, end + 1, len);
   return { type, parameters };
 }
 
@@ -80,21 +87,24 @@ function parseParameters(
   const parameters: Record<string, string> = Object.create(null);
 
   parameter: while (index < len) {
-    index = skipOWS(header, index + 1, len);
+    index = skipOWS(header, index, len);
 
     const keyStart = index;
 
     while (index < len) {
       const char = header[index];
-      if (char === ";") continue parameter;
+      if (char === ";") {
+        index++;
+        continue parameter;
+      }
 
       if (char === "=") {
         const keyEnd = trailingOWS(header, keyStart, index);
         const key = header.slice(keyStart, keyEnd).toLowerCase();
 
         index = skipOWS(header, index + 1, len);
 
-        if (header[index] === '"') {
+        if (index < len && header[index] === '"') {
           index++;
 
           let value = "";
@@ -103,12 +113,11 @@ function parseParameters(
             if (char === '"') {
               index = skipOWS(header, index, len);
               if (index < len && header[index] !== ";") {
-                throw new TypeError(
-                  `Unexpected characters after parameter at index ${index}`,
-                );
+                throw new TypeError(`Unexpected character at index ${index}`);
               }
 
               parameters[key] = value;
+              index++;
               continue parameter;
             }
 
@@ -131,6 +140,7 @@ function parseParameters(
 
         const valueEnd = trailingOWS(header, valueStart, index);
         parameters[key] = header.slice(valueStart, valueEnd);
+        index++;
         continue parameter;
       }
 

src/parse.spec.ts

@@ -190,7 +190,7 @@ describe("parse(string)", function () {
   it("should error on non-OWS after closing quote", function () {
     assert.throws(
       parse.bind(null, 'text/plain; foo="bar"baz'),
-      /Unexpected characters after parameter at index 21/,
+      /Unexpected character at index 21/,
     );
   });
 
@@ -213,4 +213,13 @@ describe("parse(string)", function () {
       },
     });
   });
+
+  it("should skip parsing parameters when options.parameters is false", function () {
+    const type = parse("text/html; charset=utf-8; foo=bar", {
+      parameters: false,
+    });
+    assert.deepEqual(type, {
+      type: "text/html",
+    });
+  });
 });