WIP - add extractor, generate snippet_data

node_modules/probe-image-size/lib/parse_stream/bmp.js

@@ -0,0 +1,36 @@
+'use strict';
+
+
+var ParserStream = require('../common').ParserStream;
+var str2arr      = require('../common').str2arr;
+var sliceEq      = require('../common').sliceEq;
+
+
+var SIG_BM = str2arr('BM');
+
+
+module.exports = function () {
+  var parser = new ParserStream();
+
+  parser._bytes(26, function (data) {
+    parser._skipBytes(Infinity);
+
+    if (!sliceEq(data, 0, SIG_BM)) {
+      parser.push(null);
+      return;
+    }
+
+    parser.push({
+      width:  data.readUInt16LE(18),
+      height: data.readUInt16LE(22),
+      type: 'bmp',
+      mime: 'image/bmp',
+      wUnits: 'px',
+      hUnits: 'px'
+    });
+
+    parser.push(null);
+  });
+
+  return parser;
+};

node_modules/probe-image-size/lib/parse_stream/gif.js

@@ -0,0 +1,37 @@
+'use strict';
+
+
+var ParserStream = require('../common').ParserStream;
+var str2arr      = require('../common').str2arr;
+var sliceEq      = require('../common').sliceEq;
+
+
+var SIG_GIF87a = str2arr('GIF87a');
+var SIG_GIF89a = str2arr('GIF89a');
+
+
+module.exports = function () {
+  var parser = new ParserStream();
+
+  parser._bytes(10, function (data) {
+    parser._skipBytes(Infinity);
+
+    if (!sliceEq(data, 0, SIG_GIF87a) && !sliceEq(data, 0, SIG_GIF89a)) {
+      parser.push(null);
+      return;
+    }
+
+    parser.push({
+      width:  data.readUInt16LE(6),
+      height: data.readUInt16LE(8),
+      type: 'gif',
+      mime: 'image/gif',
+      wUnits: 'px',
+      hUnits: 'px'
+    });
+
+    parser.push(null);
+  });
+
+  return parser;
+};

node_modules/probe-image-size/lib/parse_stream/jpeg.js

@@ -0,0 +1,117 @@
+'use strict';
+
+
+var ParserStream = require('../common').ParserStream;
+
+
+// part of parseJpegMarker called after skipping initial FF
+function parseJpegMarker_afterFF(parser, callback) {
+  parser._bytes(1, function (data) {
+    var code = data[0];
+
+    if (code === 0xFF) {
+      // padding byte, skip it
+      parseJpegMarker_afterFF(parser, callback);
+      return;
+    }
+
+    // standalone markers, according to JPEG 1992,
+    // http://www.w3.org/Graphics/JPEG/itu-t81.pdf, see Table B.1
+    if ((0xD0 <= code && code <= 0xD9) || code === 0x01) {
+      callback(code, 0);
+      return;
+    }
+
+    // the rest of the unreserved markers
+    if (0xC0 <= code && code <= 0xFE) {
+      parser._bytes(2, function (length) {
+        callback(code, length.readUInt16BE(0) - 2);
+      });
+      return;
+    }
+
+    // unknown markers
+    callback();
+  });
+}
+
+
+function parseJpegMarker(parser, callback) {
+  parser._bytes(1, function (data) {
+    if (data[0] !== 0xFF) {
+      // not a JPEG marker
+      callback();
+      return;
+    }
+
+    parseJpegMarker_afterFF(parser, callback);
+  });
+}
+
+
+function getJpegSize(parser) {
+  parseJpegMarker(parser, function (code, length) {
+    if (!code || length < 0) {
+      // invalid jpeg
+      parser._skipBytes(Infinity);
+      parser.push(null);
+      return;
+    }
+
+    if (code === 0xD9 /* EOI */ || code === 0xDA /* SOS */) {
+      // end of the datastream
+      parser._skipBytes(Infinity);
+      parser.push(null);
+      return;
+    }
+
+    if (length <= 0) {
+      // e.g. empty comment
+      getJpegSize(parser);
+      return;
+    }
+
+    if (length >= 5 &&
+        (0xC0 <= code && code <= 0xCF) &&
+        code !== 0xC4 && code !== 0xC8 && code !== 0xCC) {
+
+      parser._bytes(length, function (data) {
+        parser._skipBytes(Infinity);
+
+        parser.push({
+          width:  data.readUInt16BE(3),
+          height: data.readUInt16BE(1),
+          type: 'jpg',
+          mime: 'image/jpeg',
+          wUnits: 'px',
+          hUnits: 'px'
+        });
+
+        parser.push(null);
+      });
+      return;
+    }
+
+    parser._skipBytes(length, function () {
+      getJpegSize(parser);
+    });
+  });
+}
+
+
+module.exports = function () {
+  var parser   = new ParserStream();
+
+  parser._bytes(2, function (data) {
+    if (data[0] !== 0xFF || data[1] !== 0xD8) {
+      // first marker of the file MUST be 0xFFD8
+      parser._skipBytes(Infinity);
+      parser.push(null);
+      return;
+    }
+
+    getJpegSize(parser);
+  });
+
+  return parser;
+};

