eoapi-cdk 5.4.1 → 6.0.0

package/node_modules/gulp-sourcemaps/node_modules/through2/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "through2",
+  "version": "2.0.5",
+  "description": "A tiny wrapper around Node streams2 Transform to avoid explicit subclassing noise",
+  "main": "through2.js",
+  "scripts": {
+    "test": "node test/test.js | faucet"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rvagg/through2.git"
+  },
+  "keywords": [
+    "stream",
+    "streams2",
+    "through",
+    "transform"
+  ],
+  "author": "Rod Vagg <r@va.gg> (https://github.com/rvagg)",
+  "license": "MIT",
+  "dependencies": {
+    "readable-stream": "~2.3.6",
+    "xtend": "~4.0.1"
+  },
+  "devDependencies": {
+    "bl": "~2.0.1",
+    "faucet": "0.0.1",
+    "nyc": "~13.1.0",
+    "safe-buffer": "~5.1.2",
+    "stream-spigot": "~3.0.6",
+    "tape": "~4.9.1"
+  }
+}

package/node_modules/gulp-sourcemaps/node_modules/through2/through2.js

@@ -0,0 +1,96 @@
+var Transform = require('readable-stream').Transform
+  , inherits  = require('util').inherits
+  , xtend     = require('xtend')
+
+function DestroyableTransform(opts) {
+  Transform.call(this, opts)
+  this._destroyed = false
+}
+
+inherits(DestroyableTransform, Transform)
+
+DestroyableTransform.prototype.destroy = function(err) {
+  if (this._destroyed) return
+  this._destroyed = true
+  
+  var self = this
+  process.nextTick(function() {
+    if (err)
+      self.emit('error', err)
+    self.emit('close')
+  })
+}
+
+// a noop _transform function
+function noop (chunk, enc, callback) {
+  callback(null, chunk)
+}
+
+
+// create a new export function, used by both the main export and
+// the .ctor export, contains common logic for dealing with arguments
+function through2 (construct) {
+  return function (options, transform, flush) {
+    if (typeof options == 'function') {
+      flush     = transform
+      transform = options
+      options   = {}
+    }
+
+    if (typeof transform != 'function')
+      transform = noop
+
+    if (typeof flush != 'function')
+      flush = null
+
+    return construct(options, transform, flush)
+  }
+}
+
+
+// main export, just make me a transform stream!
+module.exports = through2(function (options, transform, flush) {
+  var t2 = new DestroyableTransform(options)
+
+  t2._transform = transform
+
+  if (flush)
+    t2._flush = flush
+
+  return t2
+})
+
+
+// make me a reusable prototype that I can `new`, or implicitly `new`
+// with a constructor call
+module.exports.ctor = through2(function (options, transform, flush) {
+  function Through2 (override) {
+    if (!(this instanceof Through2))
+      return new Through2(override)
+
+    this.options = xtend(options, override)
+
+    DestroyableTransform.call(this, this.options)
+  }
+
+  inherits(Through2, DestroyableTransform)
+
+  Through2.prototype._transform = transform
+
+  if (flush)
+    Through2.prototype._flush = flush
+
+  return Through2
+})
+
+
+module.exports.obj = through2(function (options, transform, flush) {
+  var t2 = new DestroyableTransform(xtend({ objectMode: true, highWaterMark: 16 }, options))
+
+  t2._transform = transform
+
+  if (flush)
+    t2._flush = flush
+
+  return t2
+})

