Diffusion Open Access Compliance Check Tool (OACCT) (paginated-inlines) Browse

rOACCT/node_modules/type-is/index.js
f646e1f695a7paginated-inlines

index.js
View Options

			/*!
			* type-is
			* Copyright(c) 2014 Jonathan Ong
			* Copyright(c) 2014-2015 Douglas Christopher Wilson
			* MIT Licensed
			*/

			'use strict'

			/**
			* Module dependencies.
			* @private
			*/

			var typer = require('media-typer')
			var mime = require('mime-types')

			/**
			* Module exports.
			* @public
			*/

			module.exports = typeofrequest
			module.exports.is = typeis
			module.exports.hasBody = hasbody
			module.exports.normalize = normalize
			module.exports.match = mimeMatch

			/**
			* Compare a `value` content-type with `types`.
			* Each `type` can be an extension like `html`,
			* a special shortcut like `multipart` or `urlencoded`,
			* or a mime type.
			*
			* If no types match, `false` is returned.
			* Otherwise, the first `type` that matches is returned.
			*
			* @param {String} value
			* @param {Array} types
			* @public
			*/

			function typeis (value, types_) {
			var i
			var types = types_

			// remove parameters and normalize
			var val = tryNormalizeType(value)

			// no type or invalid
			if (!val) {
			return false
			}

			// support flattened arguments
			if (types && !Array.isArray(types)) {
			types = new Array(arguments.length - 1)
			for (i = 0; i < types.length; i++) {
			types[i] = arguments[i + 1]
			}
			}

			// no types, return the content type
			if (!types \|\| !types.length) {
			return val
			}

			var type
			for (i = 0; i < types.length; i++) {
			if (mimeMatch(normalize(type = types[i]), val)) {
			return type[0] === '+' \|\| type.indexOf('*') !== -1
			? val
			: type
			}
			}

			// no matches
			return false
			}

			/**
			* Check if a request has a request body.
			* A request with a body __must__ either have `transfer-encoding`
			* or `content-length` headers set.
			* http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.3
			*
			* @param {Object} request
			* @return {Boolean}
			* @public
			*/

			function hasbody (req) {
			return req.headers['transfer-encoding'] !== undefined \|\|
			!isNaN(req.headers['content-length'])
			}

			/**
			* Check if the incoming request contains the "Content-Type"
			* header field, and it contains any of the give mime `type`s.
			* If there is no request body, `null` is returned.
			* If there is no content type, `false` is returned.
			* Otherwise, it returns the first `type` that matches.
			*
			* Examples:
			*
			* // With Content-Type: text/html; charset=utf-8
			* this.is('html'); // => 'html'
			* this.is('text/html'); // => 'text/html'
			* this.is('text/*', 'application/json'); // => 'text/html'
			*
			* // When Content-Type is application/json
			* this.is('json', 'urlencoded'); // => 'json'
			* this.is('application/json'); // => 'application/json'
			* this.is('html', 'application/*'); // => 'application/json'
			*
			* this.is('html'); // => false
			*
			* @param {String\|Array} types...
			* @return {String\|false\|null}
			* @public
			*/

			function typeofrequest (req, types_) {
			var types = types_

			// no body
			if (!hasbody(req)) {
			return null
			}

			// support flattened arguments
			if (arguments.length > 2) {
			types = new Array(arguments.length - 1)
			for (var i = 0; i < types.length; i++) {
			types[i] = arguments[i + 1]
			}
			}

			// request content type
			var value = req.headers['content-type']

			return typeis(value, types)
			}

			/**
			* Normalize a mime type.
			* If it's a shorthand, expand it to a valid mime type.
			*
			* In general, you probably want:
			*
			* var type = is(req, ['urlencoded', 'json', 'multipart']);
			*
			* Then use the appropriate body parsers.
			* These three are the most common request body types
			* and are thus ensured to work.
			*
			* @param {String} type
			* @private
			*/

			function normalize (type) {
			if (typeof type !== 'string') {
			// invalid type
			return false
			}

			switch (type) {
			case 'urlencoded':
			return 'application/x-www-form-urlencoded'
			case 'multipart':
			return 'multipart/*'
			}

			if (type[0] === '+') {
			// "+json" -> "/+json" expando
			return '/' + type
			}

			return type.indexOf('/') === -1
			? mime.lookup(type)
			: type
			}

			/**
			* Check if `expected` mime type
			* matches `actual` mime type with
			* wildcard and +suffix support.
			*
			* @param {String} expected
			* @param {String} actual
			* @return {Boolean}
			* @private
			*/

			function mimeMatch (expected, actual) {
			// invalid type
			if (expected === false) {
			return false
			}

			// split types
			var actualParts = actual.split('/')
			var expectedParts = expected.split('/')

			// invalid format
			if (actualParts.length !== 2 \|\| expectedParts.length !== 2) {
			return false
			}

			// validate type
			if (expectedParts[0] !== '*' && expectedParts[0] !== actualParts[0]) {
			return false
			}

			// validate suffix wildcard
			if (expectedParts[1].substr(0, 2) === '*+') {
			return expectedParts[1].length <= actualParts[1].length + 1 &&
			expectedParts[1].substr(1) === actualParts[1].substr(1 - expectedParts[1].length)
			}

			// validate subtype
			if (expectedParts[1] !== '*' && expectedParts[1] !== actualParts[1]) {
			return false
			}

			return true
			}

			/**
			* Normalize a type and remove parameters.
			*
			* @param {string} value
			* @return {string}
			* @private
			*/

			function normalizeType (value) {
			// parse the type
			var type = typer.parse(value)

			// remove the parameters
			type.parameters = undefined

			// reformat it
			return typer.format(type)
			}

			/**
			* Try to normalize a type and remove parameters.
			*
			* @param {string} value
			* @return {string}
			* @private
			*/

			function tryNormalizeType (value) {
			if (!value) {
			return null
			}

			try {
			return normalizeType(value)
			} catch (err) {
			return null
			}
			}