| /*! |
| * media-typer |
| * Copyright(c) 2014 Douglas Christopher Wilson |
| * MIT Licensed |
| */ |
| |
| /** |
| * RegExp to match *( ";" parameter ) in RFC 2616 sec 3.7 |
| * |
| * parameter = token "=" ( token | quoted-string ) |
| * token = 1*<any CHAR except CTLs or separators> |
| * separators = "(" | ")" | "<" | ">" | "@" |
| * | "," | ";" | ":" | "\" | <"> |
| * | "/" | "[" | "]" | "?" | "=" |
| * | "{" | "}" | SP | HT |
| * quoted-string = ( <"> *(qdtext | quoted-pair ) <"> ) |
| * qdtext = <any TEXT except <">> |
| * quoted-pair = "\" CHAR |
| * CHAR = <any US-ASCII character (octets 0 - 127)> |
| * TEXT = <any OCTET except CTLs, but including LWS> |
| * LWS = [CRLF] 1*( SP | HT ) |
| * CRLF = CR LF |
| * CR = <US-ASCII CR, carriage return (13)> |
| * LF = <US-ASCII LF, linefeed (10)> |
| * SP = <US-ASCII SP, space (32)> |
| * SHT = <US-ASCII HT, horizontal-tab (9)> |
| * CTL = <any US-ASCII control character (octets 0 - 31) and DEL (127)> |
| * OCTET = <any 8-bit sequence of data> |
| */ |
| var paramRegExp = /; *([!#$%&'\*\+\-\.0-9A-Z\^_`a-z\|~]+) *= *("(?:[ !\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u0020-\u007e])*"|[!#$%&'\*\+\-\.0-9A-Z\^_`a-z\|~]+) */g; |
| var textRegExp = /^[\u0020-\u007e\u0080-\u00ff]+$/ |
| var tokenRegExp = /^[!#$%&'\*\+\-\.0-9A-Z\^_`a-z\|~]+$/ |
| |
| /** |
| * RegExp to match quoted-pair in RFC 2616 |
| * |
| * quoted-pair = "\" CHAR |
| * CHAR = <any US-ASCII character (octets 0 - 127)> |
| */ |
| var qescRegExp = /\\([\u0000-\u007f])/g; |
| |
| /** |
| * RegExp to match chars that must be quoted-pair in RFC 2616 |
| */ |
| var quoteRegExp = /([\\"])/g; |
| |
| /** |
| * RegExp to match type in RFC 6838 |
| * |
| * type-name = restricted-name |
| * subtype-name = restricted-name |
| * restricted-name = restricted-name-first *126restricted-name-chars |
| * restricted-name-first = ALPHA / DIGIT |
| * restricted-name-chars = ALPHA / DIGIT / "!" / "#" / |
| * "$" / "&" / "-" / "^" / "_" |
| * restricted-name-chars =/ "." ; Characters before first dot always |
| * ; specify a facet name |
| * restricted-name-chars =/ "+" ; Characters after last plus always |
| * ; specify a structured syntax suffix |
| * ALPHA = %x41-5A / %x61-7A ; A-Z / a-z |
| * DIGIT = %x30-39 ; 0-9 |
| */ |
| var subtypeNameRegExp = /^[A-Za-z0-9][A-Za-z0-9!#$&^_.-]{0,126}$/ |
| var typeNameRegExp = /^[A-Za-z0-9][A-Za-z0-9!#$&^_-]{0,126}$/ |
| var typeRegExp = /^ *([A-Za-z0-9][A-Za-z0-9!#$&^_-]{0,126})\/([A-Za-z0-9][A-Za-z0-9!#$&^_.+-]{0,126}) *$/; |
| |
| /** |
| * Module exports. |
| */ |
| |
| exports.format = format |
| exports.parse = parse |
| |
| /** |
| * Format object to media type. |
| * |
| * @param {object} obj |
| * @return {string} |
| * @api public |
| */ |
| |
| function format(obj) { |
| if (!obj || typeof obj !== 'object') { |
| throw new TypeError('argument obj is required') |
| } |
| |
| var parameters = obj.parameters |
| var subtype = obj.subtype |
| var suffix = obj.suffix |
| var type = obj.type |
| |
| if (!type || !typeNameRegExp.test(type)) { |
| throw new TypeError('invalid type') |
| } |
| |
| if (!subtype || !subtypeNameRegExp.test(subtype)) { |
| throw new TypeError('invalid subtype') |
| } |
| |
| // format as type/subtype |
| var string = type + '/' + subtype |
| |
| // append +suffix |
| if (suffix) { |
| if (!typeNameRegExp.test(suffix)) { |
| throw new TypeError('invalid suffix') |
| } |
| |
| string += '+' + suffix |
| } |
| |
| // append parameters |
| if (parameters && typeof parameters === 'object') { |
| var param |
| var params = Object.keys(parameters).sort() |
| |
| for (var i = 0; i < params.length; i++) { |
| param = params[i] |
| |
| if (!tokenRegExp.test(param)) { |
| throw new TypeError('invalid parameter name') |
| } |
| |
| string += '; ' + param + '=' + qstring(parameters[param]) |
| } |
| } |
| |
| return string |
| } |
| |
| /** |
| * Parse media type to object. |
| * |
| * @param {string|object} string |
| * @return {Object} |
| * @api public |
| */ |
| |
| function parse(string) { |
| if (!string) { |
| throw new TypeError('argument string is required') |
| } |
| |
| // support req/res-like objects as argument |
| if (typeof string === 'object') { |
| string = getcontenttype(string) |
| } |
| |
| if (typeof string !== 'string') { |
| throw new TypeError('argument string is required to be a string') |
| } |
| |
| var index = string.indexOf(';') |
| var type = index !== -1 |
| ? string.substr(0, index) |
| : string |
| |
| var key |
| var match |
| var obj = splitType(type) |
| var params = {} |
| var value |
| |
| paramRegExp.lastIndex = index |
| |
| while (match = paramRegExp.exec(string)) { |
| if (match.index !== index) { |
| throw new TypeError('invalid parameter format') |
| } |
| |
| index += match[0].length |
| key = match[1].toLowerCase() |
| value = match[2] |
| |
| if (value[0] === '"') { |
| // remove quotes and escapes |
| value = value |
| .substr(1, value.length - 2) |
| .replace(qescRegExp, '$1') |
| } |
| |
| params[key] = value |
| } |
| |
| if (index !== -1 && index !== string.length) { |
| throw new TypeError('invalid parameter format') |
| } |
| |
| obj.parameters = params |
| |
| return obj |
| } |
| |
| /** |
| * Get content-type from req/res objects. |
| * |
| * @param {object} |
| * @return {Object} |
| * @api private |
| */ |
| |
| function getcontenttype(obj) { |
| if (typeof obj.getHeader === 'function') { |
| // res-like |
| return obj.getHeader('content-type') |
| } |
| |
| if (typeof obj.headers === 'object') { |
| // req-like |
| return obj.headers && obj.headers['content-type'] |
| } |
| } |
| |
| /** |
| * Quote a string if necessary. |
| * |
| * @param {string} val |
| * @return {string} |
| * @api private |
| */ |
| |
| function qstring(val) { |
| var str = String(val) |
| |
| // no need to quote tokens |
| if (tokenRegExp.test(str)) { |
| return str |
| } |
| |
| if (str.length > 0 && !textRegExp.test(str)) { |
| throw new TypeError('invalid parameter value') |
| } |
| |
| return '"' + str.replace(quoteRegExp, '\\$1') + '"' |
| } |
| |
| /** |
| * Simply "type/subtype+siffx" into parts. |
| * |
| * @param {string} string |
| * @return {Object} |
| * @api private |
| */ |
| |
| function splitType(string) { |
| var match = typeRegExp.exec(string.toLowerCase()) |
| |
| if (!match) { |
| throw new TypeError('invalid media type') |
| } |
| |
| var type = match[1] |
| var subtype = match[2] |
| var suffix |
| |
| // suffix after last + |
| var index = subtype.lastIndexOf('+') |
| if (index !== -1) { |
| suffix = subtype.substr(index + 1) |
| subtype = subtype.substr(0, index) |
| } |
| |
| var obj = { |
| type: type, |
| subtype: subtype, |
| suffix: suffix |
| } |
| |
| return obj |
| } |