node_modules/probe-image-size/lib/parse_stream/png.js

@@ -0,0 +1,44 @@
+'use strict';
+
+
+var ParserStream = require('../common').ParserStream;
+var str2arr      = require('../common').str2arr;
+var sliceEq      = require('../common').sliceEq;
+
+
+var SIG_PNG  = str2arr('\x89PNG\r\n\x1a\n');
+var SIG_IHDR = str2arr('IHDR');
+
+
+module.exports = function () {
+  var parser = new ParserStream();
+
+  parser._bytes(24, function (data) {
+    parser._skipBytes(Infinity);
+
+    // check PNG signature
+    if (!sliceEq(data, 0, SIG_PNG)) {
+      parser.push(null);
+      return;
+    }
+
+    // check that first chunk is IHDR
+    if (!sliceEq(data, 12, SIG_IHDR)) {
+      parser.push(null);
+      return;
+    }
+
+    parser.push({
+      width:  data.readUInt32BE(16),
+      height: data.readUInt32BE(20),
+      type: 'png',
+      mime: 'image/png',
+      wUnits: 'px',
+      hUnits: 'px'
+    });
+
+    parser.push(null);
+  });
+
+  return parser;
+};

node_modules/probe-image-size/lib/parse_stream/psd.js

@@ -0,0 +1,40 @@
+'use strict';
+
+
+var ParserStream = require('../common').ParserStream;
+var str2arr      = require('../common').str2arr;
+var sliceEq      = require('../common').sliceEq;
+
+
+var SIG_8BPS  = str2arr('8BPS\x00\x01');
+
+
+module.exports = function () {
+  var parser = new ParserStream();
+
+  parser._bytes(6, function (data) {
+    // signature + version
+    if (!sliceEq(data, 0, SIG_8BPS)) {
+      parser._skipBytes(Infinity);
+      parser.push(null);
+      return;
+    }
+
+    parser._bytes(16, function (data) {
+      parser._skipBytes(Infinity);
+
+      parser.push({
+        width:  data.readUInt32BE(12),
+        height: data.readUInt32BE(8),
+        type: 'psd',
+        mime: 'image/vnd.adobe.photoshop',
+        wUnits: 'px',
+        hUnits: 'px'
+      });
+
+      parser.push(null);
+    });
+  });
+
+  return parser;
+};

node_modules/probe-image-size/lib/parse_stream/svg.js