package/node_modules/gulp-sourcemaps/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "gulp-sourcemaps",
+  "version": "1.12.1",
+  "description": "Source map support for Gulp.js",
+  "homepage": "http://github.com/floridoo/gulp-sourcemaps",
+  "repository": "git://github.com/floridoo/gulp-sourcemaps.git",
+  "main": "index.js",
+  "scripts": {
+    "lint": "jshint ./src/**/*.js test/*.js",
+    "test": "npm run lint && faucet test/*.js $@",
+    "tap": "tape test/*.js",
+    "cover": "istanbul cover --dir reports/coverage tape \"test/*.js\"",
+    "coveralls": "istanbul cover tape \"test/*.js\" --report lcovonly && cat ./coverage/lcov.info | coveralls && rm -rf ./coverage",
+    "serve": "http-server",
+    "test:int": "rm -rf ./tmp && tape ./test/integration.js"
+  },
+  "keywords": [
+    "gulpplugin",
+    "gulp",
+    "source maps",
+    "sourcemaps"
+  ],
+  "author": "Florian Reiterer <me@florianreiterer.com>",
+  "license": "ISC",
+  "dependencies": {
+    "@gulp-sourcemaps/map-sources": "1.X",
+    "acorn": "4.X",
+    "convert-source-map": "1.X",
+    "css": "2.X",
+    "debug-fabulous": "0.0.X",
+    "detect-newline": "2.X",
+    "graceful-fs": "4.X",
+    "source-map": "~0.6.0",
+    "strip-bom": "2.X",
+    "through2": "2.X",
+    "vinyl": "1.X"
+  },
+  "devDependencies": {
+    "bootstrap": "3.3.7",
+    "coveralls": "2.X",
+    "faucet": "0.0.X",
+    "gulp": "3.X",
+    "gulp-concat": "2.X",
+    "gulp-if": "2.0.2",
+    "gulp-less": "3.3.0",
+    "gulp-load-plugins": "1.X",
+    "hook-std": "0.2.X",
+    "http-server": "0.9.0",
+    "istanbul": "0.X",
+    "jshint": "2.X",
+    "lodash": "4.17.4",
+    "mississippi": "^1.3.0",
+    "object-assign": "^4.1.0",
+    "tape": "4.X",
+    "yargs": "6.6.0"
+  },
+  "files": [
+    "index.js",
+    "src"
+  ],
+  "engines": {
+    "node": ">=0.10.0"
+  }
+}

package/node_modules/gulp-sourcemaps/src/init/index.internals.js

@@ -0,0 +1,122 @@
+'use strict';
+
+var utils = require('../utils');
+var PLUGIN_NAME = utils.PLUGIN_NAME;
+var makeDebug = require('debug-fabulous')();
+var convert = require('convert-source-map');
+var stripBom = require('strip-bom');
+var urlRegex = utils.urlRegex;
+var fs = require('graceful-fs');
+var path = require('path');
+var unixStylePath = utils.unixStylePath;
+
+module.exports = function(options, file, fileContent) {
+
+  function loadMaps() {
+
+    var sources = {
+      path: '',
+      map: null,
+      content: fileContent,
+      preExistingComment: null
+    };
+
+    _getInlineSources(sources);
+    if (!sources.map) // ahh not inline, so try file
+      _getFileSources(sources);
+
+    _fixSources(sources);
+
+    return sources;
+  }
+
+  function _fixSources(sources) {
+    var debug = makeDebug(PLUGIN_NAME + ':init:internals:loadMaps:_fixSources');
+
+    // fix source paths and sourceContent for imported source map
+    if (sources.map) {
+      sources.map.sourcesContent = sources.map.sourcesContent || [];
+      sources.map.sources.forEach(function(source, i) {
+        if (source.match(urlRegex)) {
+          sources.map.sourcesContent[i] = sources.map.sourcesContent[i] || null;
+          return;
+        }
+        var absPath = path.resolve(sources.path, source);
+        sources.map.sources[i] = unixStylePath(path.relative(file.base, absPath));
+
+        if (!sources.map.sourcesContent[i]) {
+          var sourceContent = null;
+          if (sources.map.sourceRoot) {
+            if (sources.map.sourceRoot.match(urlRegex)) {
+              sources.map.sourcesContent[i] = null;
+              return;
+            }
+            absPath = path.resolve(sources.path, sources.map.sourceRoot, source);
+          }
+
+          // if current file: use content
+          if (absPath === file.path) {
+            sourceContent = sources.content;
+          } else { //attempt load content from file
+            try {
+              debug(utils.logCb('No source content for "' + source + '". Loading from file.'));
+              sourceContent = stripBom(fs.readFileSync(absPath, 'utf8'));
+            } catch (e) {
+              debug(utils.logCb('warn: source file not found: ' + absPath));
+            }
+          }
+          sources.map.sourcesContent[i] = sourceContent;
+        }
+
+      });
+      // remove source map comment from source
+      file.contents = new Buffer(sources.content, 'utf8');
+    }
+
+  }
+
+  function _getInlineSources(sources) {
+    var debug = makeDebug(PLUGIN_NAME + ':init:internals:loadMaps:_getInlineSources');
+
+    sources.preExistingComment = utils.getInlinePreExisting(sources.content);
+    // Try to read inline source map
+    sources.map = convert.fromSource(sources.content, options.largeFile);
+
+    if (!sources.map)
+      return sources;
+
+    sources.map = sources.map.toObject();
+    // sources in map are relative to the source file
+    sources.path = path.dirname(file.path);
+    if (!options.largeFile) {
+      debug('comment REMOVED');
+      sources.content = convert.removeComments(sources.content);
+    }
+  }
+
+  function _getFileSources(sources) {
+    // look for source map comment referencing a source map file
+    var mapComment = convert.mapFileCommentRegex.exec(sources.content);
+
+    var mapFile;
+    if (mapComment) {
+      sources.preExistingComment = mapComment[1] || mapComment[2];
+      mapFile = path.resolve(path.dirname(file.path), sources.preExistingComment);
+      sources.content = convert.removeMapFileComments(sources.content);
+      // if no comment try map file with same name as source file
+    } else {
+      mapFile = file.path + '.map';
+    }
+
+    // sources in external map are relative to map file
+    sources.path = path.dirname(mapFile);
+
+    try {
+      sources.map = JSON.parse(stripBom(fs.readFileSync(mapFile, 'utf8')));
+    } catch (e) {} //should we really swallow this error?
+  }
+
+  return {
+    loadMaps: loadMaps
+  };
+};

