", {
33 | "class" : "alert alert-danger",
34 | text : "Error reading " + f.name + ": " + e.message
35 | }));
36 | });
37 | }
38 |
39 | var files = evt.target.files;
40 | for (var i = 0; i < files.length; i++) {
41 | handleFile(files[i]);
42 | }
43 | });
44 |
45 |
--------------------------------------------------------------------------------
/bower_components/jszip/documentation/faq.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: "Frequently Asked Questions"
3 | layout: default
4 | section: main
5 | ---
6 |
7 | ### "Corrupted zip or bug: unexpected signature"
8 |
9 | If you are sure that the zip file is correct, that error often comes from a
10 | corrupted content. An ajax request, if not prepared correctly, will try to
11 | decode the binary content as a text and corrupt it. See
12 | [this page]({{site.baseurl}}/documentation/howto/read_zip.html).
13 |
14 | ### My browser crashes / becomes unresponsive / never finish the execution
15 |
16 | That happens if you try to handle to much data with the synchronous API. If
17 | possible, try the asynchronous API, see
18 | [this page]({{site.baseurl}}/documentation/limitations.html) for more informations.
19 |
20 | ### Can't read the data of [...]. Is it in a supported JavaScript type ?
21 |
22 | Or the old message:
23 |
24 | > The data of [...] is in an unsupported format
25 |
26 | The method [`file(name, data [,options])`]({{site.baseurl}}/documentation/api_jszip/file_data.html)
27 | accepts string and binary inputs for `data`.
28 |
29 | If you use an unsupported type, an object for example, you will get this error:
30 |
31 | ```js
32 | // WRONG
33 | var data = {
34 | content: new ArrayBuffer(...)
35 | };
36 | zip.file("my.data", data); // won't work, data is an object
37 |
38 | // CORRECT
39 | var data = new ArrayBuffer(...);
40 | zip.file("my.data", data); // will work, JSZip accepts ArrayBuffer
41 | ```
42 |
43 | ### My mac generates a `.cpgz` file when I try to extract the zip file
44 |
45 | MacOS Finder has a lot of bug related to zip files (the `unzip` command line
46 | tool is fine). When something goes wrong, Finder will generate this cpgz file
47 | instead of showing an error.
48 |
49 | To get a correct result, try to enable compression in `generateAsync`:
50 |
51 | ```js
52 | zip.generateAsync({
53 | type:"...",
54 | compression: "DEFLATE" // <-- here
55 | });
56 | ```
57 |
58 | Using `platform: "UNIX"` may help too.
59 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/compressedObject.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var external = require("./external");
4 | var DataWorker = require('./stream/DataWorker');
5 | var DataLengthProbe = require('./stream/DataLengthProbe');
6 | var Crc32Probe = require('./stream/Crc32Probe');
7 | var DataLengthProbe = require('./stream/DataLengthProbe');
8 |
9 | /**
10 | * Represent a compressed object, with everything needed to decompress it.
11 | * @constructor
12 | * @param {number} compressedSize the size of the data compressed.
13 | * @param {number} uncompressedSize the size of the data after decompression.
14 | * @param {number} crc32 the crc32 of the decompressed file.
15 | * @param {object} compression the type of compression, see lib/compressions.js.
16 | * @param {String|ArrayBuffer|Uint8Array|Buffer} data the compressed data.
17 | */
18 | function CompressedObject(compressedSize, uncompressedSize, crc32, compression, data) {
19 | this.compressedSize = compressedSize;
20 | this.uncompressedSize = uncompressedSize;
21 | this.crc32 = crc32;
22 | this.compression = compression;
23 | this.compressedContent = data;
24 | }
25 |
26 | CompressedObject.prototype = {
27 | /**
28 | * Create a worker to get the uncompressed content.
29 | * @return {GenericWorker} the worker.
30 | */
31 | getContentWorker : function () {
32 | var worker = new DataWorker(external.Promise.resolve(this.compressedContent))
33 | .pipe(this.compression.uncompressWorker())
34 | .pipe(new DataLengthProbe("data_length"));
35 |
36 | var that = this;
37 | worker.on("end", function () {
38 | if(this.streamInfo['data_length'] !== that.uncompressedSize) {
39 | throw new Error("Bug : uncompressed data size mismatch");
40 | }
41 | });
42 | return worker;
43 | },
44 | /**
45 | * Create a worker to get the compressed content.
46 | * @return {GenericWorker} the worker.
47 | */
48 | getCompressedWorker : function () {
49 | return new DataWorker(external.Promise.resolve(this.compressedContent))
50 | .withStreamInfo("compressedSize", this.compressedSize)
51 | .withStreamInfo("uncompressedSize", this.uncompressedSize)
52 | .withStreamInfo("crc32", this.crc32)
53 | .withStreamInfo("compression", this.compression)
54 | ;
55 | }
56 | };
57 |
58 | /**
59 | * Chain the given worker with other workers to compress the content with the
60 | * given compresion.
61 | * @param {GenericWorker} uncompressedWorker the worker to pipe.
62 | * @param {Object} compression the compression object.
63 | * @param {Object} compressionOptions the options to use when compressing.
64 | * @return {GenericWorker} the new worker compressing the content.
65 | */
66 | CompressedObject.createWorkerFrom = function (uncompressedWorker, compression, compressionOptions) {
67 | return uncompressedWorker
68 | .pipe(new Crc32Probe())
69 | .pipe(new DataLengthProbe("uncompressedSize"))
70 | .pipe(compression.compressWorker(compressionOptions))
71 | .pipe(new DataLengthProbe("compressedSize"))
72 | .withStreamInfo("compression", compression);
73 | };
74 |
75 | module.exports = CompressedObject;
76 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/compressions.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var GenericWorker = require("./stream/GenericWorker");
4 |
5 | exports.STORE = {
6 | magic: "\x00\x00",
7 | compressWorker : function (compressionOptions) {
8 | return new GenericWorker("STORE compression");
9 | },
10 | uncompressWorker : function () {
11 | return new GenericWorker("STORE decompression");
12 | }
13 | };
14 | exports.DEFLATE = require('./flate');
15 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/crc32.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var utils = require('./utils');
4 |
5 | /**
6 | * The following functions come from pako, from pako/lib/zlib/crc32.js
7 | * released under the MIT license, see pako https://github.com/nodeca/pako/
8 | */
9 |
10 | // Use ordinary array, since untyped makes no boost here
11 | function makeTable() {
12 | var c, table = [];
13 |
14 | for(var n =0; n < 256; n++){
15 | c = n;
16 | for(var k =0; k < 8; k++){
17 | c = ((c&1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));
18 | }
19 | table[n] = c;
20 | }
21 |
22 | return table;
23 | }
24 |
25 | // Create table on load. Just 255 signed longs. Not a problem.
26 | var crcTable = makeTable();
27 |
28 |
29 | function crc32(crc, buf, len, pos) {
30 | var t = crcTable, end = pos + len;
31 |
32 | crc = crc ^ (-1);
33 |
34 | for (var i = pos; i < end; i++ ) {
35 | crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF];
36 | }
37 |
38 | return (crc ^ (-1)); // >>> 0;
39 | }
40 |
41 | // That's all for the pako functions.
42 |
43 | /**
44 | * Compute the crc32 of a string.
45 | * This is almost the same as the function crc32, but for strings. Using the
46 | * same function for the two use cases leads to horrible performances.
47 | * @param {Number} crc the starting value of the crc.
48 | * @param {String} str the string to use.
49 | * @param {Number} len the length of the string.
50 | * @param {Number} pos the starting position for the crc32 computation.
51 | * @return {Number} the computed crc32.
52 | */
53 | function crc32str(crc, str, len, pos) {
54 | var t = crcTable, end = pos + len;
55 |
56 | crc = crc ^ (-1);
57 |
58 | for (var i = pos; i < end; i++ ) {
59 | crc = (crc >>> 8) ^ t[(crc ^ str.charCodeAt(i)) & 0xFF];
60 | }
61 |
62 | return (crc ^ (-1)); // >>> 0;
63 | }
64 |
65 | module.exports = function crc32wrapper(input, crc) {
66 | if (typeof input === "undefined" || !input.length) {
67 | return 0;
68 | }
69 |
70 | var isArray = utils.getTypeOf(input) !== "string";
71 |
72 | if(isArray) {
73 | return crc32(crc|0, input, input.length, 0);
74 | } else {
75 | return crc32str(crc|0, input, input.length, 0);
76 | }
77 | };
78 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/defaults.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | exports.base64 = false;
3 | exports.binary = false;
4 | exports.dir = false;
5 | exports.createFolders = true;
6 | exports.date = null;
7 | exports.compression = null;
8 | exports.compressionOptions = null;
9 | exports.comment = null;
10 | exports.unixPermissions = null;
11 | exports.dosPermissions = null;
12 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/external.js:
--------------------------------------------------------------------------------
1 | /* global Promise */
2 | 'use strict';
3 |
4 | // load the global object first:
5 | // - it should be better integrated in the system (unhandledRejection in node)
6 | // - the environment may have a custom Promise implementation (see zone.js)
7 | var ES6Promise = null;
8 | if (typeof Promise !== "undefined") {
9 | ES6Promise = Promise;
10 | } else {
11 | ES6Promise = require("lie");
12 | }
13 |
14 | /**
15 | * Let the user use/change some implementations.
16 | */
17 | module.exports = {
18 | Promise: ES6Promise
19 | };
20 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/flate.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | var USE_TYPEDARRAY = (typeof Uint8Array !== 'undefined') && (typeof Uint16Array !== 'undefined') && (typeof Uint32Array !== 'undefined');
3 |
4 | var pako = require("pako");
5 | var utils = require("./utils");
6 | var GenericWorker = require("./stream/GenericWorker");
7 |
8 | var ARRAY_TYPE = USE_TYPEDARRAY ? "uint8array" : "array";
9 |
10 | exports.magic = "\x08\x00";
11 |
12 | /**
13 | * Create a worker that uses pako to inflate/deflate.
14 | * @constructor
15 | * @param {String} action the name of the pako function to call : either "Deflate" or "Inflate".
16 | * @param {Object} options the options to use when (de)compressing.
17 | */
18 | function FlateWorker(action, options) {
19 | GenericWorker.call(this, "FlateWorker/" + action);
20 |
21 | this._pako = null;
22 | this._pakoAction = action;
23 | this._pakoOptions = options;
24 | // the `meta` object from the last chunk received
25 | // this allow this worker to pass around metadata
26 | this.meta = {};
27 | }
28 |
29 | utils.inherits(FlateWorker, GenericWorker);
30 |
31 | /**
32 | * @see GenericWorker.processChunk
33 | */
34 | FlateWorker.prototype.processChunk = function (chunk) {
35 | this.meta = chunk.meta;
36 | if (this._pako === null) {
37 | this._createPako();
38 | }
39 | this._pako.push(utils.transformTo(ARRAY_TYPE, chunk.data), false);
40 | };
41 |
42 | /**
43 | * @see GenericWorker.flush
44 | */
45 | FlateWorker.prototype.flush = function () {
46 | GenericWorker.prototype.flush.call(this);
47 | if (this._pako === null) {
48 | this._createPako();
49 | }
50 | this._pako.push([], true);
51 | };
52 | /**
53 | * @see GenericWorker.cleanUp
54 | */
55 | FlateWorker.prototype.cleanUp = function () {
56 | GenericWorker.prototype.cleanUp.call(this);
57 | this._pako = null;
58 | };
59 |
60 | /**
61 | * Create the _pako object.
62 | * TODO: lazy-loading this object isn't the best solution but it's the
63 | * quickest. The best solution is to lazy-load the worker list. See also the
64 | * issue #446.
65 | */
66 | FlateWorker.prototype._createPako = function () {
67 | this._pako = new pako[this._pakoAction]({
68 | raw: true,
69 | level: this._pakoOptions.level || -1 // default compression
70 | });
71 | var self = this;
72 | this._pako.onData = function(data) {
73 | self.push({
74 | data : data,
75 | meta : self.meta
76 | });
77 | };
78 | };
79 |
80 | exports.compressWorker = function (compressionOptions) {
81 | return new FlateWorker("Deflate", compressionOptions);
82 | };
83 | exports.uncompressWorker = function () {
84 | return new FlateWorker("Inflate", {});
85 | };
86 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/generate/index.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var compressions = require('../compressions');
4 | var ZipFileWorker = require('./ZipFileWorker');
5 |
6 | /**
7 | * Find the compression to use.
8 | * @param {String} fileCompression the compression defined at the file level, if any.
9 | * @param {String} zipCompression the compression defined at the load() level.
10 | * @return {Object} the compression object to use.
11 | */
12 | var getCompression = function (fileCompression, zipCompression) {
13 |
14 | var compressionName = fileCompression || zipCompression;
15 | var compression = compressions[compressionName];
16 | if (!compression) {
17 | throw new Error(compressionName + " is not a valid compression method !");
18 | }
19 | return compression;
20 | };
21 |
22 | /**
23 | * Create a worker to generate a zip file.
24 | * @param {JSZip} zip the JSZip instance at the right root level.
25 | * @param {Object} options to generate the zip file.
26 | * @param {String} comment the comment to use.
27 | */
28 | exports.generateWorker = function (zip, options, comment) {
29 |
30 | var zipFileWorker = new ZipFileWorker(options.streamFiles, comment, options.platform, options.encodeFileName);
31 | var entriesCount = 0;
32 | try {
33 |
34 | zip.forEach(function (relativePath, file) {
35 | entriesCount++;
36 | var compression = getCompression(file.options.compression, options.compression);
37 | var compressionOptions = file.options.compressionOptions || options.compressionOptions || {};
38 | var dir = file.dir, date = file.date;
39 |
40 | file._compressWorker(compression, compressionOptions)
41 | .withStreamInfo("file", {
42 | name : relativePath,
43 | dir : dir,
44 | date : date,
45 | comment : file.comment || "",
46 | unixPermissions : file.unixPermissions,
47 | dosPermissions : file.dosPermissions
48 | })
49 | .pipe(zipFileWorker);
50 | });
51 | zipFileWorker.entriesCount = entriesCount;
52 | } catch (e) {
53 | zipFileWorker.error(e);
54 | }
55 |
56 | return zipFileWorker;
57 | };
58 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/index.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | /**
4 | * Representation a of zip file in js
5 | * @constructor
6 | */
7 | function JSZip() {
8 | // if this constructor is used without `new`, it adds `new` before itself:
9 | if(!(this instanceof JSZip)) {
10 | return new JSZip();
11 | }
12 |
13 | if(arguments.length) {
14 | throw new Error("The constructor with parameters has been removed in JSZip 3.0, please check the upgrade guide.");
15 | }
16 |
17 | // object containing the files :
18 | // {
19 | // "folder/" : {...},
20 | // "folder/data.txt" : {...}
21 | // }
22 | this.files = {};
23 |
24 | this.comment = null;
25 |
26 | // Where we are in the hierarchy
27 | this.root = "";
28 | this.clone = function() {
29 | var newObj = new JSZip();
30 | for (var i in this) {
31 | if (typeof this[i] !== "function") {
32 | newObj[i] = this[i];
33 | }
34 | }
35 | return newObj;
36 | };
37 | }
38 | JSZip.prototype = require('./object');
39 | JSZip.prototype.loadAsync = require('./load');
40 | JSZip.support = require('./support');
41 | JSZip.defaults = require('./defaults');
42 |
43 | // TODO find a better way to handle this version,
44 | // a require('package.json').version doesn't work with webpack, see #327
45 | JSZip.version = "3.1.5";
46 |
47 | JSZip.loadAsync = function (content, options) {
48 | return new JSZip().loadAsync(content, options);
49 | };
50 |
51 | JSZip.external = require("./external");
52 | module.exports = JSZip;
53 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/license_header.js:
--------------------------------------------------------------------------------
1 | /*!
2 |
3 | JSZip v__VERSION__ - A JavaScript class for generating and reading zip files
4 |
5 |
6 | (c) 2009-2016 Stuart Knightley
7 | Dual licenced under the MIT license or GPLv3. See https://raw.github.com/Stuk/jszip/master/LICENSE.markdown.
8 |
9 | JSZip uses the library pako released under the MIT license :
10 | https://github.com/nodeca/pako/blob/master/LICENSE
11 | */
12 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/load.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | var utils = require('./utils');
3 | var external = require("./external");
4 | var utf8 = require('./utf8');
5 | var utils = require('./utils');
6 | var ZipEntries = require('./zipEntries');
7 | var Crc32Probe = require('./stream/Crc32Probe');
8 | var nodejsUtils = require("./nodejsUtils");
9 |
10 | /**
11 | * Check the CRC32 of an entry.
12 | * @param {ZipEntry} zipEntry the zip entry to check.
13 | * @return {Promise} the result.
14 | */
15 | function checkEntryCRC32(zipEntry) {
16 | return new external.Promise(function (resolve, reject) {
17 | var worker = zipEntry.decompressed.getContentWorker().pipe(new Crc32Probe());
18 | worker.on("error", function (e) {
19 | reject(e);
20 | })
21 | .on("end", function () {
22 | if (worker.streamInfo.crc32 !== zipEntry.decompressed.crc32) {
23 | reject(new Error("Corrupted zip : CRC32 mismatch"));
24 | } else {
25 | resolve();
26 | }
27 | })
28 | .resume();
29 | });
30 | }
31 |
32 | module.exports = function(data, options) {
33 | var zip = this;
34 | options = utils.extend(options || {}, {
35 | base64: false,
36 | checkCRC32: false,
37 | optimizedBinaryString: false,
38 | createFolders: false,
39 | decodeFileName: utf8.utf8decode
40 | });
41 |
42 | if (nodejsUtils.isNode && nodejsUtils.isStream(data)) {
43 | return external.Promise.reject(new Error("JSZip can't accept a stream when loading a zip file."));
44 | }
45 |
46 | return utils.prepareContent("the loaded zip file", data, true, options.optimizedBinaryString, options.base64)
47 | .then(function(data) {
48 | var zipEntries = new ZipEntries(options);
49 | zipEntries.load(data);
50 | return zipEntries;
51 | }).then(function checkCRC32(zipEntries) {
52 | var promises = [external.Promise.resolve(zipEntries)];
53 | var files = zipEntries.files;
54 | if (options.checkCRC32) {
55 | for (var i = 0; i < files.length; i++) {
56 | promises.push(checkEntryCRC32(files[i]));
57 | }
58 | }
59 | return external.Promise.all(promises);
60 | }).then(function addFiles(results) {
61 | var zipEntries = results.shift();
62 | var files = zipEntries.files;
63 | for (var i = 0; i < files.length; i++) {
64 | var input = files[i];
65 | zip.file(input.fileNameStr, input.decompressed, {
66 | binary: true,
67 | optimizedBinaryString: true,
68 | date: input.date,
69 | dir: input.dir,
70 | comment : input.fileCommentStr.length ? input.fileCommentStr : null,
71 | unixPermissions : input.unixPermissions,
72 | dosPermissions : input.dosPermissions,
73 | createFolders: options.createFolders
74 | });
75 | }
76 | if (zipEntries.zipComment.length) {
77 | zip.comment = zipEntries.zipComment;
78 | }
79 |
80 | return zip;
81 | });
82 | };
83 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/nodejs/NodejsStreamInputAdapter.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 |
3 | var utils = require('../utils');
4 | var GenericWorker = require('../stream/GenericWorker');
5 |
6 | /**
7 | * A worker that use a nodejs stream as source.
8 | * @constructor
9 | * @param {String} filename the name of the file entry for this stream.
10 | * @param {Readable} stream the nodejs stream.
11 | */
12 | function NodejsStreamInputAdapter(filename, stream) {
13 | GenericWorker.call(this, "Nodejs stream input adapter for " + filename);
14 | this._upstreamEnded = false;
15 | this._bindStream(stream);
16 | }
17 |
18 | utils.inherits(NodejsStreamInputAdapter, GenericWorker);
19 |
20 | /**
21 | * Prepare the stream and bind the callbacks on it.
22 | * Do this ASAP on node 0.10 ! A lazy binding doesn't always work.
23 | * @param {Stream} stream the nodejs stream to use.
24 | */
25 | NodejsStreamInputAdapter.prototype._bindStream = function (stream) {
26 | var self = this;
27 | this._stream = stream;
28 | stream.pause();
29 | stream
30 | .on("data", function (chunk) {
31 | self.push({
32 | data: chunk,
33 | meta : {
34 | percent : 0
35 | }
36 | });
37 | })
38 | .on("error", function (e) {
39 | if(self.isPaused) {
40 | this.generatedError = e;
41 | } else {
42 | self.error(e);
43 | }
44 | })
45 | .on("end", function () {
46 | if(self.isPaused) {
47 | self._upstreamEnded = true;
48 | } else {
49 | self.end();
50 | }
51 | });
52 | };
53 | NodejsStreamInputAdapter.prototype.pause = function () {
54 | if(!GenericWorker.prototype.pause.call(this)) {
55 | return false;
56 | }
57 | this._stream.pause();
58 | return true;
59 | };
60 | NodejsStreamInputAdapter.prototype.resume = function () {
61 | if(!GenericWorker.prototype.resume.call(this)) {
62 | return false;
63 | }
64 |
65 | if(this._upstreamEnded) {
66 | this.end();
67 | } else {
68 | this._stream.resume();
69 | }
70 |
71 | return true;
72 | };
73 |
74 | module.exports = NodejsStreamInputAdapter;
75 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/nodejs/NodejsStreamOutputAdapter.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var Readable = require('readable-stream').Readable;
4 |
5 | var utils = require('../utils');
6 | utils.inherits(NodejsStreamOutputAdapter, Readable);
7 |
8 | /**
9 | * A nodejs stream using a worker as source.
10 | * @see the SourceWrapper in http://nodejs.org/api/stream.html
11 | * @constructor
12 | * @param {StreamHelper} helper the helper wrapping the worker
13 | * @param {Object} options the nodejs stream options
14 | * @param {Function} updateCb the update callback.
15 | */
16 | function NodejsStreamOutputAdapter(helper, options, updateCb) {
17 | Readable.call(this, options);
18 | this._helper = helper;
19 |
20 | var self = this;
21 | helper.on("data", function (data, meta) {
22 | if (!self.push(data)) {
23 | self._helper.pause();
24 | }
25 | if(updateCb) {
26 | updateCb(meta);
27 | }
28 | })
29 | .on("error", function(e) {
30 | self.emit('error', e);
31 | })
32 | .on("end", function () {
33 | self.push(null);
34 | });
35 | }
36 |
37 |
38 | NodejsStreamOutputAdapter.prototype._read = function() {
39 | this._helper.resume();
40 | };
41 |
42 | module.exports = NodejsStreamOutputAdapter;
43 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/nodejsUtils.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | module.exports = {
4 | /**
5 | * True if this is running in Nodejs, will be undefined in a browser.
6 | * In a browser, browserify won't include this file and the whole module
7 | * will be resolved an empty object.
8 | */
9 | isNode : typeof Buffer !== "undefined",
10 | /**
11 | * Create a new nodejs Buffer from an existing content.
12 | * @param {Object} data the data to pass to the constructor.
13 | * @param {String} encoding the encoding to use.
14 | * @return {Buffer} a new Buffer.
15 | */
16 | newBufferFrom: function(data, encoding) {
17 | // XXX We can't use `Buffer.from` which comes from `Uint8Array.from`
18 | // in nodejs v4 (< v.4.5). It's not the expected implementation (and
19 | // has a different signature).
20 | // see https://github.com/nodejs/node/issues/8053
21 | // A condition on nodejs' version won't solve the issue as we don't
22 | // control the Buffer polyfills that may or may not be used.
23 | return new Buffer(data, encoding);
24 | },
25 | /**
26 | * Create a new nodejs Buffer with the specified size.
27 | * @param {Integer} size the size of the buffer.
28 | * @return {Buffer} a new Buffer.
29 | */
30 | allocBuffer: function (size) {
31 | if (Buffer.alloc) {
32 | return Buffer.alloc(size);
33 | } else {
34 | return new Buffer(size);
35 | }
36 | },
37 | /**
38 | * Find out if an object is a Buffer.
39 | * @param {Object} b the object to test.
40 | * @return {Boolean} true if the object is a Buffer, false otherwise.
41 | */
42 | isBuffer : function(b){
43 | return Buffer.isBuffer(b);
44 | },
45 |
46 | isStream : function (obj) {
47 | return obj &&
48 | typeof obj.on === "function" &&
49 | typeof obj.pause === "function" &&
50 | typeof obj.resume === "function";
51 | }
52 | };
53 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/readable-stream-browser.js:
--------------------------------------------------------------------------------
1 | /*
2 | * This file is used by module bundlers (browserify/webpack/etc) when
3 | * including a stream implementation. We use "readable-stream" to get a
4 | * consistent behavior between nodejs versions but bundlers often have a shim
5 | * for "stream". Using this shim greatly improve the compatibility and greatly
6 | * reduce the final size of the bundle (only one stream implementation, not
7 | * two).
8 | */
9 | module.exports = require("stream");
10 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/reader/ArrayReader.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | var DataReader = require('./DataReader');
3 | var utils = require('../utils');
4 |
5 | function ArrayReader(data) {
6 | DataReader.call(this, data);
7 | for(var i = 0; i < this.data.length; i++) {
8 | data[i] = data[i] & 0xFF;
9 | }
10 | }
11 | utils.inherits(ArrayReader, DataReader);
12 | /**
13 | * @see DataReader.byteAt
14 | */
15 | ArrayReader.prototype.byteAt = function(i) {
16 | return this.data[this.zero + i];
17 | };
18 | /**
19 | * @see DataReader.lastIndexOfSignature
20 | */
21 | ArrayReader.prototype.lastIndexOfSignature = function(sig) {
22 | var sig0 = sig.charCodeAt(0),
23 | sig1 = sig.charCodeAt(1),
24 | sig2 = sig.charCodeAt(2),
25 | sig3 = sig.charCodeAt(3);
26 | for (var i = this.length - 4; i >= 0; --i) {
27 | if (this.data[i] === sig0 && this.data[i + 1] === sig1 && this.data[i + 2] === sig2 && this.data[i + 3] === sig3) {
28 | return i - this.zero;
29 | }
30 | }
31 |
32 | return -1;
33 | };
34 | /**
35 | * @see DataReader.readAndCheckSignature
36 | */
37 | ArrayReader.prototype.readAndCheckSignature = function (sig) {
38 | var sig0 = sig.charCodeAt(0),
39 | sig1 = sig.charCodeAt(1),
40 | sig2 = sig.charCodeAt(2),
41 | sig3 = sig.charCodeAt(3),
42 | data = this.readData(4);
43 | return sig0 === data[0] && sig1 === data[1] && sig2 === data[2] && sig3 === data[3];
44 | };
45 | /**
46 | * @see DataReader.readData
47 | */
48 | ArrayReader.prototype.readData = function(size) {
49 | this.checkOffset(size);
50 | if(size === 0) {
51 | return [];
52 | }
53 | var result = this.data.slice(this.zero + this.index, this.zero + this.index + size);
54 | this.index += size;
55 | return result;
56 | };
57 | module.exports = ArrayReader;
58 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/reader/NodeBufferReader.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | var Uint8ArrayReader = require('./Uint8ArrayReader');
3 | var utils = require('../utils');
4 |
5 | function NodeBufferReader(data) {
6 | Uint8ArrayReader.call(this, data);
7 | }
8 | utils.inherits(NodeBufferReader, Uint8ArrayReader);
9 |
10 | /**
11 | * @see DataReader.readData
12 | */
13 | NodeBufferReader.prototype.readData = function(size) {
14 | this.checkOffset(size);
15 | var result = this.data.slice(this.zero + this.index, this.zero + this.index + size);
16 | this.index += size;
17 | return result;
18 | };
19 | module.exports = NodeBufferReader;
20 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/reader/StringReader.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | var DataReader = require('./DataReader');
3 | var utils = require('../utils');
4 |
5 | function StringReader(data) {
6 | DataReader.call(this, data);
7 | }
8 | utils.inherits(StringReader, DataReader);
9 | /**
10 | * @see DataReader.byteAt
11 | */
12 | StringReader.prototype.byteAt = function(i) {
13 | return this.data.charCodeAt(this.zero + i);
14 | };
15 | /**
16 | * @see DataReader.lastIndexOfSignature
17 | */
18 | StringReader.prototype.lastIndexOfSignature = function(sig) {
19 | return this.data.lastIndexOf(sig) - this.zero;
20 | };
21 | /**
22 | * @see DataReader.readAndCheckSignature
23 | */
24 | StringReader.prototype.readAndCheckSignature = function (sig) {
25 | var data = this.readData(4);
26 | return sig === data;
27 | };
28 | /**
29 | * @see DataReader.readData
30 | */
31 | StringReader.prototype.readData = function(size) {
32 | this.checkOffset(size);
33 | // this will work because the constructor applied the "& 0xff" mask.
34 | var result = this.data.slice(this.zero + this.index, this.zero + this.index + size);
35 | this.index += size;
36 | return result;
37 | };
38 | module.exports = StringReader;
39 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/reader/Uint8ArrayReader.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | var ArrayReader = require('./ArrayReader');
3 | var utils = require('../utils');
4 |
5 | function Uint8ArrayReader(data) {
6 | ArrayReader.call(this, data);
7 | }
8 | utils.inherits(Uint8ArrayReader, ArrayReader);
9 | /**
10 | * @see DataReader.readData
11 | */
12 | Uint8ArrayReader.prototype.readData = function(size) {
13 | this.checkOffset(size);
14 | if(size === 0) {
15 | // in IE10, when using subarray(idx, idx), we get the array [0x00] instead of [].
16 | return new Uint8Array(0);
17 | }
18 | var result = this.data.subarray(this.zero + this.index, this.zero + this.index + size);
19 | this.index += size;
20 | return result;
21 | };
22 | module.exports = Uint8ArrayReader;
23 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/reader/readerFor.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var utils = require('../utils');
4 | var support = require('../support');
5 | var ArrayReader = require('./ArrayReader');
6 | var StringReader = require('./StringReader');
7 | var NodeBufferReader = require('./NodeBufferReader');
8 | var Uint8ArrayReader = require('./Uint8ArrayReader');
9 |
10 | /**
11 | * Create a reader adapted to the data.
12 | * @param {String|ArrayBuffer|Uint8Array|Buffer} data the data to read.
13 | * @return {DataReader} the data reader.
14 | */
15 | module.exports = function (data) {
16 | var type = utils.getTypeOf(data);
17 | utils.checkSupport(type);
18 | if (type === "string" && !support.uint8array) {
19 | return new StringReader(data);
20 | }
21 | if (type === "nodebuffer") {
22 | return new NodeBufferReader(data);
23 | }
24 | if (support.uint8array) {
25 | return new Uint8ArrayReader(utils.transformTo("uint8array", data));
26 | }
27 | return new ArrayReader(utils.transformTo("array", data));
28 | };
29 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/signature.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | exports.LOCAL_FILE_HEADER = "PK\x03\x04";
3 | exports.CENTRAL_FILE_HEADER = "PK\x01\x02";
4 | exports.CENTRAL_DIRECTORY_END = "PK\x05\x06";
5 | exports.ZIP64_CENTRAL_DIRECTORY_LOCATOR = "PK\x06\x07";
6 | exports.ZIP64_CENTRAL_DIRECTORY_END = "PK\x06\x06";
7 | exports.DATA_DESCRIPTOR = "PK\x07\x08";
8 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/stream/ConvertWorker.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var GenericWorker = require('./GenericWorker');
4 | var utils = require('../utils');
5 |
6 | /**
7 | * A worker which convert chunks to a specified type.
8 | * @constructor
9 | * @param {String} destType the destination type.
10 | */
11 | function ConvertWorker(destType) {
12 | GenericWorker.call(this, "ConvertWorker to " + destType);
13 | this.destType = destType;
14 | }
15 | utils.inherits(ConvertWorker, GenericWorker);
16 |
17 | /**
18 | * @see GenericWorker.processChunk
19 | */
20 | ConvertWorker.prototype.processChunk = function (chunk) {
21 | this.push({
22 | data : utils.transformTo(this.destType, chunk.data),
23 | meta : chunk.meta
24 | });
25 | };
26 | module.exports = ConvertWorker;
27 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/stream/Crc32Probe.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var GenericWorker = require('./GenericWorker');
4 | var crc32 = require('../crc32');
5 | var utils = require('../utils');
6 |
7 | /**
8 | * A worker which calculate the crc32 of the data flowing through.
9 | * @constructor
10 | */
11 | function Crc32Probe() {
12 | GenericWorker.call(this, "Crc32Probe");
13 | this.withStreamInfo("crc32", 0);
14 | }
15 | utils.inherits(Crc32Probe, GenericWorker);
16 |
17 | /**
18 | * @see GenericWorker.processChunk
19 | */
20 | Crc32Probe.prototype.processChunk = function (chunk) {
21 | this.streamInfo.crc32 = crc32(chunk.data, this.streamInfo.crc32 || 0);
22 | this.push(chunk);
23 | };
24 | module.exports = Crc32Probe;
25 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/stream/DataLengthProbe.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var utils = require('../utils');
4 | var GenericWorker = require('./GenericWorker');
5 |
6 | /**
7 | * A worker which calculate the total length of the data flowing through.
8 | * @constructor
9 | * @param {String} propName the name used to expose the length
10 | */
11 | function DataLengthProbe(propName) {
12 | GenericWorker.call(this, "DataLengthProbe for " + propName);
13 | this.propName = propName;
14 | this.withStreamInfo(propName, 0);
15 | }
16 | utils.inherits(DataLengthProbe, GenericWorker);
17 |
18 | /**
19 | * @see GenericWorker.processChunk
20 | */
21 | DataLengthProbe.prototype.processChunk = function (chunk) {
22 | if(chunk) {
23 | var length = this.streamInfo[this.propName] || 0;
24 | this.streamInfo[this.propName] = length + chunk.data.length;
25 | }
26 | GenericWorker.prototype.processChunk.call(this, chunk);
27 | };
28 | module.exports = DataLengthProbe;
29 |
30 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/stream/DataWorker.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var utils = require('../utils');
4 | var GenericWorker = require('./GenericWorker');
5 |
6 | // the size of the generated chunks
7 | // TODO expose this as a public variable
8 | var DEFAULT_BLOCK_SIZE = 16 * 1024;
9 |
10 | /**
11 | * A worker that reads a content and emits chunks.
12 | * @constructor
13 | * @param {Promise} dataP the promise of the data to split
14 | */
15 | function DataWorker(dataP) {
16 | GenericWorker.call(this, "DataWorker");
17 | var self = this;
18 | this.dataIsReady = false;
19 | this.index = 0;
20 | this.max = 0;
21 | this.data = null;
22 | this.type = "";
23 |
24 | this._tickScheduled = false;
25 |
26 | dataP.then(function (data) {
27 | self.dataIsReady = true;
28 | self.data = data;
29 | self.max = data && data.length || 0;
30 | self.type = utils.getTypeOf(data);
31 | if(!self.isPaused) {
32 | self._tickAndRepeat();
33 | }
34 | }, function (e) {
35 | self.error(e);
36 | });
37 | }
38 |
39 | utils.inherits(DataWorker, GenericWorker);
40 |
41 | /**
42 | * @see GenericWorker.cleanUp
43 | */
44 | DataWorker.prototype.cleanUp = function () {
45 | GenericWorker.prototype.cleanUp.call(this);
46 | this.data = null;
47 | };
48 |
49 | /**
50 | * @see GenericWorker.resume
51 | */
52 | DataWorker.prototype.resume = function () {
53 | if(!GenericWorker.prototype.resume.call(this)) {
54 | return false;
55 | }
56 |
57 | if (!this._tickScheduled && this.dataIsReady) {
58 | this._tickScheduled = true;
59 | utils.delay(this._tickAndRepeat, [], this);
60 | }
61 | return true;
62 | };
63 |
64 | /**
65 | * Trigger a tick a schedule an other call to this function.
66 | */
67 | DataWorker.prototype._tickAndRepeat = function() {
68 | this._tickScheduled = false;
69 | if(this.isPaused || this.isFinished) {
70 | return;
71 | }
72 | this._tick();
73 | if(!this.isFinished) {
74 | utils.delay(this._tickAndRepeat, [], this);
75 | this._tickScheduled = true;
76 | }
77 | };
78 |
79 | /**
80 | * Read and push a chunk.
81 | */
82 | DataWorker.prototype._tick = function() {
83 |
84 | if(this.isPaused || this.isFinished) {
85 | return false;
86 | }
87 |
88 | var size = DEFAULT_BLOCK_SIZE;
89 | var data = null, nextIndex = Math.min(this.max, this.index + size);
90 | if (this.index >= this.max) {
91 | // EOF
92 | return this.end();
93 | } else {
94 | switch(this.type) {
95 | case "string":
96 | data = this.data.substring(this.index, nextIndex);
97 | break;
98 | case "uint8array":
99 | data = this.data.subarray(this.index, nextIndex);
100 | break;
101 | case "array":
102 | case "nodebuffer":
103 | data = this.data.slice(this.index, nextIndex);
104 | break;
105 | }
106 | this.index = nextIndex;
107 | return this.push({
108 | data : data,
109 | meta : {
110 | percent : this.max ? this.index / this.max * 100 : 0
111 | }
112 | });
113 | }
114 | };
115 |
116 | module.exports = DataWorker;
117 |
--------------------------------------------------------------------------------
/bower_components/jszip/lib/support.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | exports.base64 = true;
4 | exports.array = true;
5 | exports.string = true;
6 | exports.arraybuffer = typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined";
7 | exports.nodebuffer = typeof Buffer !== "undefined";
8 | // contains true if JSZip can read/generate Uint8Array, false otherwise.
9 | exports.uint8array = typeof Uint8Array !== "undefined";
10 |
11 | if (typeof ArrayBuffer === "undefined") {
12 | exports.blob = false;
13 | }
14 | else {
15 | var buffer = new ArrayBuffer(0);
16 | try {
17 | exports.blob = new Blob([buffer], {
18 | type: "application/zip"
19 | }).size === 0;
20 | }
21 | catch (e) {
22 | try {
23 | var Builder = self.BlobBuilder || self.WebKitBlobBuilder || self.MozBlobBuilder || self.MSBlobBuilder;
24 | var builder = new Builder();
25 | builder.append(buffer);
26 | exports.blob = builder.getBlob('application/zip').size === 0;
27 | }
28 | catch (e) {
29 | exports.blob = false;
30 | }
31 | }
32 | }
33 |
34 | try {
35 | exports.nodestream = !!require('readable-stream').Readable;
36 | } catch(e) {
37 | exports.nodestream = false;
38 | }
39 |
--------------------------------------------------------------------------------
/bower_components/jszip/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "jszip",
3 | "version": "3.1.5",
4 | "author": "Stuart Knightley ",
5 | "description": "Create, read and edit .zip files with JavaScript http://stuartk.com/jszip",
6 | "scripts": {
7 | "test": "npm run test-node && npm run test-browser",
8 | "test-node": "qunit-cli -c test/helpers/test-utils.js test/helpers/node-test-utils.js test/asserts/*.js",
9 | "test-browser": "grunt build && grunt test",
10 | "lint": "grunt jshint"
11 | },
12 | "contributors": [
13 | {
14 | "name": "Franz Buchinger"
15 | },
16 | {
17 | "name": "António Afonso"
18 | },
19 | {
20 | "name": "David Duponchel"
21 | },
22 | {
23 | "name": "yiminghe"
24 | }
25 | ],
26 | "main": "./lib/index",
27 | "browser": {
28 | "readable-stream": "./lib/readable-stream-browser.js"
29 | },
30 | "repository": {
31 | "type": "git",
32 | "url": "https://github.com/Stuk/jszip.git"
33 | },
34 | "keywords": [
35 | "zip",
36 | "deflate",
37 | "inflate"
38 | ],
39 | "devDependencies": {
40 | "grunt": "~0.4.1",
41 | "grunt-cli": "~1.1.0",
42 | "grunt-saucelabs": "8.6.2",
43 | "grunt-contrib-connect": "1.0.0",
44 | "jshint": "~2.9.1",
45 | "browserify": "~13.0.0",
46 | "grunt-browserify": "~5.0.0",
47 | "grunt-contrib-jshint": "~1.0.0",
48 | "grunt-contrib-qunit": "~1.2.0",
49 | "grunt-contrib-uglify": "~1.0.0",
50 | "phantomjs-prebuilt": "2.1.15",
51 | "jszip-utils": "~0.0.2",
52 | "package-json-versionify": "1.0.2",
53 | "qunit-cli": "~0.2.0",
54 | "qunitjs": "~1.23.0",
55 | "tmp": "0.0.28"
56 | },
57 | "dependencies": {
58 | "core-js": "~2.3.0",
59 | "es6-promise": "~3.0.2",
60 | "lie": "~3.1.0",
61 | "pako": "~1.0.2",
62 | "readable-stream": "~2.0.6"
63 | },
64 | "license": "(MIT OR GPL-3.0)"
65 | }
66 |
--------------------------------------------------------------------------------
/bower_components/skeleton/LICENSE.md:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 |
3 | Copyright (c) 2011-2014 Dave Gamache
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
--------------------------------------------------------------------------------
/bower_components/skeleton/README.md:
--------------------------------------------------------------------------------
1 | # [Skeleton](http://getskeleton.com)
2 | Skeleton is a simple, responsive boilerplate to kickstart any responsive project.
3 |
4 | Check out for documentation and details.
5 |
6 | ## Getting started
7 |
8 | There are a couple ways to download Skeleton:
9 | - [Download the zip](https://github.com/dhg/Skeleton/releases/download/2.0.4/Skeleton-2.0.4.zip)
10 | - Clone the repo: `git clone https://github.com/dhg/Skeleton.git` (Note: this is under active development, so if you're looking for stable and safe, use the zipped download)
11 |
12 |
13 | ### What's in the download?
14 |
15 | The download includes Skeleton's CSS, Normalize CSS as a reset, a sample favicon, and an index.html as a starting point.
16 |
17 | ```
18 | Skeleton/
19 | ├── index.html
20 | ├── css/
21 | │ ├── normalize.min.css
22 | │ └── skeleton.css
23 | └── images/
24 | └── favicon.ico
25 |
26 | ```
27 |
28 | ### Why it's awesome
29 |
30 | Skeleton is lightweight and simple. It styles only raw HTML elements (with a few exceptions) and provides a responsive grid. Nothing more.
31 | - Around 400 lines of CSS unminified and with comments
32 | - It's a starting point, not a UI framework
33 | - No compiling or installing...just vanilla CSS
34 |
35 |
36 | ## Browser support
37 |
38 | - Chrome latest
39 | - Firefox latest
40 | - Opera latest
41 | - Safari latest
42 | - IE latest
43 |
44 | The above list is non-exhaustive. Skeleton works perfectly with almost all older versions of the browsers above, though IE certainly has large degradation prior to IE9.
45 |
46 |
47 | ## License
48 |
49 | All parts of Skeleton are free to use and abuse under the [open-source MIT license](https://github.com/dhg/Skeleton/blob/master/LICENSE.md).
50 |
51 |
52 | ## Extensions
53 |
54 | The following are extensions to Skeleton built by the community. They are not officially supported, but all have been tested and are compatible with v2.0 (exact release noted):
55 | - [Skeleton on LESS](https://github.com/whatsnewsaes/Skeleton-less): Skeleton built with LESS for easier replacement of grid, color, and media queries. (Last update was to match v2.0.1)
56 | - [Skeleton on Sass](https://github.com/whatsnewsaes/Skeleton-Sass): Skeleton built with Sass for easier replacement of grid, color, and media queries. (Last update was to match v2.0.1)
57 |
58 | Have an extension you want to see here? Just shoot an email to hi@getskeleton.com with your extension!
59 |
60 |
61 | ## Colophon
62 |
63 | Skeleton was built using [Sublime Text 3](http://www.sublimetext.com/3) and designed with [Sketch](http://bohemiancoding.com/sketch). The typeface [Raleway](http://www.google.com/fonts/specimen/Raleway) was created by [Matt McInerney](http://matt.cc/) and [Pablo Impallari](http://www.impallari.com/). Code highlighting by Google's [Prettify library](https://code.google.com/p/google-code-prettify/). Icons in the header of the documentation are all derivative work of icons from [The Noun Project](http://thenounproject.com). [Feather](http://thenounproject.com/term/feather/22073) by Zach VanDeHey, [Pen](http://thenounproject.com/term/pen/21163) (with cap) by Ed Harrison, [Pen](http://thenounproject.com/term/pen/32847) (with clicker) by Matthew Hall, and [Watch](http://thenounproject.com/term/watch/48015) by Julien Deveaux.
64 |
65 |
66 | ## Acknowledgement
67 |
68 | Skeleton was created by [Dave Gamache](https://twitter.com/dhg) for a better web.
69 |
--------------------------------------------------------------------------------
/bower_components/skeleton/bower.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "skeleton",
3 | "version": "2.0.4",
4 | "homepage": "http://getskeleton.com/",
5 | "repository": {
6 | "type": "git",
7 | "url": "https://github.com/dhg/Skeleton"
8 | },
9 | "authors": [
10 | "Dave Gamache (http://davegamache.com/)"
11 | ],
12 | "description": "Skeleton is a dead-simple, responsive boilerplate to kickstart any responsive project.",
13 | "main": "css/skeleton.css",
14 | "keywords": [
15 | "css",
16 | "skeleton",
17 | "responsive",
18 | "boilerplate"
19 | ],
20 | "license": "MIT"
21 | }
--------------------------------------------------------------------------------
/bower_components/skeleton/images/favicon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/textileio/textile-facebook/0432ae0f89c20128900615f01a105673f0b51baa/bower_components/skeleton/images/favicon.png
--------------------------------------------------------------------------------
/bower_components/skeleton/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
7 |
8 | Your page title here :)
9 |
10 |
11 |
12 |
14 |
15 |
16 |
18 |
19 |
20 |
22 |
23 |
24 |
25 |
27 |
28 |
29 |
30 |
31 |
32 |
34 |
35 |
36 |
37 |
Basic Page
38 |
This index.html page is a placeholder with the CSS, font and favicon. It's just waiting for you to add some content! If you need some help hit up the Skeleton documentation.