@@ -0,0 +1,188 @@
+'use strict';
+
+/* eslint-disable consistent-return */
+
+var Transform = require('stream').Transform;
+
+var STATE_IDENTIFY  = 0; // look for '<'
+var STATE_PARSE     = 1; // extract width and height from svg tag
+var STATE_IGNORE    = 2; // we got all the data we want, skip the rest
+
+// max size for pre-svg-tag comments plus svg tag itself
+var MAX_DATA_LENGTH = 65536;
+
+var SVG_HEADER_RE  = /<svg\s[^>]+>/;
+var SVG_WIDTH_RE   = /[^-]\bwidth="([^%]+?)"|[^-]\bwidth='([^%]+?)'/;
+var SVG_HEIGHT_RE  = /\bheight="([^%]+?)"|\bheight='([^%]+?)'/;
+var SVG_VIEWBOX_RE = /\bview[bB]ox="(.+?)"|\bview[bB]ox='(.+?)'/;
+var SVG_UNITS_RE   = /in$|mm$|cm$|pt$|pc$|px$|em$|ex$/;
+
+
+function isWhiteSpace(chr) {
+  return chr === 0x20 || chr === 0x09 || chr === 0x0D || chr === 0x0A;
+}
+
+// Filter NaN, Infinity, < 0
+function isFinitePositive(val) {
+  return typeof val === 'number' && isFinite(val) && val > 0;
+}
+
+function svgAttrs(str) {
+  var width   = str.match(SVG_WIDTH_RE);
+  var height  = str.match(SVG_HEIGHT_RE);
+  var viewbox = str.match(SVG_VIEWBOX_RE);
+
+  return {
+    width:   width && (width[1] || width[2]),
+    height:  height && (height[1] || height[2]),
+    viewbox: viewbox && (viewbox[1] || viewbox[2])
+  };
+}
+
+
+function units(str) {
+  if (!SVG_UNITS_RE.test(str)) return 'px';
+
+  return str.match(SVG_UNITS_RE)[0];
+}
+
+
+function parseSvg(str) {
+  if (!SVG_HEADER_RE.test(str)) return;
+
+  var attrs  = svgAttrs(str.match(SVG_HEADER_RE)[0]);
+  var width  = parseFloat(attrs.width);
+  var height = parseFloat(attrs.height);
+
+  // Extract from direct values
+
+  if (attrs.width && attrs.height) {
+    if (!isFinitePositive(width) || !isFinitePositive(height)) return;
+
+    return {
+      width:  width,
+      height: height,
+      type:   'svg',
+      mime:   'image/svg+xml',
+      wUnits: units(attrs.width),
+      hUnits: units(attrs.height)
+    };
+  }
+
+  // Extract from viewbox
+
+  var parts = (attrs.viewbox || '').split(' ');
+  var viewbox = {
+    width:  parts[2],
+    height: parts[3]
+  };
+  var vbWidth  = parseFloat(viewbox.width);
+  var vbHeight = parseFloat(viewbox.height);
+
+  if (!isFinitePositive(vbWidth) || !isFinitePositive(vbHeight)) return;
+  if (units(viewbox.width) !== units(viewbox.height)) return;
+
+  var ratio = vbWidth / vbHeight;
+
+  if (attrs.width) {
+    if (!isFinitePositive(width)) return;
+
+    return {
+      width:  width,
+      height: width / ratio,
+      type:   'svg',
+      mime:   'image/svg+xml',
+      wUnits: units(attrs.width),
+      hUnits: units(attrs.width)
+    };
+  }
+
+  if (attrs.height) {
+    if (!isFinitePositive(height)) return;
+
+    return {
+      width:  height * ratio,
+      height: height,
+      type:   'svg',
+      mime:   'image/svg+xml',
+      wUnits: units(attrs.height),
+      hUnits: units(attrs.height)
+    };
+  }
+
+  return {
+    width:  vbWidth,
+    height: vbHeight,
+    type:   'svg',
+    mime:   'image/svg+xml',
+    wUnits: units(viewbox.width),
+    hUnits: units(viewbox.height)
+  };
+}
+
+
+module.exports = function () {
+  var state    = STATE_IDENTIFY;
+  var data_len = 0;
+  var str      = '';
+
+  var parser = new Transform({
+    readableObjectMode: true,
+    transform: function transform(chunk, encoding, next) {
+      switch (state) {
+        case STATE_IDENTIFY:
+          var i = 0, max = chunk.length;
+
+          while (i < max && isWhiteSpace(chunk[i])) i++;
+
+          if (i >= max) {
+            data_len += chunk.length;
+
+            if (data_len > MAX_DATA_LENGTH) {
+              state = STATE_IGNORE;
+              parser.push(null);
+            }
+
+          } else if (chunk[i] === 0x3c /* < */) {
+            state = STATE_PARSE;
+            return transform(chunk, encoding, next);
+
+          } else {
+            state = STATE_IGNORE;
+            parser.push(null);
+          }
+
+          break;
+
+        case STATE_PARSE:
+          str += chunk.toString();
+
+          var result = parseSvg(str);
+
+          if (result) {
+            parser.push(result);
+            parser.push(null);
+            break;
+          }
+
+          data_len += chunk.length;
+
+          if (data_len > MAX_DATA_LENGTH) {
+            state = STATE_IGNORE;
+            parser.push(null);
+          }
+
+          break;
+      }
+
+      next();
+    },
+
+    flush: function () {
+      state = STATE_IGNORE;
+      parser.push(null);
+    }
+  });
+
+  return parser;
+};