package/node_modules/gulp-sourcemaps/src/init/index.js

@@ -0,0 +1,141 @@
+'use strict';
+var utils = require('../utils'),
+  unixStylePath = utils.unixStylePath,
+  PLUGIN_NAME = utils.PLUGIN_NAME,
+  through = require('through2'),
+  path = require('path'),
+  acorn = require('acorn'),
+  SourceMapGenerator = require('source-map').SourceMapGenerator,
+  css = require('css'),
+  initInternals = require('./index.internals');
+
+/**
+ * Initialize source mapping chain
+ */
+function init(options) {
+  var debug = require('debug-fabulous')()(PLUGIN_NAME + ':init');
+
+  function sourceMapInit(file, encoding, callback) {
+    /*jshint validthis:true */
+
+    // pass through if file is null or already has a source map
+    if (file.isNull() || file.sourceMap) {
+      this.push(file);
+      return callback();
+    }
+
+    if (file.isStream()) {
+      return callback(new Error(PLUGIN_NAME + '-init: Streaming not supported'));
+    }
+
+    if (options === undefined) {
+      options = {};
+    }
+    debug(function() {
+      return options;
+    });
+
+    var fileContent = file.contents.toString();
+    var sourceMap, preExistingComment;
+    var internals = initInternals(options, file, fileContent);
+
+    if (options.loadMaps) {
+      var result = internals.loadMaps();
+      sourceMap = result.map;
+      fileContent = result.content;
+      preExistingComment = result.preExistingComment;
+    }
+
+    if (!sourceMap && options.identityMap) {
+      debug(function() {
+        return 'identityMap';
+      });
+      var fileType = path.extname(file.path);
+      var source = unixStylePath(file.relative);
+      var generator = new SourceMapGenerator({file: source});
+
+      if (fileType === '.js') {
+        var tokenizer = acorn.tokenizer(fileContent, {locations: true});
+        while (true) {
+          var token = tokenizer.getToken();
+          if (token.type.label === "eof")
+            break;
+          var mapping = {
+            original: token.loc.start,
+            generated: token.loc.start,
+            source: source
+          };
+          if (token.type.label === 'name') {
+            mapping.name = token.value;
+          }
+          generator.addMapping(mapping);
+        }
+        generator.setSourceContent(source, fileContent);
+        sourceMap = generator.toJSON();
+
+      } else if (fileType === '.css') {
+        debug('css');
+        var ast = css.parse(fileContent, {silent: true});
+        debug(function() {
+          return ast;
+        });
+        var registerTokens = function(ast) {
+          if (ast.position) {
+            generator.addMapping({original: ast.position.start, generated: ast.position.start, source: source});
+          }
+
+          function logAst(key, ast) {
+            debug(function() {
+              return 'key: ' + key;
+            });
+            debug(function() {
+              return ast[key];
+            });
+          }
+
+          for (var key in ast) {
+            logAst(key, ast);
+            if (key !== "position") {
+              if (Object.prototype.toString.call(ast[key]) === '[object Object]') {
+                registerTokens(ast[key]);
+              } else if (Array.isArray(ast[key])) {
+                debug(function() {
+                  return "@@@@ ast[key] isArray @@@@";
+                });
+                for (var i = 0; i < ast[key].length; i++) {
+                  registerTokens(ast[key][i]);
+                }
+              }
+            }
+          }
+        };
+        registerTokens(ast);
+        generator.setSourceContent(source, fileContent);
+        sourceMap = generator.toJSON();
+      }
+    }
+
+    if (!sourceMap) {
+      // Make an empty source map
+      sourceMap = {
+        version: 3,
+        names: [],
+        mappings: '',
+        sources: [unixStylePath(file.relative)],
+        sourcesContent: [fileContent]
+      };
+    }
+    else if(preExistingComment !== null && typeof preExistingComment !== 'undefined')
+      sourceMap.preExistingComment = preExistingComment;
+
+    sourceMap.file = unixStylePath(file.relative);
+    file.sourceMap = sourceMap;
+
+    this.push(file);
+    callback();
+  }
+
+  return through.obj(sourceMapInit);
+}
+
+module.exports = init;

