node_modules

node_modules/mime/src/README_js.md

@@ -0,0 +1,184 @@
+```javascript --hide
+runmd.onRequire = path => path.replace(/^mime/, '..');
+```
+# Mime
+
+A comprehensive, compact MIME type module.
+
+[![Build Status](https://travis-ci.org/broofa/node-mime.svg?branch=master)](https://travis-ci.org/broofa/node-mime)
+
+## Version 2 Notes
+
+Version 2 is a breaking change from 1.x as the semver implies.  Specifically:
+
+* `lookup()` renamed to `getType()`
+* `extension()` renamed to `getExtension()`
+* `charset()` and `load()` methods have been removed
+
+If you prefer the legacy version of this module please `npm install mime@^1`.  Version 1 docs may be found [here](https://github.com/broofa/node-mime/tree/v1.4.0).
+
+## Install
+
+### NPM
+```
+npm install mime
+```
+
+### Browser
+
+It is recommended that you use a bundler such as
+[webpack](https://webpack.github.io/) or [browserify](http://browserify.org/) to
+package your code.  However, browser-ready versions are available via wzrd.in.
+E.g. For the full version:
+
+    <script src="https://wzrd.in/standalone/mime@latest"></script>
+    <script>
+    mime.getType(...); // etc.
+    <script>
+
+Or, for the `mime/lite` version:
+
+    <script src="https://wzrd.in/standalone/mime%2flite@latest"></script>
+    <script>
+    mimelite.getType(...); // (Note `mimelite` here)
+    <script>
+
+## Quick Start
+
+For the full version (800+ MIME types, 1,000+ extensions):
+
+```javascript --run default
+const mime = require('mime');
+
+mime.getType('txt');                    // RESULT
+mime.getExtension('text/plain');        // RESULT
+```
+
+See [Mime API](#mime-api) below for API details.
+
+## Lite Version
+
+There is also a "lite" version of this module that omits vendor-specific
+(`*/vnd.*`) and experimental (`*/x-*`) types.  It weighs in at ~2.5KB, compared
+to 8KB for the full version.  To load the lite version:
+
+```javascript
+const mime = require('mime/lite');
+```
+
+## Mime .vs. mime-types .vs. mime-db modules
+
+For those of you wondering about the difference between these [popular] NPM modules,
+here's a brief rundown ...
+
+[`mime-db`](https://github.com/jshttp/mime-db) is "the source of
+truth" for MIME type information.  It is not an API.  Rather, it is a canonical
+dataset of mime type definitions pulled from IANA, Apache, NGINX, and custom mappings
+submitted by the Node.js community.
+
+[`mime-types`](https://github.com/jshttp/mime-types) is a thin
+wrapper around mime-db that provides an API drop-in compatible(ish) with `mime @ < v1.3.6` API.
+
+`mime` is, as of v2, a self-contained module bundled with a pre-optimized version
+of the `mime-db` dataset.  It provides a simplified API with the following characteristics:
+
+* Intelligently resolved type conflicts (See [mime-score](https://github.com/broofa/mime-score) for details)
+* Method naming consistent with industry best-practices
+* Compact footprint.  E.g. The minified+compressed sizes of the various modules:
+
+Module | Size
+--- | ---
+`mime-db`  | 18 KB
+`mime-types` | same as mime-db
+`mime` | 8 KB
+`mime/lite` | 2 KB
+
+## Mime API
+
+Both `require('mime')` and `require('mime/lite')` return instances of the MIME
+class, documented below.
+
+Note: Inputs to this API are case-insensitive.  Outputs (returned values) will
+be lowercase.
+
+### new Mime(typeMap, ... more maps)
+
+Most users of this module will not need to create Mime instances directly.
+However if you would like to create custom mappings, you may do so as follows
+...
+
+```javascript --run default
+// Require Mime class
+const Mime = require('mime/Mime');
+
+// Define mime type -> extensions map
+const typeMap = {
+  'text/abc': ['abc', 'alpha', 'bet'],
+  'text/def': ['leppard']
+};
+
+// Create and use Mime instance
+const myMime = new Mime(typeMap);
+myMime.getType('abc');            // RESULT
+myMime.getExtension('text/def');  // RESULT
+```
+
+If more than one map argument is provided, each map is `define()`ed (see below), in order.
+
+### mime.getType(pathOrExtension)
+
+Get mime type for the given path or extension.  E.g.
+
+```javascript --run default
+mime.getType('js');             // RESULT
+mime.getType('json');           // RESULT
+
+mime.getType('txt');            // RESULT
+mime.getType('dir/text.txt');   // RESULT
+mime.getType('dir\\text.txt');  // RESULT
+mime.getType('.text.txt');      // RESULT
+mime.getType('.txt');           // RESULT
+```
+
+`null` is returned in cases where an extension is not detected or recognized
+
+```javascript --run default
+mime.getType('foo/txt');        // RESULT
+mime.getType('bogus_type');     // RESULT
+```
+
+### mime.getExtension(type)
+Get extension for the given mime type.  Charset options (often included in
+Content-Type headers) are ignored.
+
+```javascript --run default
+mime.getExtension('text/plain');               // RESULT
+mime.getExtension('application/json');         // RESULT
+mime.getExtension('text/html; charset=utf8');  // RESULT
+```
+
+### mime.define(typeMap[, force = false])
+
+Define [more] type mappings.
+
+`typeMap` is a map of type -> extensions, as documented in `new Mime`, above.
+
+By default this method will throw an error if you try to map a type to an
+extension that is already assigned to another type.  Passing `true` for the
+`force` argument will suppress this behavior (overriding any previous mapping).
+
+```javascript --run default
+mime.define({'text/x-abc': ['abc', 'abcd']});
+
+mime.getType('abcd');            // RESULT
+mime.getExtension('text/x-abc')  // RESULT
+```
+
+## Command Line
+
+    mime [path_or_extension]
+
+E.g.
+
+    > mime scripts/jquery.js
+    application/javascript

node_modules/mime/src/benchmark.js

@@ -0,0 +1,26 @@
+const Benchmark = require('benchmark');
+const mime = require('..');
+const mimeLite = require('../lite');
+
+const suite = new Benchmark.Suite();
+
+const extensions = Object.keys(mime._types);
+let idx = 0;
+
+suite
+  .add('mime.getType',
+    function() {
+      mime.getType(extensions[idx++]);
+      if (idx >= extensions.length) idx = 0;
+    }
+  )
+  .add('mimeLite.getType',
+    function() {
+      mimeLite.getType(extensions[idx++]);
+      if (idx >= extensions.length) idx = 0;
+    }
+  )
+  .on('cycle', function(event) {
+    console.log(String(event.target));
+  })
+  .run();

node_modules/mime/src/build.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var mimeScore = require('mime-score');
+
+var db = require('mime-db');
+var chalk = require('chalk');
+
+var STANDARD_FACET_SCORE = 900;
+
+var byExtension = {};
+
+// Clear out any conflict extensions in mime-db
+for (var type in db) {
+  var entry = db[type];
+  entry.type = type;
+  if (!entry.extensions) continue;
+
+  entry.extensions.forEach(function(ext) {
+    var drop;
+    var keep = entry;
+    if (ext in byExtension) {
+      var e0 = entry;
+      var e1 = byExtension[ext];
+
+      e0.pri = mimeScore(e0.type, e0.source);
+      e1.pri = mimeScore(e1.type, e1.source);
+
+      drop = e0.pri < e1.pri ? e0 : e1;
+      keep = e0.pri >= e1.pri ? e0 : e1;
+
+      // Prefix lower-priority extensions with '*'
+      drop.extensions = drop.extensions.map(function(e) {return e == ext ? '*' + e : e});
+
+      console.log(
+        ext + ': Preferring ' + chalk.green(keep.type) + ' (' + keep.pri +
+        ') over ' + chalk.red(drop.type) + ' (' + drop.pri + ')' + ' for ' + ext
+      );
+    }
+
+    // Cache the hightest ranking type for this extension
+    if (keep == entry) byExtension[ext] = entry;
+  });
+}
+
+function writeTypesFile(types, path) {
+  fs.writeFileSync(path, 'module.exports = ' + JSON.stringify(types) + ';');
+}
+
+// Segregate into standard and non-standard types based on facet per
+// https://tools.ietf.org/html/rfc6838#section-3.1
+var standard = {};
+var other = {};
+
+Object.keys(db).sort().forEach(function(k) {
+  var entry = db[k];
+
+  if (entry.extensions) {
+    if (mimeScore(entry.type, entry.source) >= STANDARD_FACET_SCORE) {
+      standard[entry.type] = entry.extensions;
+    } else {
+      other[entry.type] = entry.extensions;
+    }
+  }
+});
+
+writeTypesFile(standard, path.join(__dirname, '../types', 'standard.js'));
+writeTypesFile(other, path.join(__dirname, '../types', 'other.js'));

node_modules/mime/src/test.js

@@ -0,0 +1,256 @@
+'use strict';
+
+var mime = require('..');
+var mimeTypes = require('../node_modules/mime-types');
+var assert = require('assert');
+var chalk = require('chalk');
+
+describe('class Mime', function() {
+  it('mime and mime/lite coexist', function() {
+    assert.doesNotThrow(function() {
+      require('../lite');
+    });
+  });
+
+  it('new constructor()', function() {
+    var Mime = require('../Mime');
+
+    var mime = new Mime(
+      {'text/a': ['a', 'a1']},
+      {'text/b': ['b', 'b1']}
+    );
+
+    assert.deepEqual(mime._types, {
+      a: 'text/a',
+      a1: 'text/a',
+      b: 'text/b',
+      b1: 'text/b',
+    });
+
+    assert.deepEqual(mime._extensions, {
+      'text/a': 'a',
+      'text/b': 'b',
+    });
+  });
+
+  it('define()', function() {
+    var Mime = require('../Mime');
+
+    var mime = new Mime({'text/a': ['a']}, {'text/b': ['b']});
+
+    assert.throws(function() {
+      mime.define({'text/c': ['b']});
+    });
+
+    assert.doesNotThrow(function() {
+      mime.define({'text/c': ['b']}, true);
+    });
+
+    assert.deepEqual(mime._types, {
+      a: 'text/a',
+      b: 'text/c',
+    });
+
+    assert.deepEqual(mime._extensions, {
+      'text/a': 'a',
+      'text/b': 'b',
+      'text/c': 'b',
+    });
+  });
+
+  it('define() *\'ed types', function() {
+    var Mime = require('../Mime');
+
+    var mime = new Mime(
+      {'text/a': ['*b']},
+      {'text/b': ['b']}
+    );
+
+    assert.deepEqual(mime._types, {
+      b: 'text/b',
+    });
+
+    assert.deepEqual(mime._extensions, {
+      'text/a': 'b',
+      'text/b': 'b',
+    });
+  });
+
+  it ('case-insensitive', function() {
+    var Mime = require('../Mime');
+    const mime = new Mime({
+      'TEXT/UPPER': ['UP'],
+      'text/lower': ['low'],
+    });
+
+    assert.equal(mime.getType('test.up'), 'text/upper');
+    assert.equal(mime.getType('test.UP'), 'text/upper');
+    assert.equal(mime.getType('test.low'), 'text/lower');
+    assert.equal(mime.getType('test.LOW'), 'text/lower');
+
+    assert.equal(mime.getExtension('text/upper'), 'up');
+    assert.equal(mime.getExtension('text/lower'), 'low');
+    assert.equal(mime.getExtension('TEXT/UPPER'), 'up');
+    assert.equal(mime.getExtension('TEXT/LOWER'), 'low');
+  });
+
+  it('getType()', function() {
+    // Upper/lower case
+    assert.equal(mime.getType('text.txt'), 'text/plain');
+    assert.equal(mime.getType('TEXT.TXT'), 'text/plain');
+
+    // Bare extension
+    assert.equal(mime.getType('txt'), 'text/plain');
+    assert.equal(mime.getType('.txt'), 'text/plain');
+    assert.strictEqual(mime.getType('.bogus'), null);
+    assert.strictEqual(mime.getType('bogus'), null);
+
+    // Non-sensical
+    assert.strictEqual(mime.getType(null), null);
+    assert.strictEqual(mime.getType(undefined), null);
+    assert.strictEqual(mime.getType(42), null);
+    assert.strictEqual(mime.getType({}), null);
+
+    // File paths
+    assert.equal(mime.getType('dir/text.txt'), 'text/plain');
+    assert.equal(mime.getType('dir\\text.txt'), 'text/plain');
+    assert.equal(mime.getType('.text.txt'), 'text/plain');
+    assert.equal(mime.getType('.txt'), 'text/plain');
+    assert.equal(mime.getType('txt'), 'text/plain');
+    assert.equal(mime.getType('/path/to/page.html'), 'text/html');
+    assert.equal(mime.getType('c:\\path\\to\\page.html'), 'text/html');
+    assert.equal(mime.getType('page.html'), 'text/html');
+    assert.equal(mime.getType('path/to/page.html'), 'text/html');
+    assert.equal(mime.getType('path\\to\\page.html'), 'text/html');
+    assert.strictEqual(mime.getType('/txt'), null);
+    assert.strictEqual(mime.getType('\\txt'), null);
+    assert.strictEqual(mime.getType('text.nope'), null);
+    assert.strictEqual(mime.getType('/path/to/file.bogus'), null);
+    assert.strictEqual(mime.getType('/path/to/json'), null);
+    assert.strictEqual(mime.getType('/path/to/.json'), null);
+    assert.strictEqual(mime.getType('/path/to/.config.json'), 'application/json');
+    assert.strictEqual(mime.getType('.config.json'), 'application/json');
+  });
+
+  it('getExtension()', function() {
+    assert.equal(mime.getExtension('text/html'), 'html');
+    assert.equal(mime.getExtension(' text/html'), 'html');
+    assert.equal(mime.getExtension('text/html '), 'html');
+    assert.strictEqual(mime.getExtension('application/x-bogus'), null);
+    assert.strictEqual(mime.getExtension('bogus'), null);
+    assert.strictEqual(mime.getExtension(null), null);
+    assert.strictEqual(mime.getExtension(undefined), null);
+    assert.strictEqual(mime.getExtension(42), null);
+    assert.strictEqual(mime.getExtension({}), null);
+  });
+});
+
+describe('DB', function() {
+  var diffs = [];
+
+  after(function() {
+    if (diffs.length) {
+      console.log('\n[INFO] The following inconsistencies with MDN (https://goo.gl/lHrFU6) and/or mime-types (https://github.com/jshttp/mime-types) are expected:');
+      diffs.forEach(function(d) {
+        console.warn(
+          '  ' + d[0]+ '[' + chalk.blue(d[1]) + '] = ' + chalk.red(d[2]) +
+          ', mime[' + d[1] + '] = ' + chalk.green(d[3])
+        );
+      });
+    }
+  });
+
+  it('Consistency', function() {
+    for (var ext in this.types) {
+      assert.equal(ext, this.extensions[this.types[ext]], '${ext} does not have consistent ext->type->ext mapping');
+    }
+  });
+
+  it('MDN types', function() {
+    // MDN types listed at https://goo.gl/lHrFU6
+    var MDN = {
+      aac: 'audio/aac',
+      bin: 'application/octet-stream',
+      css: 'text/css',
+      csv: 'text/csv',
+      doc: 'application/msword',
+      docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+      gif: 'image/gif',
+      html: 'text/html',
+      ico: 'image/vnd.microsoft.icon',
+      jpg: 'image/jpeg',
+      js: 'application/javascript',
+      json: 'application/json',
+      midi: 'audio/midi',
+      mjs: 'application/javascript',
+      mp3: 'audio/mpeg',
+      mpeg: 'video/mpeg',
+      oga: 'audio/ogg',
+      ogv: 'video/ogg',
+      otf: 'font/otf',
+      png: 'image/png',
+      pdf: 'application/pdf',
+      rtf: 'application/rtf',
+      svg: 'image/svg+xml',
+      swf: 'application/x-shockwave-flash',
+      tiff: 'image/tiff',
+      ttf: 'font/ttf',
+      txt: 'text/plain',
+      wav: 'audio/wav',
+      weba: 'audio/webm',
+      webm: 'video/webm',
+      webp: 'image/webp',
+      woff: 'font/woff',
+      xls: 'application/vnd.ms-excel',
+      xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+      xml: 'application/xml',
+      zip: 'application/zip',
+      '3gp': 'video/3gpp',
+    };
+
+    for (var ext in MDN) {
+      var expected = MDN[ext];
+      var actual = mime.getType(ext);
+      if (actual !== expected) diffs.push(['MDN', ext, expected, actual]);
+    }
+
+    for (var ext in mimeTypes.types) {
+      var expected = mimeTypes.types[ext];
+      var actual = mime.getType(ext);
+      if (actual !== expected) diffs.push(['mime-types', ext, expected, actual]);
+    }
+  });
+
+  it('Specific types', function() {
+    // Assortment of types we sanity check for good measure
+    assert.equal(mime.getType('html'), 'text/html');
+    assert.equal(mime.getType('js'), 'application/javascript');
+    assert.equal(mime.getType('json'), 'application/json');
+    assert.equal(mime.getType('rtf'), 'application/rtf');
+    assert.equal(mime.getType('txt'), 'text/plain');
+    assert.equal(mime.getType('xml'), 'application/xml');
+
+    assert.equal(mime.getType('wasm'), 'application/wasm');
+  });
+
+  it('Specific extensions', function() {
+    assert.equal(mime.getExtension('text/html;charset=UTF-8'), 'html');
+    assert.equal(mime.getExtension('text/HTML; charset=UTF-8'), 'html');
+    assert.equal(mime.getExtension('text/html; charset=UTF-8'), 'html');
+    assert.equal(mime.getExtension('text/html; charset=UTF-8 '), 'html');
+    assert.equal(mime.getExtension('text/html ; charset=UTF-8'), 'html');
+    assert.equal(mime.getExtension(mime._types.text), 'txt');
+    assert.equal(mime.getExtension(mime._types.htm), 'html');
+    assert.equal(mime.getExtension('application/octet-stream'), 'bin');
+    assert.equal(mime.getExtension('application/octet-stream '), 'bin');
+    assert.equal(mime.getExtension(' text/html; charset=UTF-8'), 'html');
+    assert.equal(mime.getExtension('text/html; charset=UTF-8 '), 'html');
+    assert.equal(mime.getExtension('text/html; charset=UTF-8'), 'html');
+    assert.equal(mime.getExtension('text/html ; charset=UTF-8'), 'html');
+    assert.equal(mime.getExtension('text/html;charset=UTF-8'), 'html');
+    assert.equal(mime.getExtension('text/Html;charset=UTF-8'), 'html');
+    assert.equal(mime.getExtension('unrecognized'), null);
+
+    assert.equal(mime.getExtension('text/xml'), 'xml'); // See #180
+  });
+});