node_modules/probe-image-size/lib/parse_stream/tiff.js

@@ -0,0 +1,112 @@
+'use strict';
+
+
+var ParserStream = require('../common').ParserStream;
+var str2arr      = require('../common').str2arr;
+var sliceEq      = require('../common').sliceEq;
+
+
+var SIG_1 = str2arr('II\x2A\0');
+var SIG_2 = str2arr('MM\0\x2A');
+
+
+function readUInt16(buffer, offset, is_big_endian) {
+  return is_big_endian ? buffer.readUInt16BE(offset) : buffer.readUInt16LE(offset);
+}
+
+function readUInt32(buffer, offset, is_big_endian) {
+  return is_big_endian ? buffer.readUInt32BE(offset) : buffer.readUInt32LE(offset);
+}
+
+function readIFDValue(data, data_offset, is_big_endian) {
+  var type       = readUInt16(data, data_offset + 2, is_big_endian);
+  var values     = readUInt32(data, data_offset + 4, is_big_endian);
+
+  if (values !== 1 || (type !== 3 && type !== 4)) {
+    return null;
+  }
+
+  if (type === 3) {
+    return readUInt16(data, data_offset + 8, is_big_endian);
+  }
+
+  return readUInt32(data, data_offset + 8, is_big_endian);
+}
+
+module.exports = function () {
+  var parser = new ParserStream();
+
+  // read header
+  parser._bytes(8, function (data) {
+    // check TIFF signature
+    if (!sliceEq(data, 0, SIG_1) && !sliceEq(data, 0, SIG_2)) {
+      parser._skipBytes(Infinity);
+      parser.push(null);
+      return;
+    }
+
+    var is_big_endian = (data[0] === 77 /* 'MM' */);
+    var count = readUInt32(data, 4, is_big_endian) - 8;
+
+    if (count < 0) {
+      parser._skipBytes(Infinity);
+      parser.push(null);
+      return;
+    }
+
+    function safeSkip(parser, count, callback) {
+      if (count === 0) { // parser._skipBytes throws error if count === 0
+        callback();
+        return;
+      }
+
+      parser._skipBytes(count, callback);
+    }
+
+    // skip until IFD
+    safeSkip(parser, count, function () {
+      // read number of IFD entries
+      parser._bytes(2, function (data) {
+        var ifd_size = readUInt16(data, 0, is_big_endian) * 12;
+
+        if (ifd_size <= 0) {
+          parser._skipBytes(Infinity);
+          parser.push(null);
+          return;
+        }
+
+        // read all IFD entries
+        parser._bytes(ifd_size, function (data) {
+          parser._skipBytes(Infinity);
+
+          var i, width, height, tag;
+
+          for (i = 0; i < ifd_size; i += 12) {
+            tag = readUInt16(data, i, is_big_endian);
+
+            if (tag === 256) {
+              width = readIFDValue(data, i, is_big_endian);
+            } else if (tag === 257) {
+              height = readIFDValue(data, i, is_big_endian);
+            }
+          }
+
+          if (width && height) {
+            parser.push({
+              width:  width,
+              height: height,
+              type:   'tiff',
+              mime:   'image/tiff',
+              wUnits: 'px',
+              hUnits: 'px'
+            });
+          }
+
+          parser.push(null);
+        });
+      });
+    });
+  });
+
+  return parser;
+};