package/node_modules/gulp-sourcemaps/src/utils.js

@@ -0,0 +1,81 @@
+'use strict';
+var path = require('path'),
+  detectNewline = require('detect-newline');
+
+function unixStylePath(filePath) {
+  return filePath.split(path.sep).join('/');
+}
+
+var PLUGIN_NAME = require('../package.json').name;
+
+var urlRegex = /^(https?|webpack(-[^:]+)?):\/\//;
+
+var debug = require('debug-fabulous')()(PLUGIN_NAME + ':utils');
+
+/*
+So reusing the same ref for a regex (with global (g)) is from a poor decision in js.
+See http://stackoverflow.com/questions/10229144/bug-with-regexp-in-javascript-when-do-global-search
+
+So we either need to use a new instance of a regex everywhere.
+*/
+var sourceMapUrlRegEx = function(){ return /\/\/\# sourceMappingURL\=.*/g;};
+
+
+var getCommentFormatter = function (file) {
+  var extension = file.relative.split('.').pop(),
+    fileContents =  file.contents.toString(),
+    newline =  detectNewline.graceful(fileContents || ''),
+    commentFormatter = function(url) {
+      return '';
+    };
+
+  if (file.sourceMap.preExistingComment){
+    debug(logCb('preExistingComment commentFormatter'));
+    commentFormatter = function(url) {
+      return "//# sourceMappingURL=" + url + newline;
+    };
+    return commentFormatter;
+  }
+
+  switch (extension) {
+    case 'css':
+      debug(logCb('css commentFormatter'));
+      commentFormatter = function(url) {
+        return newline + "/*# sourceMappingURL=" + url + " */" + newline;
+      };
+      break;
+    case 'js':
+      debug(logCb('js commentFormatter'));
+      commentFormatter = function(url) {
+        return newline + "//# sourceMappingURL=" + url + newline;
+      };
+      break;
+    default:
+      debug(logCb('unknown commentFormatter'));
+  }
+
+  return commentFormatter;
+};
+
+var getInlinePreExisting = function(fileContent){
+  if(sourceMapUrlRegEx().test(fileContent)){
+    debug(logCb('has preExisting'));
+    return fileContent.match(sourceMapUrlRegEx())[0];
+  }
+};
+
+function logCb(toLog){
+  return function() {
+    return toLog;
+  };
+}
+
+module.exports = {
+  unixStylePath: unixStylePath,
+  PLUGIN_NAME: PLUGIN_NAME,
+  urlRegex: urlRegex,
+  sourceMapUrlRegEx: sourceMapUrlRegEx,
+  getCommentFormatter: getCommentFormatter,
+  getInlinePreExisting: getInlinePreExisting,
+  logCb: logCb
+};