@d1g1tal/media-type 4.1.0 → 5.0.1

package/dist/media-type.js

@@ -1,453 +1,299 @@
-var MediaType = (() => {
-  var __defProp = Object.defineProperty;
-  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-  var __getOwnPropNames = Object.getOwnPropertyNames;
-  var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __export = (target, all) => {
-    for (var name in all)
-      __defProp(target, name, { get: all[name], enumerable: true });
-  };
-  var __copyProps = (to, from, except, desc) => {
-    if (from && typeof from === "object" || typeof from === "function") {
-      for (let key of __getOwnPropNames(from))
-        if (!__hasOwnProp.call(to, key) && key !== except)
-          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-    }
-    return to;
-  };
-  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-  // src/media-type.js
-  var media_type_exports = {};
-  __export(media_type_exports, {
-    default: () => MediaType
-  });
+// ../chrysalis/src/esm/object-type.js
+var { toString } = Object.prototype;
+var _type = (object) => object?.constructor ?? globalThis[toString.call(object).slice(8, -1)] ?? object;
+var object_type_default = _type;
 
-  // src/utils.js
-  var whitespaceCharacters = [" ", "	", "\n", "\r"];
-  var leadingWhitespace = /^[ \t\n\r]+/u;
-  var trailingWhitespace = /[ \t\n\r]+$/u;
-  var httpTokenCodePoints = /^[-!#$%&'*+.^_`|~A-Za-z0-9]*$/u;
-  var httpQuotedTokenCodePoints = /^[\t\u0020-\u007E\u0080-\u00FF]*$/u;
-  var removeLeadingAndTrailingHTTPWhitespace = (string) => string.replace(leadingWhitespace, "").replace(trailingWhitespace, "");
-  var removeTrailingHTTPWhitespace = (string) => string.replace(trailingWhitespace, "");
-  var isHTTPWhitespaceChar = (char) => whitespaceCharacters.includes(char);
-  var solelyContainsHTTPTokenCodePoints = (string) => httpTokenCodePoints.test(string);
-  var solelyContainsHTTPQuotedStringTokenCodePoints = (string) => httpQuotedTokenCodePoints.test(string);
-  var asciiLowercase = (string) => {
-    let result = "";
-    for (const [char, charCode = char.charCodeAt(0)] of string) {
-      result += charCode >= 65 && charCode <= 90 ? String.fromCharCode(charCode + 32) : char;
-    }
-    return result;
-  };
-  var collectAnHTTPQuotedString = (input, position) => {
-    let value = "";
-    for (let length = input.length, char; ++position < length; ) {
-      char = input[position];
-      if (char == "\\") {
-        value += ++position < length ? input[position] : char;
-      } else if (char == '"') {
-        break;
-      } else {
-        value += char;
-      }
-    }
-    return [value, position];
-  };
+// src/utils.js
+var httpTokenCodePoints = /^[-!#$%&'*+.^_`|~A-Za-z0-9]*$/u;
+var utils_default = httpTokenCodePoints;
 
-  // src/media-type-parameters.js
-  var MediaTypeParameters = class {
-    /** @type {Map<string, string>} */
-    #map;
-    /**
-     * Create a new MediaTypeParameters instance.
-     *
-     * @param {Array<Array<string>>} entries An array of [name, value] tuples.
-     */
-    constructor(entries) {
-      this.#map = new Map(entries);
-    }
-    /**
-     * Gets the number of media type parameters.
-     *
-     * @returns {number} The number of media type parameters
-     */
-    get size() {
-      return this.#map.size;
-    }
-    /**
-     * Gets the media type parameter value for the supplied name.
-     *
-     * @param {string} name The name of the media type parameter to retrieve.
-     * @returns {string} The media type parameter value.
-     */
-    get(name) {
-      return this.#map.get(asciiLowercase(String(name)));
-    }
-    /**
-     * Indicates whether the media type parameter with the specified name exists or not.
-     *
-     * @param {string} name The name of the media type parameter to check.
-     * @returns {boolean} true if the media type parameter exists, false otherwise.
-     */
-    has(name) {
-      return this.#map.has(asciiLowercase(String(name)));
-    }
-    /**
-     * Adds a new media type parameter using the specified name and value to the MediaTypeParameters.
-     * If an parameter with the same name already exists, the parameter will be updated.
-     *
-     * @param {string} name The name of the media type parameter to set.
-     * @param {string} value The media type parameter value.
-     * @returns {MediaTypeParameters} This instance.
-     */
-    set(name, value) {
-      name = asciiLowercase(String(name));
-      value = String(value);
-      if (!solelyContainsHTTPTokenCodePoints(name)) {
-        throw new Error(`Invalid media type parameter name "${name}": only HTTP token code points are valid.`);
-      }
-      if (!solelyContainsHTTPQuotedStringTokenCodePoints(value)) {
-        throw new Error(`Invalid media type parameter value "${value}": only HTTP quoted-string token code points are valid.`);
-      }
-      this.#map.set(name, value);
-      return this;
-    }
-    /**
-     * Clears all the media type parameters.
-     */
-    clear() {
-      this.#map.clear();
-    }
-    /**
-     * Removes the media type parameter using the specified name.
-     *
-     * @param {string} name The name of the media type parameter to delete.
-     * @returns {boolean} true if the parameter existed and has been removed, or false if the parameter does not exist.
-     */
-    delete(name) {
-      name = asciiLowercase(String(name));
-      return this.#map.delete(name);
-    }
-    /**
-     * Executes a provided function once per each name/value pair in the MediaTypeParameters, in insertion order.
-     *
-     * @param {function(string, string): void} callback The function called on each iteration.
-     * @param {*} [thisArg] Optional object when binding 'this' to the callback.
-     */
-    forEach(callback, thisArg) {
-      this.#map.forEach(callback, thisArg);
-    }
-    /**
-     * Returns an iterable of parameter names.
-     *
-     * @returns {IterableIterator<string>} The {@link IterableIterator} of media type parameter names.
-     */
-    keys() {
-      return this.#map.keys();
-    }
-    /**
-     * Returns an iterable of parameter values.
-     *
-     * @returns {IterableIterator<string>} The {@link IterableIterator} of media type parameter values.
-     */
-    values() {
-      return this.#map.values();
-    }
-    /**
-     * Returns an iterable of name, value pairs for every parameter entry in the media type parameters.
-     *
-     * @returns {IterableIterator<Array<Array<string>>>} The media type parameter entries.
-     */
-    entries() {
-      return this.#map.entries();
-    }
-    /**
-     * A method that returns the default iterator for the {@link MediaTypeParameters}. Called by the semantics of the for-of statement.
-     *
-     * @returns {Iterator<string, string, undefined>} The {@link Symbol.iterator} for the media type parameters.
-     */
-    [Symbol.iterator]() {
-      return this.#map[Symbol.iterator]();
-    }
-    /**
-     * Returns a string representation of the media type parameters.
-     * This method is called by the `String()` function.
-     *
-     * @example
-     * const parameters = new MediaTypeParameters(new Map([['charset', 'utf-8']]));
-     * String(parameters); // 'charset=utf-8'
-     * parameters.toString(); // 'charset=utf-8'
-     * parameters + ''; // 'charset=utf-8'
-     * `${parameters}`; // 'charset=utf-8'
-     * parameters[Symbol.toStringTag]; // 'MediaTypeParameters'
-     * parameters[Symbol.toStringTag](); // 'MediaTypeParameters'
-     * Object.prototype.toString.call(parameters); // '[object MediaTypeParameters]'
-     * parameters + ''; // 'charset=utf-8'
-     * @returns {string} The string representation of the media type parameters.
-     */
-    [Symbol.toStringTag]() {
-      return "MediaTypeParameters";
-    }
-  };
+// src/media-type-parameters.js
+var matcher = /(["\\])/ug;
+var httpQuotedStringTokenCodePoints = /^[\t\u0020-\u007E\u0080-\u00FF]*$/u;
+var MediaTypeParameters = class _MediaTypeParameters extends Map {
+  /**
+   * Create a new MediaTypeParameters instance.
+   *
+   * @param {Array<[string, string]>} entries An array of [name, value] tuples.
+   */
+  constructor(entries = []) {
+    super(entries);
+  }
+  /**
+   * Indicates whether the supplied name and value are valid media type parameters.
+   *
+   * @static
+   * @param {string} name The name of the media type parameter to validate.
+   * @param {string} value The media type parameter value to validate.
+   * @returns {boolean} true if the media type parameter is valid, false otherwise.
+   */
+  static isValid(name, value) {
+    return utils_default.test(name) && httpQuotedStringTokenCodePoints.test(value);
+  }
+  /**
+   * Gets the media type parameter value for the supplied name.
+   *
+   * @param {string} name The name of the media type parameter to retrieve.
+   * @returns {string} The media type parameter value.
+   */
+  get(name) {
+    return super.get(name.toLowerCase());
+  }
+  /**
+   * Indicates whether the media type parameter with the specified name exists or not.
+   *
+   * @param {string} name The name of the media type parameter to check.
+   * @returns {boolean} true if the media type parameter exists, false otherwise.
+   */
+  has(name) {
+    return super.has(name.toLowerCase());
+  }
+  /**
+   * Adds a new media type parameter using the specified name and value to the MediaTypeParameters.
+   * If an parameter with the same name already exists, the parameter will be updated.
+   *
+   * @param {string} name The name of the media type parameter to set.
+   * @param {string} value The media type parameter value.
+   * @returns {MediaTypeParameters} This instance.
+   */
+  set(name, value) {
+    if (!_MediaTypeParameters.isValid(name, value)) {
+      throw new Error(`Invalid media type parameter name/value: ${name}/${value}`);
+    }
+    super.set(name.toLowerCase(), value);
+    return this;
+  }
+  /**
+   * Removes the media type parameter using the specified name.
+   *
+   * @param {string} name The name of the media type parameter to delete.
+   * @returns {boolean} true if the parameter existed and has been removed, or false if the parameter does not exist.
+   */
+  delete(name) {
+    return super.delete(name.toLowerCase());
+  }
+  /**
+   * Returns a string representation of the media type parameters.
+   *
+   * @override
+   * @returns {string} The string representation of the media type parameters.
+   */
+  toString() {
+    return Array.from(this).map(([name, value]) => `;${name}=${!value || !utils_default.test(value) ? `"${value.replace(matcher, "\\$1")}"` : value}`).join("");
+  }
+  /**
+   * Returns the name of this class.
+   *
+   * @override
+   * @returns {string} The name of this class.
+   */
+  [Symbol.toStringTag]() {
+    return "MediaTypeParameters";
+  }
+};
 
-  // src/parser.js
-  var parse = (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;
-    }
-    ++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 mediaType = {
-      type: asciiLowercase(type),
-      subtype: asciiLowercase(subtype),
-      parameters: /* @__PURE__ */ new Map()
-    };
-    while (position < input.length) {
-      ++position;
-      while (isHTTPWhitespaceChar(input[position])) {
+// src/media-type-parser.js
+var whitespaceCharacters = [" ", "	", "\n", "\r"];
+var trailingWhitespace = /[ \t\n\r]+$/u;
+var leadingAndTrailingWhitespace = /^[ \t\n\r]+|[ \t\n\r]+$/ug;
+var MediaTypeParser = class _MediaTypeParser {
+  /**
+   * Function to parse a media type.
+   *
+   * @static
+   * @param {string} input The media type to parse
+   * @returns {{ type: string, subtype: string, parameters: MediaTypeParameters }} An object populated with the parsed media type properties and any parameters.
+   */
+  static parse(input) {
+    input = input.replace(leadingAndTrailingWhitespace, "");
+    const length = input.length, trim = true, lowerCase = false;
+    let { position, result: type, subtype = "" } = _MediaTypeParser.#filterComponent({ input }, "/");
+    if (!type.length || position >= length || !utils_default.test(type)) {
+      throw new TypeError(_MediaTypeParser.#generateErrorMessage("type", type));
+    }
+    ({ position, result: subtype } = _MediaTypeParser.#filterComponent({ position: ++position, input, trim }, ";"));
+    if (!subtype.length || !utils_default.test(subtype)) {
+      throw new TypeError(_MediaTypeParser.#generateErrorMessage("subtype", subtype));
+    }
+    let parameterName = "", parameterValue = null;
+    const parameters = new MediaTypeParameters();
+    while (position++ < length) {
+      while (whitespaceCharacters.includes(input[position])) {
         ++position;
       }
-      let parameterName = "";
-      while (position < input.length && input[position] != ";" && input[position] != "=") {
-        parameterName += input[position];
-        ++position;
-      }
-      parameterName = asciiLowercase(parameterName);
-      if (position < input.length) {
+      ({ position, result: parameterName } = _MediaTypeParser.#filterComponent({ position, input, lowerCase }, ";", "="));
+      if (position < length) {
         if (input[position] == ";") {
           continue;
         }
         ++position;
       }
-      let parameterValue = null;
       if (input[position] == '"') {
-        [parameterValue, position] = collectAnHTTPQuotedString(input, position);
-        while (position < input.length && input[position] != ";") {
+        [parameterValue, position] = _MediaTypeParser.#collectHttpQuotedString(input, position);
+        while (position < length && input[position] != ";") {
           ++position;
         }
       } else {
-        parameterValue = "";
-        while (position < input.length && input[position] != ";") {
-          parameterValue += input[position];
-          ++position;
-        }
-        parameterValue = removeTrailingHTTPWhitespace(parameterValue);
-        if (parameterValue === "") {
+        ({ position, result: parameterValue } = _MediaTypeParser.#filterComponent({ position, input, lowerCase, trim }, ";"));
+        if (!parameterValue) {
           continue;
         }
       }
-      if (parameterName.length > 0 && solelyContainsHTTPTokenCodePoints(parameterName) && solelyContainsHTTPQuotedStringTokenCodePoints(parameterValue) && !mediaType.parameters.has(parameterName)) {
-        mediaType.parameters.set(parameterName, parameterValue);
+      if (parameterName && MediaTypeParameters.isValid(parameterName, parameterValue) && !parameters.has(parameterName)) {
+        parameters.set(parameterName, parameterValue);
       }
     }
-    return mediaType;
-  };
-  var parser_default = parse;
-
-  // src/serializer.js
-  var serialize = (mediaType) => {
-    let serialization = `${mediaType.type}/${mediaType.subtype}`;
-    if (mediaType.parameters.size === 0) {
-      return serialization;
-    }
-    for (let [name, value] of mediaType.parameters) {
-      serialization += `;${name}=`;
-      if (!solelyContainsHTTPTokenCodePoints(value) || value.length === 0) {
-        value = `"${value.replace(/(["\\])/ug, "\\$1")}"`;
+    return { type, subtype, parameters };
+  }
+  /**
+   * Filters a component from the input string.
+   *
+   * @private
+   * @static
+   * @param {Object} options The options.
+   * @param {number} [options.position] The starting position.
+   * @param {string} options.input The input string.
+   * @param {boolean} [options.lowerCase] Indicates whether the result should be lowercased.
+   * @param {boolean} [options.trim] Indicates whether the result should be trimmed.
+   * @param {string[]} charactersToFilter The characters to filter.
+   * @returns {{ position: number, result: string }} An object that includes the resulting string and updated position.
+   */
+  static #filterComponent({ position = 0, input, lowerCase = true, trim = false }, ...charactersToFilter) {
+    let result = "";
+    for (const length = input.length; position < length && !charactersToFilter.includes(input[position]); position++) {
+      result += input[position];
+    }
+    if (lowerCase) {
+      result = result.toLowerCase();
+    }
+    if (trim) {
+      result = result.replace(trailingWhitespace, "");
+    }
+    return { position, result };
+  }
+  /**
+   * Collects all the HTTP quoted strings.
+   * This variant only implements it with the extract-value flag set.
+   *
+   * @private
+   * @static
+   * @param {string} input The string to process.
+   * @param {number} position The starting position.
+   * @returns {Array<string|number>} An array that includes the resulting string and updated position.
+   */
+  static #collectHttpQuotedString(input, position) {
+    let value = "";
+    for (let length = input.length, char; ++position < length; ) {
+      if ((char = input[position]) == '"') {
+        break;
       }
-      serialization += value;
+      value += char == "\\" && ++position < length ? input[position] : char;
     }
-    return serialization;
-  };
-  var serializer_default = serialize;
+    return [value, position];
+  }
+  /**
+   * Generates an error message.
+   *
+   * @private
+   * @static
+   * @param {string} component The component name.
+   * @param {string} value The component value.
+   * @returns {string} The error message.
+   */
+  static #generateErrorMessage(component, value) {
+    return `Invalid ${component} "${value}": only HTTP token code points are valid.`;
+  }
+};
 
-  // src/media-type.js
-  var MediaType = class {
-    /** @type {string} */
-    #type;
-    /** @type {string} */
-    #subtype;
-    /** @type {MediaTypeParameters} */
-    #parameters;
-    /**
-     * Create a new MediaType instance from a string representation.
-     *
-     * @param {string} mediaType The media type to parse.
-     * @param {Object} [parameters] Optional parameters.
-     */
-    constructor(mediaType, parameters = {}) {
-      const { type, subtype, parameters: parsedParameters } = parser_default(mediaType);
-      this.#type = type;
-      this.#subtype = subtype;
-      this.#parameters = new MediaTypeParameters([...parsedParameters, ...Object.entries(parameters).map(([name, value]) => [asciiLowercase(name), asciiLowercase(value)])]);
-    }
-    /**
-     * Static factory method for parsing a media type.
-     *
-     * @param {string} string The media type to parse.
-     * @returns {MediaType} The parsed {@link MediaType} object or null if the string could not be parsed.
-     */
-    static parse(string) {
-      try {
-        return new MediaType(string);
-      } catch (e) {
-        throw new Error(`Could not parse media type string '${string}'`);
-      }
-    }
-    /**
-     * Gets the media type essence (type/subtype).
-     *
-     * @returns {string} The media type without any parameters
-     */
-    get essence() {
-      return `${this.#type}/${this.#subtype}`;
-    }
-    /**
-     * Gets the type.
-     *
-     * @returns {string} The type.
-     */
-    get type() {
-      return this.#type;
-    }
-    /**
-     * Sets the 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;
-    }
-    /**
-     * Gets the subtype.
-     *
-     * @returns {string} The subtype.
-     */
-    get subtype() {
-      return this.#subtype;
-    }
-    /**
-     * Sets the 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;
-    }
-    /**
-     * Gets the parameters.
-     *
-     * @returns {MediaTypeParameters} The media type parameters.
-     */
-    get parameters() {
-      return this.#parameters;
-    }
-    /**
-     * Gets the serialized version of the media type.
-     *
-     * @returns {string} The serialized media type.
-     */
-    toString() {
-      return serializer_default(this);
-    }
-    /**
-     * Determines if this instance is a JavaScript media type.
-     *
-     * @param {Object} [options] Optional options.
-     * @param {boolean} [options.prohibitParameters=false] The option to prohibit parameters when checking if the media type is JavaScript.
-     * @returns {boolean} true if this instance represents a JavaScript media type, false otherwise.
-     */
-    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;
-      }
-    }
-    /**
-     * Determines if this instance is an XML media type.
-     *
-     * @returns {boolean} true if this instance represents an XML media type, false otherwise.
-     */
-    isXML() {
-      return this.#subtype === "xml" && (this.#type === "text" || this.#type === "application") || this.#subtype.endsWith("+xml");
-    }
-    /**
-     * Determines if this instance is an HTML media type.
-     *
-     * @returns {boolean} true if this instance represents an HTML media type, false otherwise.
-     */
-    isHTML() {
-      return this.#subtype === "html" && this.#type === "text";
-    }
-    /**
-     * Gets the name of the class.
-     *
-     * @returns {string} The class name
-     */
-    get [Symbol.toStringTag]() {
-      return "MediaType";
-    }
-  };
-  return __toCommonJS(media_type_exports);
-})();
-window.MediaType = MediaType.default;
+// src/media-type.js
+var MediaType = class _MediaType {
+  /** @type {string} */
+  #type;
+  /** @type {string} */
+  #subtype;
+  /** @type {MediaTypeParameters} */
+  #parameters;
+  /**
+   * Create a new MediaType instance from a string representation.
+   *
+   * @param {string} mediaType The media type to parse.
+   * @param {Object} [parameters] Optional parameters.
+   */
+  constructor(mediaType, parameters = {}) {
+    if (object_type_default(parameters) != Object) {
+      throw new TypeError("The parameters argument must be an object");
+    }
+    ({ type: this.#type, subtype: this.#subtype, parameters: this.#parameters } = MediaTypeParser.parse(mediaType));
+    for (const [name, value] of Object.entries(parameters)) {
+      this.#parameters.set(name, value);
+    }
+  }
+  static parse(mediaType) {
+    try {
+      return new _MediaType(mediaType);
+    } catch (e) {
+    }
+    return null;
+  }
+  /**
+   * Gets the type.
+   *
+   * @returns {string} The type.
+   */
+  get type() {
+    return this.#type;
+  }
+  /**
+   * Gets the subtype.
+   *
+   * @returns {string} The subtype.
+   */
+  get subtype() {
+    return this.#subtype;
+  }
+  /**
+   * Gets the media type essence (type/subtype).
+   *
+   * @returns {string} The media type without any parameters
+   */
+  get essence() {
+    return `${this.#type}/${this.#subtype}`;
+  }
+  /**
+   * Gets the parameters.
+   *
+   * @returns {MediaTypeParameters} The media type parameters.
+   */
+  get parameters() {
+    return this.#parameters;
+  }
+  /**
+   * Checks if the media type matches the specified type.
+   *
+   * @todo Fix string handling to parse the type and subtype from the string.
+   * @param {MediaType|string} mediaType The media type to check.
+   * @returns {boolean} true if the media type matches the specified type, false otherwise.
+   */
+  matches(mediaType) {
+    return this.#type === mediaType?.type && this.#subtype === mediaType?.subtype || this.essence.includes(mediaType);
+  }
+  /**
+   * Gets the serialized version of the media type.
+   *
+   * @returns {string} The serialized media type.
+   */
+  toString() {
+    return `${this.essence}${this.#parameters.toString()}`;
+  }
+  /**
+   * Gets the name of the class.
+   *
+   * @returns {string} The class name
+   */
+  get [Symbol.toStringTag]() {
+    return "MediaType";
+  }
+};
+export {
+  MediaType as default
+};