node_modules/probe-image-size/lib/parse_stream/webp.js

@@ -0,0 +1,104 @@
+'use strict';
+
+/* eslint-disable no-bitwise */
+
+var ParserStream = require('../common').ParserStream;
+var str2arr      = require('../common').str2arr;
+var sliceEq      = require('../common').sliceEq;
+
+
+var SIG_RIFF    = str2arr('RIFF');
+var SIG_WEBPVP8 = str2arr('WEBPVP8');
+
+
+function parseVP8(parser) {
+  parser._bytes(14, function (data) {
+    parser._skipBytes(Infinity);
+
+    if (data[7] !== 0x9D || data[8] !== 0x01 || data[9] !== 0x2A) {
+      // bad code block signature
+      parser.push(null);
+      return;
+    }
+
+    parser.push({
+      width:  data.readUInt16LE(10) & 0x3FFF,
+      height: data.readUInt16LE(12) & 0x3FFF,
+      type:   'webp',
+      mime:   'image/webp',
+      wUnits: 'px',
+      hUnits: 'px'
+    });
+
+    parser.push(null);
+  });
+}
+
+
+function parseVP8L(parser) {
+  parser._bytes(9, function (data) {
+    parser._skipBytes(Infinity);
+
+    if (data[4] !== 0x2F) {
+      // bad code block signature
+      parser.push(null);
+      return;
+    }
+
+    var bits = data.readUInt32LE(5);
+
+    parser.push({
+      width:  (bits & 0x3FFF) + 1,
+      height: ((bits >> 14) & 0x3FFF) + 1,
+      type:   'webp',
+      mime:   'image/webp',
+      wUnits: 'px',
+      hUnits: 'px'
+    });
+
+    parser.push(null);
+  });
+}
+
+
+function parseVP8X(parser) {
+  parser._bytes(14, function (data) {
+    parser._skipBytes(Infinity);
+
+    parser.push({
+      // TODO: replace with `data.readUIntLE(8, 3) + 1`
+      //       when 0.10 support is dropped
+      width:  ((data[10] << 16) | (data[9] << 8) | data[8]) + 1,
+      height: ((data[13] << 16) | (data[12] << 8) | data[11]) + 1,
+      type:   'webp',
+      mime:   'image/webp',
+      wUnits: 'px',
+      hUnits: 'px'
+    });
+
+    parser.push(null);
+  });
+}
+
+
+module.exports = function () {
+  var parser = new ParserStream();
+
+  parser._bytes(16, function (data) {
+
+    // check /^RIFF....WEBPVP8([ LX])$/ signature
+
+    if (sliceEq(data, 0, SIG_RIFF) && sliceEq(data, 8, SIG_WEBPVP8)) {
+      switch (data[15]) {
+        case 32/*' '*/: parseVP8(parser); return;
+        case 76/* L */: parseVP8L(parser); return;
+        case 88/* X */: parseVP8X(parser); return;
+      }
+    } else {
+      parser._skipBytes(Infinity);
+      parser.push(null);
+    }
+  });
+
+  return parser;
+};