less-execjs 2.6.0.3

data/lib/less/js/image-size/lib/types/png.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var pngSignature = 'PNG\r\n\x1a\n';
+function isPNG (buffer) {
+  if (pngSignature === buffer.toString('ascii', 1, 8)) {
+    if ('IHDR' !== buffer.toString('ascii', 12, 16)) {
+      throw new TypeError('invalid png');
+    }
+    return true;
+  }
+}
+
+function calculate (buffer) {
+  return {
+    'width': buffer.readUInt32BE(16),
+    'height': buffer.readUInt32BE(20)
+  };
+}
+
+module.exports = {
+  'detect': isPNG,
+  'calculate': calculate
+};

data/lib/less/js/image-size/lib/types/psd.js

@@ -0,0 +1,17 @@
+'use strict';
+
+function isPSD (buffer) {
+  return ('8BPS' === buffer.toString('ascii', 0, 4));
+}
+
+function calculate (buffer) {
+  return {
+    'width': buffer.readUInt32BE(18),
+    'height': buffer.readUInt32BE(14)
+  };
+}
+
+module.exports = {
+  'detect': isPSD,
+  'calculate': calculate
+};

data/lib/less/js/image-size/lib/types/svg.js

@@ -0,0 +1,78 @@
+'use strict';
+
+var svgReg = /<svg[^>]+[^>]*>/;
+function isSVG (buffer) {
+  return svgReg.test(buffer);
+}
+
+var extractorRegExps = {
+  'root': /<svg\s[^>]+>/,
+  'width': /\bwidth=(['"])([^%]+?)\1/,
+  'height': /\bheight=(['"])([^%]+?)\1/,
+  'viewbox': /\bviewBox=(['"])(.+?)\1/
+};
+
+function parseViewbox (viewbox) {
+  var bounds = viewbox.split(' ');
+  return {
+    'width': parseInt(bounds[2], 10),
+    'height': parseInt(bounds[3], 10)
+  };
+}
+
+function parseAttributes (root) {
+  var width = root.match(extractorRegExps.width);
+  var height = root.match(extractorRegExps.height);
+  var viewbox = root.match(extractorRegExps.viewbox);
+  return {
+    'width': width && parseInt(width[2], 10),
+    'height': height && parseInt(height[2], 10),
+    'viewbox': viewbox && parseViewbox(viewbox[2])
+  };
+}
+
+function calculateByDimensions (attrs) {
+  return {
+    'width': attrs.width,
+    'height': attrs.height
+  };
+}
+
+function calculateByViewbox (attrs) {
+  var ratio = attrs.viewbox.width / attrs.viewbox.height;
+  if (attrs.width) {
+    return {
+      'width': attrs.width,
+      'height': Math.floor(attrs.width / ratio)
+    };
+  }
+  if (attrs.height) {
+    return {
+      'width': Math.floor(attrs.height * ratio),
+      'height': attrs.height
+    };
+  }
+  return {
+    'width': attrs.viewbox.width,
+    'height': attrs.viewbox.height
+  };
+}
+
+function calculate (buffer) {
+  var root = buffer.toString('utf8').match(extractorRegExps.root);
+  if (root) {
+    var attrs = parseAttributes(root[0]);
+    if (attrs.width && attrs.height) {
+      return calculateByDimensions(attrs);
+    }
+    if (attrs.viewbox) {
+      return calculateByViewbox(attrs);
+    }
+  }
+  throw new TypeError('invalid svg');
+}
+
+module.exports = {
+  'detect': isSVG,
+  'calculate': calculate
+};

data/lib/less/js/image-size/lib/types/tiff.js

@@ -0,0 +1,118 @@
+'use strict';
+
+// based on http://www.compix.com/fileformattif.htm
+// TO-DO: support big-endian as well
+
+var fs = require('fs');
+var readUInt = require('../readUInt');
+
+function isTIFF (buffer) {
+  var hex4 = buffer.toString('hex', 0, 4);
+  return ('49492a00' === hex4 || '4d4d002a' === hex4);
+}
+
+// Read IFD (image-file-directory) into a buffer
+function readIFD (buffer, filepath, isBigEndian) {
+
+  var ifdOffset = readUInt(buffer, 32, 4, isBigEndian);
+
+  // read only till the end of the file
+  var bufferSize = 1024;
+  var fileSize = fs.statSync(filepath).size;
+  if (ifdOffset + bufferSize > fileSize) {
+    bufferSize = fileSize - ifdOffset - 10;
+  }
+
+  // populate the buffer
+  var endBuffer = new Buffer(bufferSize);
+  var descriptor = fs.openSync(filepath, 'r');
+  fs.readSync(descriptor, endBuffer, 0, bufferSize, ifdOffset);
+
+  // var ifdLength = readUInt(endBuffer, 16, 0, isBigEndian);
+  var ifdBuffer = endBuffer.slice(2); //, 2 + 12 * ifdLength);
+  return ifdBuffer;
+}
+
+// TIFF values seem to be messed up on Big-Endian, this helps
+function readValue (buffer, isBigEndian) {
+  var low = readUInt(buffer, 16, 8, isBigEndian);
+  var high = readUInt(buffer, 16, 10, isBigEndian);
+  return (high << 16) + low;
+}
+
+// move to the next tag
+function nextTag (buffer) {
+  if (buffer.length > 24) {
+    return buffer.slice(12);
+  }
+}
+
+// Extract IFD tags from TIFF metadata
+function extractTags (buffer, isBigEndian) {
+  var tags = {};
+  var code, type, length;
+
+  while (buffer && buffer.length) {
+    code = readUInt(buffer, 16, 0, isBigEndian);
+    type = readUInt(buffer, 16, 2, isBigEndian);
+    length = readUInt(buffer, 32, 4, isBigEndian);
+
+    // 0 means end of IFD
+    if (code === 0) {
+      break;
+    } else {
+      // 256 is width, 257 is height
+      // if (code === 256 || code === 257) {
+      if (length === 1 && type === 3) {
+        tags[code] = readValue(buffer, isBigEndian);
+      }
+
+      // move to the next tag
+      buffer = nextTag(buffer);
+    }
+  }
+  return tags;
+}
+
+// Test if the TIFF is Big Endian or Little Endian
+function determineEndianness (buffer) {
+  var signature = buffer.toString('ascii', 0, 2);
+  if ('II' === signature) {
+    return 'LE';
+  } else if ('MM' === signature) {
+    return 'BE';
+  }
+}
+
+function calculate (buffer, filepath) {
+
+  if (!filepath) {
+    throw new TypeError('Tiff doesn\'t support buffer');
+  }
+
+  // Determine BE/LE
+  var isBigEndian = determineEndianness(buffer) === 'BE';
+
+  // read the IFD
+  var ifdBuffer = readIFD(buffer, filepath, isBigEndian);
+
+  // extract the tags from the IFD
+  var tags = extractTags(ifdBuffer, isBigEndian);
+
+  var width = tags[256];
+  var height = tags[257];
+
+  if (!width || !height) {
+    throw new TypeError('Invalid Tiff, missing tags');
+  }
+
+  return {
+    'width': width,
+    'height': height
+  };
+}
+
+module.exports = {
+  'detect': isTIFF,
+  'calculate': calculate
+};

data/lib/less/js/image-size/lib/types/webp.js

@@ -0,0 +1,51 @@
+'use strict';
+
+// based on https://developers.google.com/speed/webp/docs/riff_container
+
+function isWebP (buffer) {
+  var riffHeader = 'RIFF' === buffer.toString('ascii', 0, 4);
+  var webpHeader = 'WEBP' === buffer.toString('ascii', 8, 12);
+  var vp8Header  = 'VP8'  === buffer.toString('ascii', 12, 15);
+  return (riffHeader && webpHeader && vp8Header);
+}
+
+function calculate (buffer) {
+
+  var chunkHeader = buffer.toString('ascii', 12, 16);
+  buffer = buffer.slice(20, 30);
+
+  // Lossless webp stream signature
+  if (chunkHeader === 'VP8 ' && buffer[0] !== 0x2f) {
+    return calculateLossy(buffer);
+  }
+
+  // Lossy webp stream signature
+  var signature = buffer.toString('hex', 3, 6);
+  if (chunkHeader === 'VP8L' && signature !== '9d012a') {
+    return calculateLossless(buffer);
+  }
+
+  return false;
+}
+
+function calculateLossless (buffer) {
+  return {
+    'width': 1 + (((buffer[2] & 0x3F) << 8) | buffer[1]),
+    'height': 1 + (((buffer[4] & 0xF) << 10) | (buffer[3] << 2) |
+                  ((buffer[2] & 0xC0) >> 6))
+  };
+}
+
+function calculateLossy (buffer) {
+  // `& 0x3fff` returns the last 14 bits
+  // TO-DO: include webp scaling in the calculations
+  return {
+    'width': buffer.readInt16LE(6) & 0x3fff,
+    'height': buffer.readInt16LE(8) & 0x3fff
+  };
+}
+
+module.exports = {
+  'detect': isWebP,
+  'calculate': calculate
+};

data/lib/less/js/image-size/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "image-size",
+  "version": "0.4.0",
+  "description": "get dimensions of any image file",
+  "main": "lib/index.js",
+  "files": [
+    "bin",
+    "lib"
+  ],
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "bin": {
+    "image-size": "bin/image-size.js"
+  },
+  "scripts": {
+    "pretest": "jshint",
+    "test": "mocha specs",
+    "coverage": "istanbul cover _mocha specs"
+  },
+  "repository": "image-size/image-size",
+  "keywords": [
+    "image",
+    "size",
+    "dimensions",
+    "resolution",
+    "width",
+    "height",
+    "png",
+    "jpeg",
+    "bmp",
+    "gif",
+    "psd",
+    "tiff",
+    "webp",
+    "svg"
+  ],
+  "author": "netroy <aditya@netroy.in> (http://netroy.in/)",
+  "license": "MIT",
+  "devDependencies": {
+    "escomplex-js": "^1.2.0",
+    "expect.js": "^0.3.1",
+    "glob": "^6.0.1",
+    "istanbul": "^0.4.0",
+    "jshint": "^2.8.0",
+    "mocha": "^2.3.4",
+    "sinon": "^1.17.2"
+  }
+}

data/lib/less/js/image-size/specs/.jshintrc

@@ -0,0 +1,9 @@
+{
+  "predef": [
+    "module",
+    "require",
+    "describe",
+    "beforeEach",
+    "it"
+  ]
+}

data/lib/less/js/image-size/specs/complexity.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var esj = require('escomplex-js');
+var expect = require('expect.js');
+var glob = require('glob');
+
+var path = require('path');
+var fs = require('fs');
+
+var options = {
+  'max_complexity': 6,
+  'max_cyclomatic_density': 110,
+  'max_dependencies': 10,
+  'maintainability': 100
+};
+
+describe('Code complexity', function () {
+  // find all source files
+  var codeFiles = glob.sync('lib/**/*.js');
+  // loop through them
+  codeFiles.forEach(function (file) {
+
+    describe(file, function () {
+      // get the absolute path
+      file = path.resolve(file);
+      // read the file
+      var code = fs.readFileSync(file, 'utf-8');
+
+      // calculate the complexity
+      var analysis = esj.analyse(code);
+
+      // Halstead
+      // TO-DO: analysis.aggregate.halstead
+
+      // Complexity
+      describe('functions', function () {
+        var fns = analysis.functions || [];
+        fns.forEach(function (fn) {
+          it(fn.name, function () {
+            // TO-DO: add checks on fn.halstead
+            expect(fn.cyclomatic).to.be.lessThan(options.max_complexity);
+            expect(fn.cyclomaticDensity).to.be.lessThan(options.max_cyclomatic_density);
+          });
+        });
+      });
+
+      // prevent too many dependencies
+      it('dependencies', function () {
+        expect(analysis.dependencies.length).to.be.lessThan(options.max_dependencies);
+      });
+
+      // keep functions maintainable
+      it('maintainability', function () {
+        expect(analysis.maintainability).to.be.greaterThan(options.maintainability);
+      });
+    });
+  });
+});

data/lib/less/js/image-size/specs/fs-close.spec.js

@@ -0,0 +1,61 @@
+'use strict';
+
+var expect = require('expect.js');
+var sinon = require('sinon');
+var fs = require('fs');
+
+var imageSize = require('..');
+
+describe('after done reading from files', function () {
+
+  var oldOpen = fs.open;
+  function readFromClosed (descriptor) {
+    fs.readSync(descriptor, new Buffer(1), 0, 1, 0);
+  }
+
+  describe('should close the file descriptor', function () {
+
+    it('async', function (done) {
+
+      var descriptor;
+      var oldOpen = fs.open;
+      fs.open = sinon.spy(function (path, mode, callback) {
+        oldOpen.call(fs, path, mode, function (err, d) {
+          descriptor = d;
+          callback(err, d);
+        });
+      });
+
+      imageSize('specs/images/valid/jpg/large.jpg', function () {
+
+        expect(readFromClosed.bind(null, descriptor)).to.throwException(function (e) {
+          expect(e.code).to.equal('EBADF');
+          expect(e).to.be.an(Error);
+          expect(e.message).to.match(/bad file descriptor/);
+        });
+
+        fs.open = oldOpen;
+        done();
+      });
+    });
+
+    it('sync', function () {
+      var descriptor;
+      var oldOpen = fs.openSync;
+      fs.openSync = sinon.spy(function (path, mode) {
+        descriptor = oldOpen.call(fs, path, mode);
+        return descriptor;
+      });
+
+      imageSize('specs/images/valid/jpg/large.jpg');
+
+      expect(readFromClosed.bind(null, descriptor)).to.throwException(function (e) {
+        expect(e.code).to.equal('EBADF');
+        expect(e).to.be.an(Error);
+        expect(e.message).to.match(/bad file descriptor/);
+      });
+
+      fs.openSync = oldOpen;
+    });
+  });
+});