feat: ✨ Created a mini nodeJS server with NewMan for testing without PostMan GUI.

This will mimic a run in a CD/CI environment or docker container.

node_modules/faker/lib/address.js

@@ -0,0 +1,412 @@
+/**
+ *
+ * @namespace faker.address
+ */
+function Address (faker) {
+  var f = faker.fake,
+    Helpers = faker.helpers;
+
+  /**
+   * Generates random zipcode from format. If format is not specified, the
+   * locale's zip format is used.
+   *
+   * @method faker.address.zipCode
+   * @param {String} format
+   */
+  this.zipCode = function(format) {
+    // if zip format is not specified, use the zip format defined for the locale
+    if (typeof format === 'undefined') {
+      var localeFormat = faker.definitions.address.postcode;
+      if (typeof localeFormat === 'string') {
+        format = localeFormat;
+      } else {
+        format = faker.random.arrayElement(localeFormat);
+      }
+    }
+    return Helpers.replaceSymbols(format);
+  }
+
+  /**
+   * Generates random zipcode from state abbreviation. If state abbreviation is
+   * not specified, a random zip code is generated according to the locale's zip format.
+   * Only works for locales with postcode_by_state definition. If a locale does not
+   * have a postcode_by_state definition, a random zip code is generated according
+   * to the locale's zip format.
+   *
+   * @method faker.address.zipCodeByState
+   * @param {String} state
+   */
+  this.zipCodeByState = function (state) {
+    var zipRange = faker.definitions.address.postcode_by_state[state];
+    if (zipRange) {
+      return faker.datatype.number(zipRange);
+    }
+    return faker.address.zipCode();
+  }
+
+  /**
+   * Generates a random localized city name. The format string can contain any
+   * method provided by faker wrapped in `{{}}`, e.g. `{{name.firstName}}` in
+   * order to build the city name.
+   *
+   * If no format string is provided one of the following is randomly used:
+   *
+   * * `{{address.cityPrefix}} {{name.firstName}}{{address.citySuffix}}`
+   * * `{{address.cityPrefix}} {{name.firstName}}`
+   * * `{{name.firstName}}{{address.citySuffix}}`
+   * * `{{name.lastName}}{{address.citySuffix}}`
+   * * `{{address.cityName}}` when city name is available
+   *
+   * @method faker.address.city
+   * @param {String} format
+   */
+  this.city = function (format) {
+    var formats = [
+      '{{address.cityPrefix}} {{name.firstName}}{{address.citySuffix}}',
+      '{{address.cityPrefix}} {{name.firstName}}',
+      '{{name.firstName}}{{address.citySuffix}}',
+      '{{name.lastName}}{{address.citySuffix}}'
+    ];
+
+    if (!format && faker.definitions.address.city_name) {
+      formats.push('{{address.cityName}}');
+    }
+
+    if (typeof format !== "number") {
+      format = faker.datatype.number(formats.length - 1);
+    }
+
+    return f(formats[format]);
+
+  }
+
+  /**
+   * Return a random localized city prefix
+   * @method faker.address.cityPrefix
+   */
+  this.cityPrefix = function () {
+    return faker.random.arrayElement(faker.definitions.address.city_prefix);
+  }
+
+  /**
+   * Return a random localized city suffix
+   *
+   * @method faker.address.citySuffix
+   */
+  this.citySuffix = function () {
+    return faker.random.arrayElement(faker.definitions.address.city_suffix);
+  }
+
+  /**
+   * Returns a random city name
+   * 
+   * @method faker.address.cityName
+   */
+  this.cityName = function() {
+    return faker.random.arrayElement(faker.definitions.address.city_name);
+  }
+
+  /**
+   * Returns a random localized street name
+   *
+   * @method faker.address.streetName
+   */
+  this.streetName = function () {
+    var result;
+    var suffix = faker.address.streetSuffix();
+    if (suffix !== "") {
+      suffix = " " + suffix
+    }
+
+    switch (faker.datatype.number(1)) {
+      case 0:
+        result = faker.name.lastName() + suffix;
+        break;
+      case 1:
+        result = faker.name.firstName() + suffix;
+        break;
+    }
+    return result;
+  }
+
+  //
+  // TODO: change all these methods that accept a boolean to instead accept an options hash.
+  //
+  /**
+   * Returns a random localized street address
+   *
+   * @method faker.address.streetAddress
+   * @param {Boolean} useFullAddress
+   */
+  this.streetAddress = function (useFullAddress) {
+    if (useFullAddress === undefined) { useFullAddress = false; }
+    var address = "";
+    switch (faker.datatype.number(2)) {
+      case 0:
+        address = Helpers.replaceSymbolWithNumber("#####") + " " + faker.address.streetName();
+        break;
+      case 1:
+        address = Helpers.replaceSymbolWithNumber("####") +  " " + faker.address.streetName();
+        break;
+      case 2:
+        address = Helpers.replaceSymbolWithNumber("###") + " " + faker.address.streetName();
+        break;
+    }
+    return useFullAddress ? (address + " " + faker.address.secondaryAddress()) : address;
+  }
+
+  /**
+   * streetSuffix
+   *
+   * @method faker.address.streetSuffix
+   */
+  this.streetSuffix = function () {
+    return faker.random.arrayElement(faker.definitions.address.street_suffix);
+  }
+
+  /**
+   * streetPrefix
+   *
+   * @method faker.address.streetPrefix
+   */
+  this.streetPrefix = function () {
+    return faker.random.arrayElement(faker.definitions.address.street_prefix);
+  }
+
+  /**
+   * secondaryAddress
+   *
+   * @method faker.address.secondaryAddress
+   */
+  this.secondaryAddress = function () {
+    return Helpers.replaceSymbolWithNumber(faker.random.arrayElement(
+      [
+        'Apt. ###',
+        'Suite ###'
+      ]
+    ));
+  }
+
+  /**
+   * county
+   *
+   * @method faker.address.county
+   */
+  this.county = function () {
+    return faker.random.arrayElement(faker.definitions.address.county);
+  }
+
+  /**
+   * country
+   *
+   * @method faker.address.country
+   */
+  this.country = function () {
+    return faker.random.arrayElement(faker.definitions.address.country);
+  }
+
+  /**
+   * countryCode
+   *
+   * @method faker.address.countryCode
+   * @param {string} alphaCode default alpha-2
+   */
+  this.countryCode = function (alphaCode) {
+    
+    if (typeof alphaCode === 'undefined' || alphaCode === 'alpha-2') {
+      return faker.random.arrayElement(faker.definitions.address.country_code);
+    }
+
+    if (alphaCode === 'alpha-3') {
+      return faker.random.arrayElement(faker.definitions.address.country_code_alpha_3);
+    }
+      
+    return faker.random.arrayElement(faker.definitions.address.country_code);
+
+  }
+
+  /**
+   * state
+   *
+   * @method faker.address.state
+   * @param {Boolean} useAbbr
+   */
+  this.state = function (useAbbr) {
+    return faker.random.arrayElement(faker.definitions.address.state);
+  }
+
+  /**
+   * stateAbbr
+   *
+   * @method faker.address.stateAbbr
+   */
+  this.stateAbbr = function () {
+    return faker.random.arrayElement(faker.definitions.address.state_abbr);
+  }
+
+  /**
+   * latitude
+   *
+   * @method faker.address.latitude
+   * @param {Double} max default is 90
+   * @param {Double} min default is -90
+   * @param {number} precision default is 4
+   */
+  this.latitude = function (max, min, precision) {
+    max       = max || 90
+    min       = min || -90
+    precision = precision || 4
+
+    return faker.datatype.number({
+      max: max,
+      min: min,
+      precision: parseFloat((0.0).toPrecision(precision) + '1')
+    }).toFixed(precision);
+  }
+
+  /**
+   * longitude
+   *
+   * @method faker.address.longitude
+   * @param {Double} max default is 180
+   * @param {Double} min default is -180
+   * @param {number} precision default is 4
+   */
+  this.longitude = function (max, min, precision) {
+    max       = max || 180
+    min       = min || -180
+    precision = precision || 4
+
+    return faker.datatype.number({
+      max: max,
+      min: min,
+      precision: parseFloat((0.0).toPrecision(precision) + '1')
+    }).toFixed(precision);
+  }
+
+  /**
+   *  direction
+   *
+   * @method faker.address.direction
+   * @param {Boolean} useAbbr return direction abbreviation. defaults to false
+   */
+  this.direction = function (useAbbr) {
+    if (typeof useAbbr === 'undefined' || useAbbr === false) {
+      return faker.random.arrayElement(faker.definitions.address.direction);
+    }
+    return faker.random.arrayElement(faker.definitions.address.direction_abbr);
+  }
+
+  this.direction.schema = {
+    "description": "Generates a direction. Use optional useAbbr bool to return abbreviation",
+    "sampleResults": ["Northwest", "South", "SW", "E"]
+  };
+
+  /**
+   * cardinal direction
+   *
+   * @method faker.address.cardinalDirection
+   * @param {Boolean} useAbbr return direction abbreviation. defaults to false
+   */
+  this.cardinalDirection = function (useAbbr) {
+    if (typeof useAbbr === 'undefined' || useAbbr === false) {
+      return (
+        faker.random.arrayElement(faker.definitions.address.direction.slice(0, 4))
+      );
+    }
+    return (
+      faker.random.arrayElement(faker.definitions.address.direction_abbr.slice(0, 4))
+    );
+  }
+
+  this.cardinalDirection.schema = {
+    "description": "Generates a cardinal direction. Use optional useAbbr boolean to return abbreviation",
+    "sampleResults": ["North", "South", "E", "W"]
+  };
+
+  /**
+   * ordinal direction
+   *
+   * @method faker.address.ordinalDirection
+   * @param {Boolean} useAbbr return direction abbreviation. defaults to false
+   */
+  this.ordinalDirection = function (useAbbr) {
+    if (typeof useAbbr === 'undefined' || useAbbr === false) {
+      return (
+        faker.random.arrayElement(faker.definitions.address.direction.slice(4, 8))
+      );
+    }
+    return (
+      faker.random.arrayElement(faker.definitions.address.direction_abbr.slice(4, 8))
+    );
+  }
+
+  this.ordinalDirection.schema = {
+    "description": "Generates an ordinal direction. Use optional useAbbr boolean to return abbreviation",
+    "sampleResults": ["Northwest", "Southeast", "SW", "NE"]
+  };
+
+  this.nearbyGPSCoordinate = function(coordinate, radius, isMetric) {
+    function randomFloat(min, max) {
+      return Math.random() * (max-min) + min;
+    }
+    function degreesToRadians(degrees) {
+      return degrees * (Math.PI/180.0);
+    }
+    function radiansToDegrees(radians) {
+      return radians * (180.0/Math.PI);
+    }
+    function kilometersToMiles(miles) {
+      return miles * 0.621371;
+    }
+    function coordinateWithOffset(coordinate, bearing, distance, isMetric) {
+      var R = 6378.137; // Radius of the Earth (http://nssdc.gsfc.nasa.gov/planetary/factsheet/earthfact.html)
+      var d = isMetric ? distance : kilometersToMiles(distance); // Distance in km
+
+      var lat1 = degreesToRadians(coordinate[0]); //Current lat point converted to radians
+      var lon1 = degreesToRadians(coordinate[1]); //Current long point converted to radians
+
+      var lat2 = Math.asin(Math.sin(lat1) * Math.cos(d/R) +
+                Math.cos(lat1) * Math.sin(d/R) * Math.cos(bearing));
+
+      var lon2 = lon1 + Math.atan2(
+        Math.sin(bearing) * Math.sin(d/R) * Math.cos(lat1),
+        Math.cos(d/R) - Math.sin(lat1) * Math.sin(lat2));
+
+      // Keep longitude in range [-180, 180]
+      if (lon2 > degreesToRadians(180)) {
+        lon2 = lon2 - degreesToRadians(360);
+      } else if (lon2 < degreesToRadians(-180)) {
+        lon2 = lon2 + degreesToRadians(360);
+      }
+
+      return [radiansToDegrees(lat2), radiansToDegrees(lon2)];
+    }
+
+    // If there is no coordinate, the best we can do is return a random GPS coordinate.
+    if (coordinate === undefined) {
+      return [faker.address.latitude(), faker.address.longitude()]
+    }
+    radius = radius || 10.0;
+    isMetric = isMetric || false;
+
+    // TODO: implement either a gaussian/uniform distribution of points in cicular region.
+    // Possibly include param to function that allows user to choose between distributions.
+
+    // This approach will likely result in a higher density of points near the center.
+    var randomCoord = coordinateWithOffset(coordinate, degreesToRadians(Math.random() * 360.0), radius, isMetric);
+    return [randomCoord[0].toFixed(4), randomCoord[1].toFixed(4)];
+  }
+
+  /**
+     * Return a random time zone
+     * @method faker.address.timeZone
+     */
+  this.timeZone = function() {
+    return faker.random.arrayElement(faker.definitions.address.time_zone);
+  }
+
+  return this;
+}
+
+module.exports = Address;

node_modules/faker/lib/animal.js

@@ -0,0 +1,124 @@
+/**
+ *
+ * @namespace faker.animal
+ */
+var Animal = function (faker) {
+  var self = this;
+
+  /**
+   * dog
+   *
+   * @method faker.animal.dog
+   */
+  self.dog = function() {
+    return faker.random.arrayElement(faker.definitions.animal.dog);
+  };
+  /**
+   * cat
+   *
+   * @method faker.animal.cat
+   */
+  self.cat = function() {
+    return faker.random.arrayElement(faker.definitions.animal.cat);
+  };
+  /**
+   * snake  
+   *
+   * @method faker.animal.snake
+   */
+  self.snake = function() {
+    return faker.random.arrayElement(faker.definitions.animal.snake);
+  };
+  /**
+   * bear  
+   *
+   * @method faker.animal.bear
+   */
+  self.bear = function() {
+    return faker.random.arrayElement(faker.definitions.animal.bear);
+  };
+  /**
+   * lion  
+   *
+   * @method faker.animal.lion
+   */
+  self.lion = function() {
+    return faker.random.arrayElement(faker.definitions.animal.lion);
+  };
+  /**
+   * cetacean  
+   *
+   * @method faker.animal.cetacean
+   */
+  self.cetacean = function() {
+    return faker.random.arrayElement(faker.definitions.animal.cetacean);
+  };
+  /**
+   * horse 
+   *
+   * @method faker.animal.horse
+   */
+  self.horse = function() {
+    return faker.random.arrayElement(faker.definitions.animal.horse);
+  };
+  /**
+   * bird
+   *
+   * @method faker.animal.bird
+   */
+  self.bird = function() {
+    return faker.random.arrayElement(faker.definitions.animal.bird);
+  };
+  /**
+   * cow 
+   *
+   * @method faker.animal.cow
+   */
+  self.cow = function() {
+    return faker.random.arrayElement(faker.definitions.animal.cow);
+  };
+  /**
+   * fish
+   *
+   * @method faker.animal.fish
+   */
+  self.fish = function() {
+    return faker.random.arrayElement(faker.definitions.animal.fish);
+  };
+  /**
+   * crocodilia
+   *
+   * @method faker.animal.crocodilia
+   */
+  self.crocodilia = function() {
+    return faker.random.arrayElement(faker.definitions.animal.crocodilia);
+  };
+  /**
+   * insect  
+   *
+   * @method faker.animal.insect
+   */
+  self.insect = function() {
+    return faker.random.arrayElement(faker.definitions.animal.insect);
+  };
+  /**
+   * rabbit 
+   *
+   * @method faker.animal.rabbit
+   */
+  self.rabbit = function() {
+    return faker.random.arrayElement(faker.definitions.animal.rabbit);
+  };
+  /**
+   * type 
+   *
+   * @method faker.animal.type
+   */
+  self.type = function() {
+    return faker.random.arrayElement(faker.definitions.animal.type);
+  };
+
+  return self;
+};
+
+module['exports'] = Animal;

node_modules/faker/lib/commerce.js

@@ -0,0 +1,128 @@
+/**
+ *
+ * @namespace faker.commerce
+ */
+var Commerce = function (faker) {
+  var self = this;
+
+  /**
+   * color
+   *
+   * @method faker.commerce.color
+   */
+  self.color = function() {
+    return faker.random.arrayElement(faker.definitions.commerce.color);
+  };
+
+  /**
+   * department
+   *
+   * @method faker.commerce.department
+   */
+  self.department = function() {
+    return faker.random.arrayElement(faker.definitions.commerce.department);
+  };
+
+  /**
+   * productName
+   *
+   * @method faker.commerce.productName
+   */
+  self.productName = function() {
+    return faker.commerce.productAdjective() + " " +
+              faker.commerce.productMaterial() + " " +
+              faker.commerce.product();
+  };
+
+  /**
+   * price
+   *
+   * @method faker.commerce.price
+   * @param {number} min
+   * @param {number} max
+   * @param {number} dec
+   * @param {string} symbol
+   *
+   * @return {string}
+   */
+  self.price = function(min, max, dec, symbol) {
+    min = min || 1;
+    max = max || 1000;
+    dec = dec === undefined ? 2 : dec;
+    symbol = symbol || '';
+
+    if (min < 0 || max < 0) {
+      return symbol + 0.00;
+    }
+
+    var randValue = faker.datatype.number({ max: max, min: min });
+
+    return symbol + (Math.round(randValue * Math.pow(10, dec)) / Math.pow(10, dec)).toFixed(dec);
+  };
+
+  /*
+  self.categories = function(num) {
+      var categories = [];
+
+      do {
+          var category = faker.random.arrayElement(faker.definitions.commerce.department);
+          if(categories.indexOf(category) === -1) {
+              categories.push(category);
+          }
+      } while(categories.length < num);
+
+      return categories;
+  };
+
+  */
+  /*
+  self.mergeCategories = function(categories) {
+      var separator = faker.definitions.separator || " &";
+      // TODO: find undefined here
+      categories = categories || faker.definitions.commerce.categories;
+      var commaSeparated = categories.slice(0, -1).join(', ');
+
+      return [commaSeparated, categories[categories.length - 1]].join(separator + " ");
+  };
+  */
+
+  /**
+   * productAdjective
+   *
+   * @method faker.commerce.productAdjective
+   */
+  self.productAdjective = function() {
+    return faker.random.arrayElement(faker.definitions.commerce.product_name.adjective);
+  };
+
+  /**
+   * productMaterial
+   *
+   * @method faker.commerce.productMaterial
+   */
+  self.productMaterial = function() {
+    return faker.random.arrayElement(faker.definitions.commerce.product_name.material);
+  };
+
+  /**
+   * product
+   *
+   * @method faker.commerce.product
+   */
+  self.product = function() {
+    return faker.random.arrayElement(faker.definitions.commerce.product_name.product);
+  };
+
+  /**
+   * productDescription
+   *
+   * @method faker.commerce.productDescription
+   */
+  self.productDescription = function() {
+    return faker.random.arrayElement(faker.definitions.commerce.product_description);
+  };
+
+  return self;
+};
+
+module['exports'] = Commerce;

node_modules/faker/lib/company.js

@@ -0,0 +1,124 @@
+/**
+ *
+ * @namespace faker.company
+ */
+var Company = function (faker) {
+  
+  var self = this;
+  var f = faker.fake;
+  
+  /**
+   * suffixes
+   *
+   * @method faker.company.suffixes
+   */
+  this.suffixes = function () {
+    // Don't want the source array exposed to modification, so return a copy
+    return faker.definitions.company.suffix.slice(0);
+  }
+
+  /**
+   * companyName
+   *
+   * @method faker.company.companyName
+   * @param {string} format
+   */
+  this.companyName = function (format) {
+
+    var formats = [
+      '{{name.lastName}} {{company.companySuffix}}',
+      '{{name.lastName}} - {{name.lastName}}',
+      '{{name.lastName}}, {{name.lastName}} and {{name.lastName}}'
+    ];
+
+    if (typeof format !== "number") {
+      format = faker.datatype.number(formats.length - 1);
+    }
+
+    return f(formats[format]);
+  }
+
+  /**
+   * companySuffix
+   *
+   * @method faker.company.companySuffix
+   */
+  this.companySuffix = function () {
+    return faker.random.arrayElement(faker.company.suffixes());
+  }
+
+  /**
+   * catchPhrase
+   *
+   * @method faker.company.catchPhrase
+   */
+  this.catchPhrase = function () {
+    return f('{{company.catchPhraseAdjective}} {{company.catchPhraseDescriptor}} {{company.catchPhraseNoun}}')
+  }
+
+  /**
+   * bs
+   *
+   * @method faker.company.bs
+   */
+  this.bs = function () {
+    return f('{{company.bsBuzz}} {{company.bsAdjective}} {{company.bsNoun}}');
+  }
+
+  /**
+   * catchPhraseAdjective
+   *
+   * @method faker.company.catchPhraseAdjective
+   */
+  this.catchPhraseAdjective = function () {
+    return faker.random.arrayElement(faker.definitions.company.adjective);
+  }
+
+  /**
+   * catchPhraseDescriptor
+   *
+   * @method faker.company.catchPhraseDescriptor
+   */
+  this.catchPhraseDescriptor = function () {
+    return faker.random.arrayElement(faker.definitions.company.descriptor);
+  }
+
+  /**
+   * catchPhraseNoun
+   *
+   * @method faker.company.catchPhraseNoun
+   */
+  this.catchPhraseNoun = function () {
+    return faker.random.arrayElement(faker.definitions.company.noun);
+  }
+
+  /**
+   * bsAdjective
+   *
+   * @method faker.company.bsAdjective
+   */
+  this.bsAdjective = function () {
+    return faker.random.arrayElement(faker.definitions.company.bs_adjective);
+  }
+
+  /**
+   * bsBuzz
+   *
+   * @method faker.company.bsBuzz
+   */
+  this.bsBuzz = function () {
+    return faker.random.arrayElement(faker.definitions.company.bs_verb);
+  }
+
+  /**
+   * bsNoun
+   *
+   * @method faker.company.bsNoun
+   */
+  this.bsNoun = function () {
+    return faker.random.arrayElement(faker.definitions.company.bs_noun);
+  }
+  
+}
+
+module['exports'] = Company;

node_modules/faker/lib/database.js

@@ -0,0 +1,64 @@
+/**
+ *
+ * @namespace faker.database
+ */
+var Database = function (faker) {
+  var self = this;
+  /**
+   * column
+   *
+   * @method faker.database.column
+   */
+  self.column = function () {
+    return faker.random.arrayElement(faker.definitions.database.column);
+  };
+
+  self.column.schema = {
+    "description": "Generates a column name.",
+    "sampleResults": ["id", "title", "createdAt"]
+  };
+
+  /**
+   * type
+   *
+   * @method faker.database.type
+   */
+  self.type = function () {
+    return faker.random.arrayElement(faker.definitions.database.type);
+  };
+
+  self.type.schema = {
+    "description": "Generates a column type.",
+    "sampleResults": ["byte", "int", "varchar", "timestamp"]
+  };
+
+  /**
+   * collation
+   *
+   * @method faker.database.collation
+   */
+  self.collation = function () {
+    return faker.random.arrayElement(faker.definitions.database.collation);
+  };
+
+  self.collation.schema = {
+    "description": "Generates a collation.",
+    "sampleResults": ["utf8_unicode_ci", "utf8_bin"]
+  };
+
+  /**
+   * engine
+   *
+   * @method faker.database.engine
+   */
+  self.engine = function () {
+    return faker.random.arrayElement(faker.definitions.database.engine);
+  };
+
+  self.engine.schema = {
+    "description": "Generates a storage engine.",
+    "sampleResults": ["MyISAM", "InnoDB"]
+  };
+};
+
+module["exports"] = Database;

node_modules/faker/lib/datatype.js

@@ -0,0 +1,226 @@
+/**
+ *
+ * @namespace faker.datatype
+ */
+function Datatype (faker, seed) {
+  // Use a user provided seed if it is an array or number
+  if (Array.isArray(seed) && seed.length) {
+    faker.mersenne.seed_array(seed);
+  }
+  else if(!isNaN(seed)) {
+    faker.mersenne.seed(seed);
+  }
+
+  /**
+     * returns a single random number based on a max number or range
+     *
+     * @method faker.datatype.number
+     * @param {mixed} options {min, max, precision}
+     */
+  this.number = function (options) {
+
+    if (typeof options === "number") {
+      options = {
+        max: options
+      };
+    }
+
+    options = options || {};
+
+    if (typeof options.min === "undefined") {
+      options.min = 0;
+    }
+
+    if (typeof options.max === "undefined") {
+      options.max = 99999;
+    }
+    if (typeof options.precision === "undefined") {
+      options.precision = 1;
+    }
+
+    // Make the range inclusive of the max value
+    var max = options.max;
+    if (max >= 0) {
+      max += options.precision;
+    }
+
+    var randomNumber = Math.floor(
+      faker.mersenne.rand(max / options.precision, options.min / options.precision));
+    // Workaround problem in Float point arithmetics for e.g. 6681493 / 0.01
+    randomNumber = randomNumber / (1 / options.precision);
+
+    return randomNumber;
+
+  };
+
+  /**
+     * returns a single random floating-point number based on a max number or range
+     *
+     * @method faker.datatype.float
+     * @param {mixed} options
+     */
+  this.float = function (options) {
+    if (typeof options === "number") {
+      options = {
+        precision: options
+      };
+    }
+    options = options || {};
+    var opts = {};
+    for (var p in options) {
+      opts[p] = options[p];
+    }
+    if (typeof opts.precision === 'undefined') {
+      opts.precision = 0.01;
+    }
+    return faker.datatype.number(opts);
+  };
+
+  /**
+     * method returns a Date object using a random number of milliseconds since 1. Jan 1970 UTC
+     * Caveat: seeding is not working
+     *
+     * @method faker.datatype.datetime
+     * @param {mixed} options, pass min OR max as number of milliseconds since 1. Jan 1970 UTC
+     */
+  this.datetime = function (options) {
+    if (typeof options === "number") {
+      options = {
+        max: options
+      };
+    }
+
+    var minMax = 8640000000000000;
+
+    options = options || {};
+
+    if (typeof options.min === "undefined" || options.min < minMax*-1) {
+      options.min = new Date().setFullYear(1990, 1, 1);
+    }
+
+    if (typeof options.max === "undefined" || options.max > minMax) {
+      options.max = new Date().setFullYear(2100,1,1);
+    }
+
+    var random = faker.datatype.number(options);
+    return new Date(random);
+  };
+
+  /**
+     * Returns a string, containing UTF-16 chars between 33 and 125 ('!' to '}')
+     *
+     *
+     * @method faker.datatype.string
+     * @param { number } length: length of generated string, default = 10, max length = 2^20
+     */
+  this.string = function (length) {
+    if(length === undefined ){
+      length = 10;
+    }
+
+    var maxLength = Math.pow(2, 20);
+    if(length >= (maxLength)){
+      length = maxLength;
+    }
+
+    var charCodeOption = {
+      min: 33,
+      max: 125
+    };
+
+    var returnString = '';
+
+    for(var i = 0; i < length; i++){
+      returnString += String.fromCharCode(faker.datatype.number(charCodeOption));
+    }
+    return returnString;
+  };
+
+  /**
+     * uuid
+     *
+     * @method faker.datatype.uuid
+     */
+  this.uuid = function () {
+    var RFC4122_TEMPLATE = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
+    var replacePlaceholders = function (placeholder) {
+      var random = faker.datatype.number({ min: 0, max: 15 });
+      var value = placeholder == 'x' ? random : (random &0x3 | 0x8);
+      return value.toString(16);
+    };
+    return RFC4122_TEMPLATE.replace(/[xy]/g, replacePlaceholders);
+  };
+
+  /**
+     * boolean
+     *
+     * @method faker.datatype.boolean
+     */
+  this.boolean = function () {
+    return !!faker.datatype.number(1);
+  };
+
+
+  /**
+     * hexaDecimal
+     *
+     * @method faker.datatype.hexaDecimal
+     * @param {number} count defaults to 1
+     */
+  this.hexaDecimal = function hexaDecimal(count) {
+    if (typeof count === "undefined") {
+      count = 1;
+    }
+
+    var wholeString = "";
+    for(var i = 0; i < count; i++) {
+      wholeString += faker.random.arrayElement(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f", "A", "B", "C", "D", "E", "F"]);
+    }
+
+    return "0x"+wholeString;
+  };
+
+  /**
+     * returns json object with 7 pre-defined properties
+     *
+     * @method faker.datatype.json
+     */
+  this.json = function json() {
+
+    var properties = ['foo', 'bar', 'bike', 'a', 'b', 'name', 'prop'];
+
+    var returnObject = {};
+    properties.forEach(function(prop){
+      returnObject[prop] = faker.datatype.boolean() ?
+        faker.datatype.string() : faker.datatype.number();
+    });
+
+    return JSON.stringify(returnObject);
+  };
+
+  /**
+     * returns an array with values generated by faker.datatype.number and faker.datatype.string
+     *
+     * @method faker.datatype.array
+     * @param { number } length of the returned array
+     */
+
+  this.array = function array(length) {
+
+
+    if(length === undefined){
+      length = 10;
+    }
+    var returnArray = new Array(length);
+    for(var i = 0; i < length; i++){
+      returnArray[i] = faker.datatype.boolean() ?
+        faker.datatype.string() : faker.datatype.number();
+    }
+    return returnArray;
+
+  };
+
+  return this;
+}
+
+module['exports'] = Datatype;

node_modules/faker/lib/date.js

@@ -0,0 +1,193 @@
+/**
+ *
+ * @namespace faker.date
+ */
+var _Date = function (faker) {
+  var self = this;
+  /**
+   * past
+   *
+   * @method faker.date.past
+   * @param {number} years
+   * @param {date} refDate
+   */
+  self.past = function (years, refDate) {
+    var date = new Date();
+    if (typeof refDate !== "undefined") {
+      date = new Date(Date.parse(refDate));
+    }
+
+    var range = {
+      min: 1000,
+      max: (years || 1) * 365 * 24 * 3600 * 1000
+    };
+
+    var past = date.getTime();
+    past -= faker.datatype.number(range); // some time from now to N years ago, in milliseconds
+    date.setTime(past);
+
+    return date;
+  };
+
+  /**
+   * future
+   *
+   * @method faker.date.future
+   * @param {number} years
+   * @param {date} refDate
+   */
+  self.future = function (years, refDate) {
+    var date = new Date();
+    if (typeof refDate !== "undefined") {
+      date = new Date(Date.parse(refDate));
+    }
+
+    var range = {
+      min: 1000,
+      max: (years || 1) * 365 * 24 * 3600 * 1000
+    };
+
+    var future = date.getTime();
+    future += faker.datatype.number(range); // some time from now to N years later, in milliseconds
+    date.setTime(future);
+
+    return date;
+  };
+
+  /**
+   * between
+   *
+   * @method faker.date.between
+   * @param {date} from
+   * @param {date} to
+   */
+  self.between = function (from, to) {
+    var fromMilli = Date.parse(from);
+    var dateOffset = faker.datatype.number(Date.parse(to) - fromMilli);
+
+    var newDate = new Date(fromMilli + dateOffset);
+
+    return newDate;
+  };
+
+  /**
+   * betweens
+   *
+   * @method faker.date.between
+   * @param {date} from
+   * @param {date} to
+   */
+  self.betweens = function (from, to, num) {
+    if (typeof num == 'undefined') { num = 3; }
+    var newDates = [];
+    var fromMilli = Date.parse(from);
+    var dateOffset = (Date.parse(to) - fromMilli) / ( num + 1 );
+    var lastDate = from
+    for (var i = 0; i < num; i++) {
+      fromMilli = Date.parse(lastDate);
+      lastDate = new Date(fromMilli + dateOffset)
+      newDates.push(lastDate)
+    }
+    return newDates;
+  };
+
+
+  /**
+   * recent
+   *
+   * @method faker.date.recent
+   * @param {number} days
+   * @param {date} refDate
+   */
+  self.recent = function (days, refDate) {
+    var date = new Date();
+    if (typeof refDate !== "undefined") {
+      date = new Date(Date.parse(refDate));
+    }
+
+    var range = {
+      min: 1000,
+      max: (days || 1) * 24 * 3600 * 1000
+    };
+
+    var future = date.getTime();
+    future -= faker.datatype.number(range); // some time from now to N days ago, in milliseconds
+    date.setTime(future);
+
+    return date;
+  };
+
+  /**
+   * soon
+   *
+   * @method faker.date.soon
+   * @param {number} days
+   * @param {date} refDate
+   */
+  self.soon = function (days, refDate) {
+    var date = new Date();
+    if (typeof refDate !== "undefined") {
+      date = new Date(Date.parse(refDate));
+    }
+
+    var range = {
+      min: 1000,
+      max: (days || 1) * 24 * 3600 * 1000
+    };
+
+    var future = date.getTime();
+    future += faker.datatype.number(range); // some time from now to N days later, in milliseconds
+    date.setTime(future);
+
+    return date;
+  };
+
+  /**
+   * month
+   *
+   * @method faker.date.month
+   * @param {object} options
+   */
+  self.month = function (options) {
+    options = options || {};
+
+    var type = 'wide';
+    if (options.abbr) {
+      type = 'abbr';
+    }
+    if (options.context && typeof faker.definitions.date.month[type + '_context'] !== 'undefined') {
+      type += '_context';
+    }
+
+    var source = faker.definitions.date.month[type];
+
+    return faker.random.arrayElement(source);
+  };
+
+  /**
+   * weekday
+   *
+   * @param {object} options
+   * @method faker.date.weekday
+   */
+  self.weekday = function (options) {
+    options = options || {};
+
+    var type = 'wide';
+    if (options.abbr) {
+      type = 'abbr';
+    }
+    if (options.context && typeof faker.definitions.date.weekday[type + '_context'] !== 'undefined') {
+      type += '_context';
+    }
+
+    var source = faker.definitions.date.weekday[type];
+
+    return faker.random.arrayElement(source);
+  };
+
+  return self;
+
+};
+
+module['exports'] = _Date;

node_modules/faker/lib/fake.js

@@ -0,0 +1,107 @@
+/*
+  fake.js - generator method for combining faker methods based on string input
+
+*/
+
+function Fake (faker) {
+  
+  /**
+   * Generator method for combining faker methods based on string input
+   *
+   * __Example:__
+   *
+   * ```
+   * console.log(faker.fake('{{name.lastName}}, {{name.firstName}} {{name.suffix}}'));
+   * //outputs: "Marks, Dean Sr."
+   * ```
+   *
+   * This will interpolate the format string with the value of methods
+   * [name.lastName]{@link faker.name.lastName}, [name.firstName]{@link faker.name.firstName},
+   * and [name.suffix]{@link faker.name.suffix}
+   *
+   * @method faker.fake
+   * @param {string} str
+   */
+  this.fake = function fake (str) {
+    // setup default response as empty string
+    var res = '';
+
+    // if incoming str parameter is not provided, return error message
+    if (typeof str !== 'string' || str.length === 0) {
+      throw new Error('string parameter is required!');
+    }
+
+    // find first matching {{ and }}
+    var start = str.search('{{');
+    var end = str.search('}}');
+
+    // if no {{ and }} is found, we are done
+    if (start === -1 && end === -1) {
+      return str;
+    }
+
+    // console.log('attempting to parse', str);
+
+    // extract method name from between the {{ }} that we found
+    // for example: {{name.firstName}}
+    var token = str.substr(start + 2,  end - start - 2);
+    var method = token.replace('}}', '').replace('{{', '');
+
+    // console.log('method', method)
+
+    // extract method parameters
+    var regExp = /\(([^)]+)\)/;
+    var matches = regExp.exec(method);
+    var parameters = '';
+    if (matches) {
+      method = method.replace(regExp, '');
+      parameters = matches[1];
+    }
+
+    // split the method into module and function
+    var parts = method.split('.');
+
+    if (typeof faker[parts[0]] === "undefined") {
+      throw new Error('Invalid module: ' + parts[0]);
+    }
+
+    if (typeof faker[parts[0]][parts[1]] === "undefined") {
+      throw new Error('Invalid method: ' + parts[0] + "." + parts[1]);
+    }
+
+    // assign the function from the module.function namespace
+    var fn = faker[parts[0]][parts[1]];
+
+    // If parameters are populated here, they are always going to be of string type
+    // since we might actually be dealing with an object or array,
+    // we always attempt to the parse the incoming parameters into JSON
+    var params;
+    // Note: we experience a small performance hit here due to JSON.parse try / catch
+    // If anyone actually needs to optimize this specific code path, please open a support issue on github
+    try {
+      params = JSON.parse(parameters)
+    } catch (err) {
+      // since JSON.parse threw an error, assume parameters was actually a string
+      params = parameters;
+    }
+
+    var result;
+    if (typeof params === "string" && params.length === 0) {
+      result = fn.call(this);
+    } else {
+      result = fn.call(this, params);
+    }
+
+    // replace the found tag with the returned fake value
+    res = str.replace('{{' + token + '}}', result);
+
+    // return the response recursively until we are done finding all tags
+    return fake(res);    
+  }
+  
+  return this;
+  
+  
+}
+
+module['exports'] = Fake;

node_modules/faker/lib/finance.js

@@ -0,0 +1,352 @@
+/**
+ * @namespace faker.finance
+ */
+var Finance = function (faker) {
+  var ibanLib = require("./iban");
+  var Helpers = faker.helpers,
+      self = this;
+
+  /**
+   * account
+   *
+   * @method faker.finance.account
+   * @param {number} length
+   */
+  self.account = function (length) {
+
+      length = length || 8;
+
+      var template = '';
+
+      for (var i = 0; i < length; i++) {
+          template = template + '#';
+      }
+      length = null;
+      return Helpers.replaceSymbolWithNumber(template);
+  };
+
+  /**
+   * accountName
+   *
+   * @method faker.finance.accountName
+   */
+  self.accountName = function () {
+
+      return [Helpers.randomize(faker.definitions.finance.account_type), 'Account'].join(' ');
+  };
+
+  /**
+   * routingNumber
+   *
+   * @method faker.finance.routingNumber
+   */
+  self.routingNumber = function () {
+
+      var routingNumber = Helpers.replaceSymbolWithNumber('########');
+
+      // Modules 10 straight summation.
+      var sum = 0;
+
+      for (var i = 0; i < routingNumber.length; i += 3) {
+        sum += Number(routingNumber[i]) * 3;
+        sum += Number(routingNumber[i + 1]) * 7;
+        sum += Number(routingNumber[i + 2]) || 0;
+      }
+
+      return routingNumber + (Math.ceil(sum / 10) * 10 - sum);
+  }
+
+  /**
+   * mask
+   *
+   * @method faker.finance.mask
+   * @param {number} length
+   * @param {boolean} parens
+   * @param {boolean} ellipsis
+   */
+  self.mask = function (length, parens, ellipsis) {
+
+      //set defaults
+      length = (length == 0 || !length || typeof length == 'undefined') ? 4 : length;
+      parens = (parens === null) ? true : parens;
+      ellipsis = (ellipsis === null) ? true : ellipsis;
+
+      //create a template for length
+      var template = '';
+
+      for (var i = 0; i < length; i++) {
+          template = template + '#';
+      }
+
+      //prefix with ellipsis
+      template = (ellipsis) ? ['...', template].join('') : template;
+
+      template = (parens) ? ['(', template, ')'].join('') : template;
+
+      //generate random numbers
+      template = Helpers.replaceSymbolWithNumber(template);
+
+      return template;
+  };
+
+  //min and max take in minimum and maximum amounts, dec is the decimal place you want rounded to, symbol is $, €, £, etc
+  //NOTE: this returns a string representation of the value, if you want a number use parseFloat and no symbol
+
+  /**
+   * amount
+   *
+   * @method faker.finance.amount
+   * @param {number} min
+   * @param {number} max
+   * @param {number} dec
+   * @param {string} symbol
+   *
+   * @return {string}
+   */
+  self.amount = function (min, max, dec, symbol, autoFormat) {
+
+      min = min || 0;
+      max = max || 1000;
+      dec = dec === undefined ? 2 : dec;
+      symbol = symbol || '';
+      const randValue = faker.datatype.number({ max: max, min: min, precision: Math.pow(10, -dec) });
+
+      var formattedString;
+      if(autoFormat) {
+        formattedString = randValue.toLocaleString(undefined, {minimumFractionDigits: dec});
+      }
+      else {
+        formattedString = randValue.toFixed(dec);
+      }
+
+      return symbol + formattedString;
+  };
+
+  /**
+   * transactionType
+   *
+   * @method faker.finance.transactionType
+   */
+  self.transactionType = function () {
+      return Helpers.randomize(faker.definitions.finance.transaction_type);
+  };
+
+  /**
+   * currencyCode
+   *
+   * @method faker.finance.currencyCode
+   */
+  self.currencyCode = function () {
+      return faker.random.objectElement(faker.definitions.finance.currency)['code'];
+  };
+
+  /**
+   * currencyName
+   *
+   * @method faker.finance.currencyName
+   */
+  self.currencyName = function () {
+      return faker.random.objectElement(faker.definitions.finance.currency, 'key');
+  };
+
+  /**
+   * currencySymbol
+   *
+   * @method faker.finance.currencySymbol
+   */
+  self.currencySymbol = function () {
+      var symbol;
+
+      while (!symbol) {
+          symbol = faker.random.objectElement(faker.definitions.finance.currency)['symbol'];
+      }
+      return symbol;
+  };
+
+  /**
+   * bitcoinAddress
+   *
+   * @method  faker.finance.bitcoinAddress
+   */
+  self.bitcoinAddress = function () {
+    var addressLength = faker.datatype.number({ min: 25, max: 34 });
+
+    var address = faker.random.arrayElement(['1', '3']);
+
+    for (var i = 0; i < addressLength - 1; i++)
+      address += faker.random.arrayElement('123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'.split(''));
+
+    return address;
+  }
+
+/**
+ * litecoinAddress
+ *
+ * @method  faker.finance.litecoinAddress
+ */
+self.litecoinAddress = function () {
+  var addressLength = faker.datatype.number({ min: 26, max: 33 });
+
+  var address = faker.random.arrayElement(['L', 'M', '3']);
+
+  for (var i = 0; i < addressLength - 1; i++)
+    address += faker.random.arrayElement('123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'.split(''));
+
+  return address;
+}
+
+  /**
+   * Credit card number
+   * @method faker.finance.creditCardNumber
+   * @param {string} provider | scheme
+  */
+  self.creditCardNumber = function(provider){
+    provider = provider || "";
+    var format, formats;
+    var localeFormat = faker.definitions.finance.credit_card;
+    if (provider in localeFormat) {
+      formats = localeFormat[provider]; // there chould be multiple formats
+      if (typeof formats === "string") {
+        format = formats;
+      } else {
+        format = faker.random.arrayElement(formats);
+      }
+    } else if (provider.match(/#/)) { // The user chose an optional scheme
+      format = provider;
+    } else { // Choose a random provider
+      if (typeof localeFormat === 'string') {
+        format = localeFormat;
+      } else if( typeof localeFormat === "object") {
+        // Credit cards are in a object structure
+        formats = faker.random.objectElement(localeFormat, "value"); // There chould be multiple formats
+        if (typeof formats === "string") {
+          format = formats;
+        } else {
+          format = faker.random.arrayElement(formats);
+        }
+      }
+    }
+    format = format.replace(/\//g,"")
+    return Helpers.replaceCreditCardSymbols(format);
+  };
+  /**
+   * Credit card CVV
+   * @method faker.finance.creditCardCVV
+  */
+  self.creditCardCVV = function() {
+    var cvv = "";
+    for (var i = 0; i < 3; i++) {
+      cvv += faker.datatype.number({max:9}).toString();
+    }
+    return cvv;
+  };
+
+  /**
+   * ethereumAddress
+   *
+   * @method  faker.finance.ethereumAddress
+   */
+  self.ethereumAddress = function () {
+    var address = faker.datatype.hexaDecimal(40).toLowerCase();
+    return address;
+  };
+
+  /**
+   * iban
+   *
+   * @param {boolean} [formatted=false] - Return a formatted version of the generated IBAN.
+   * @param {string} [countryCode] - The country code from which you want to generate an IBAN, if none is provided a random country will be used.
+   * @throws Will throw an error if the passed country code is not supported.
+   *
+   * @method  faker.finance.iban
+   */
+  self.iban = function (formatted, countryCode) {
+      var ibanFormat;
+      if (countryCode) {
+          var findFormat = function(currentFormat) { return currentFormat.country === countryCode; };
+          ibanFormat = ibanLib.formats.find(findFormat);
+      } else {
+          ibanFormat = faker.random.arrayElement(ibanLib.formats);
+      }
+
+      if (!ibanFormat) {
+          throw new Error('Country code ' + countryCode + ' not supported.');
+      }
+
+      var s = "";
+      var count = 0;
+      for (var b = 0; b < ibanFormat.bban.length; b++) {
+          var bban = ibanFormat.bban[b];
+          var c = bban.count;
+          count += bban.count;
+          while (c > 0) {
+              if (bban.type == "a") {
+                  s += faker.random.arrayElement(ibanLib.alpha);
+              } else if (bban.type == "c") {
+                  if (faker.datatype.number(100) < 80) {
+                      s += faker.datatype.number(9);
+                  } else {
+                      s += faker.random.arrayElement(ibanLib.alpha);
+                  }
+              } else {
+                  if (c >= 3 && faker.datatype.number(100) < 30) {
+                      if (faker.datatype.boolean()) {
+                          s += faker.random.arrayElement(ibanLib.pattern100);
+                          c -= 2;
+                      } else {
+                          s += faker.random.arrayElement(ibanLib.pattern10);
+                          c--;
+                      }
+                  } else {
+                      s += faker.datatype.number(9);
+                  }
+              }
+              c--;
+          }
+          s = s.substring(0, count);
+      }
+      var checksum = 98 - ibanLib.mod97(ibanLib.toDigitString(s + ibanFormat.country + "00"));
+      if (checksum < 10) {
+          checksum = "0" + checksum;
+      }
+      var iban = ibanFormat.country + checksum + s;
+      return formatted ? iban.match(/.{1,4}/g).join(" ") : iban;
+  };
+
+  /**
+   * bic
+   *
+   * @method  faker.finance.bic
+   */
+  self.bic = function () {
+      var vowels = ["A", "E", "I", "O", "U"];
+      var prob = faker.datatype.number(100);
+      return Helpers.replaceSymbols("???") +
+          faker.random.arrayElement(vowels) +
+          faker.random.arrayElement(ibanLib.iso3166) +
+          Helpers.replaceSymbols("?") + "1" +
+          (prob < 10 ?
+              Helpers.replaceSymbols("?" + faker.random.arrayElement(vowels) + "?") :
+          prob < 40 ?
+              Helpers.replaceSymbols("###") : "");
+  };
+
+  /**
+   * description
+   *
+   * @method  faker.finance.transactionDescription
+   */
+  self.transactionDescription = function() {
+    var transaction = Helpers.createTransaction();
+    var account = transaction.account;
+    var amount = transaction.amount;
+    var transactionType = transaction.type;
+    var company = transaction.business;
+    var card = faker.finance.mask();
+    var currency = faker.finance.currencyCode();
+    return transactionType + " transaction at " + company + " using card ending with ***" + card + " for " + currency + " " + amount + " in account ***" + account
+  };
+
+};
+
+module['exports'] = Finance;

node_modules/faker/lib/git.js

@@ -0,0 +1,87 @@
+/**
+ * @namespace faker.git
+ */
+
+var Git = function(faker) {
+  var self = this;
+  var f = faker.fake;
+
+  var hexChars = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
+
+  /**
+   * branch
+   *
+   * @method faker.git.branch
+   */
+  self.branch = function() {
+    var noun = faker.hacker.noun().replace(' ', '-');
+    var verb = faker.hacker.verb().replace(' ', '-');
+    return noun + '-' + verb;
+  }
+
+  /**
+   * commitEntry
+   *
+   * @method faker.git.commitEntry
+   * @param {object} options
+   */
+  self.commitEntry = function(options) {
+    options = options || {};
+
+    var entry = 'commit {{git.commitSha}}\r\n';
+
+    if (options.merge || (faker.datatype.number({ min: 0, max: 4 }) === 0)) {
+      entry += 'Merge: {{git.shortSha}} {{git.shortSha}}\r\n';
+    }
+
+    entry += 'Author: {{name.firstName}} {{name.lastName}} <{{internet.email}}>\r\n';
+    entry += 'Date: ' + faker.date.recent().toString() + '\r\n';
+    entry += '\r\n\xa0\xa0\xa0\xa0{{git.commitMessage}}\r\n';
+
+    return f(entry);
+  };
+
+  /**
+   * commitMessage
+   *
+   * @method faker.git.commitMessage
+   */
+  self.commitMessage = function() {
+    var format = '{{hacker.verb}} {{hacker.adjective}} {{hacker.noun}}';
+    return f(format);
+  };
+
+  /**
+   * commitSha
+   *
+   * @method faker.git.commitSha
+   */
+  self.commitSha = function() {
+    var commit = "";
+
+    for (var i = 0; i < 40; i++) {
+      commit += faker.random.arrayElement(hexChars);
+    }
+
+    return commit;
+  };
+
+  /**
+   * shortSha
+   *
+   * @method faker.git.shortSha
+   */
+  self.shortSha = function() {
+    var shortSha = "";
+
+    for (var i = 0; i < 7; i++) {
+      shortSha += faker.random.arrayElement(hexChars);
+    }
+
+    return shortSha;
+  };
+
+  return self;
+}
+
+module['exports'] = Git;

node_modules/faker/lib/hacker.js

@@ -0,0 +1,75 @@
+/**
+ *
+ * @namespace faker.hacker
+ */
+var Hacker = function (faker) {
+  var self = this;
+  
+  /**
+   * abbreviation
+   *
+   * @method faker.hacker.abbreviation
+   */
+  self.abbreviation = function () {
+    return faker.random.arrayElement(faker.definitions.hacker.abbreviation);
+  };
+
+  /**
+   * adjective
+   *
+   * @method faker.hacker.adjective
+   */
+  self.adjective = function () {
+    return faker.random.arrayElement(faker.definitions.hacker.adjective);
+  };
+
+  /**
+   * noun
+   *
+   * @method faker.hacker.noun
+   */
+  self.noun = function () {
+    return faker.random.arrayElement(faker.definitions.hacker.noun);
+  };
+
+  /**
+   * verb
+   *
+   * @method faker.hacker.verb
+   */
+  self.verb = function () {
+    return faker.random.arrayElement(faker.definitions.hacker.verb);
+  };
+
+  /**
+   * ingverb
+   *
+   * @method faker.hacker.ingverb
+   */
+  self.ingverb = function () {
+    return faker.random.arrayElement(faker.definitions.hacker.ingverb);
+  };
+
+  /**
+   * phrase
+   *
+   * @method faker.hacker.phrase
+   */
+  self.phrase = function () {
+
+    var data = {
+      abbreviation: self.abbreviation,
+      adjective: self.adjective,
+      ingverb: self.ingverb,
+      noun: self.noun,
+      verb: self.verb
+    };
+
+    var phrase = faker.random.arrayElement(faker.definitions.hacker.phrase);
+    return faker.helpers.mustache(phrase, data);
+  };
+  
+  return self;
+};
+
+module['exports'] = Hacker;

node_modules/faker/lib/helpers.js

@@ -0,0 +1,385 @@
+/**
+ *
+ * @namespace faker.helpers
+ */
+var Helpers = function (faker) {
+
+  var self = this;
+
+  /**
+   * backward-compatibility
+   *
+   * @method faker.helpers.randomize
+   * @param {array} array
+   */
+  self.randomize = function (array) {
+      array = array || ["a", "b", "c"];
+      return faker.random.arrayElement(array);
+  };
+
+  /**
+   * slugifies string
+   *
+   * @method faker.helpers.slugify
+   * @param {string} string
+   */
+  self.slugify = function (string) {
+      string = string || "";
+      return string.replace(/ /g, '-').replace(/[^\一-龠\ぁ-ゔ\ァ-ヴー\w\.\-]+/g, '');
+  };
+
+  /**
+   * parses string for a symbol and replace it with a random number from 1-10
+   *
+   * @method faker.helpers.replaceSymbolWithNumber
+   * @param {string} string
+   * @param {string} symbol defaults to `"#"`
+   */
+  self.replaceSymbolWithNumber = function (string, symbol) {
+      string = string || "";
+      // default symbol is '#'
+      if (symbol === undefined) {
+          symbol = '#';
+      }
+
+      var str = '';
+      for (var i = 0; i < string.length; i++) {
+          if (string.charAt(i) == symbol) {
+              str += faker.datatype.number(9);
+          } else if (string.charAt(i) == "!"){
+              str += faker.datatype.number({min: 2, max: 9});
+          } else {
+              str += string.charAt(i);
+          }
+      }
+      return str;
+  };
+
+  /**
+   * parses string for symbols (numbers or letters) and replaces them appropriately (# will be replaced with number,
+   * ? with letter and * will be replaced with number or letter)
+   *
+   * @method faker.helpers.replaceSymbols
+   * @param {string} string
+   */
+  self.replaceSymbols = function (string) {
+      string = string || "";
+      var alpha = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
+      var str = '';
+
+      for (var i = 0; i < string.length; i++) {
+          if (string.charAt(i) == "#") {
+              str += faker.datatype.number(9);
+          } else if (string.charAt(i) == "?") {
+              str += faker.random.arrayElement(alpha);
+          } else if (string.charAt(i) == "*") {
+            str += faker.datatype.boolean() ? faker.random.arrayElement(alpha) : faker.datatype.number(9);
+          } else {
+              str += string.charAt(i);
+          }
+      }
+      return str;
+  };
+
+  /**
+   * replace symbols in a credit card schems including Luhn checksum
+   *
+   * @method faker.helpers.replaceCreditCardSymbols
+   * @param {string} string
+   * @param {string} symbol
+   */
+
+   self.replaceCreditCardSymbols = function(string, symbol) {
+
+     // default values required for calling method without arguments
+     string = string || "6453-####-####-####-###L";
+     symbol = symbol || "#";
+
+     // Function calculating the Luhn checksum of a number string
+     var getCheckBit = function(number) {
+       number.reverse();
+       number = number.map(function(num, index){
+         if (index%2 === 0) {
+           num *= 2;
+           if(num>9) {
+             num -= 9;
+           }
+         }
+         return num;
+       });
+       var sum = number.reduce(function(prev,curr){return prev + curr;});
+       return sum % 10;
+     };
+
+     string = faker.helpers.regexpStyleStringParse(string); // replace [4-9] with a random number in range etc...
+     string = faker.helpers.replaceSymbolWithNumber(string, symbol); // replace ### with random numbers
+
+     var numberList = string.replace(/\D/g,"").split("").map(function(num){return parseInt(num);});
+     var checkNum = getCheckBit(numberList);
+     return string.replace("L",checkNum);
+   };
+
+   /** string repeat helper, alternative to String.prototype.repeat.... See PR #382
+   *
+   * @method faker.helpers.repeatString
+   * @param {string} string
+   * @param {number} num
+   */
+   self.repeatString = function(string, num) {
+     if(typeof num ==="undefined") {
+       num = 0;
+     }
+     var text = "";
+     for(var i = 0; i < num; i++){
+       text += string.toString();
+     }
+     return text;
+   };
+
+   /**
+    * parse string patterns in a similar way to RegExp
+    *
+    * e.g. "#{3}test[1-5]" -> "###test4"
+    *
+    * @method faker.helpers.regexpStyleStringParse
+    * @param {string} string
+    */
+   self.regexpStyleStringParse = function(string){
+     string = string || "";
+     // Deal with range repeat `{min,max}`
+     var RANGE_REP_REG = /(.)\{(\d+)\,(\d+)\}/;
+     var REP_REG = /(.)\{(\d+)\}/;
+     var RANGE_REG = /\[(\d+)\-(\d+)\]/;
+     var min, max, tmp, repetitions;
+     var token = string.match(RANGE_REP_REG);
+     while(token !== null){
+       min = parseInt(token[2]);
+       max =  parseInt(token[3]);
+       // switch min and max
+       if(min>max) {
+         tmp = max;
+         max = min;
+         min = tmp;
+       }
+       repetitions = faker.datatype.number({min:min,max:max});
+       string = string.slice(0,token.index) + faker.helpers.repeatString(token[1], repetitions) + string.slice(token.index+token[0].length);
+       token = string.match(RANGE_REP_REG);
+     }
+     // Deal with repeat `{num}`
+     token = string.match(REP_REG);
+     while(token !== null){
+       repetitions = parseInt(token[2]);
+       string = string.slice(0,token.index)+ faker.helpers.repeatString(token[1], repetitions) + string.slice(token.index+token[0].length);
+       token = string.match(REP_REG);
+     }
+     // Deal with range `[min-max]` (only works with numbers for now)
+     //TODO: implement for letters e.g. [0-9a-zA-Z] etc.
+
+     token = string.match(RANGE_REG);
+     while(token !== null){
+       min = parseInt(token[1]); // This time we are not capturing the char before `[]`
+       max =  parseInt(token[2]);
+       // switch min and max
+       if(min>max) {
+         tmp = max;
+         max = min;
+         min = tmp;
+       }
+        string = string.slice(0,token.index) +
+          faker.datatype.number({min:min, max:max}).toString() +
+          string.slice(token.index+token[0].length);
+        token = string.match(RANGE_REG);
+     }
+     return string;
+   };
+
+  /**
+   * takes an array and randomizes it in place then returns it
+   * 
+   * uses the modern version of the Fisher–Yates algorithm
+   *
+   * @method faker.helpers.shuffle
+   * @param {array} o
+   */
+  self.shuffle = function (o) {
+      if (typeof o === 'undefined' || o.length === 0) {
+        return o || [];
+      }
+      o = o || ["a", "b", "c"];
+      for (var x, j, i = o.length - 1; i > 0; --i) {
+        j = faker.datatype.number(i);
+        x = o[i];
+        o[i] = o[j];
+        o[j] = x;
+      }
+      return o;
+  };
+
+  /**
+   * mustache
+   *
+   * @method faker.helpers.mustache
+   * @param {string} str
+   * @param {object} data
+   */
+  self.mustache = function (str, data) {
+    if (typeof str === 'undefined') {
+      return '';
+    }
+    for(var p in data) {
+      var re = new RegExp('{{' + p + '}}', 'g')
+      str = str.replace(re, data[p]);
+    }
+    return str;
+  };
+
+  /**
+   * createCard
+   *
+   * @method faker.helpers.createCard
+   */
+  self.createCard = function () {
+      return {
+          "name": faker.name.findName(),
+          "username": faker.internet.userName(),
+          "email": faker.internet.email(),
+          "address": {
+              "streetA": faker.address.streetName(),
+              "streetB": faker.address.streetAddress(),
+              "streetC": faker.address.streetAddress(true),
+              "streetD": faker.address.secondaryAddress(),
+              "city": faker.address.city(),
+              "state": faker.address.state(),
+              "country": faker.address.country(),
+              "zipcode": faker.address.zipCode(),
+              "geo": {
+                  "lat": faker.address.latitude(),
+                  "lng": faker.address.longitude()
+              }
+          },
+          "phone": faker.phone.phoneNumber(),
+          "website": faker.internet.domainName(),
+          "company": {
+              "name": faker.company.companyName(),
+              "catchPhrase": faker.company.catchPhrase(),
+              "bs": faker.company.bs()
+          },
+          "posts": [
+              {
+                  "words": faker.lorem.words(),
+                  "sentence": faker.lorem.sentence(),
+                  "sentences": faker.lorem.sentences(),
+                  "paragraph": faker.lorem.paragraph()
+              },
+              {
+                  "words": faker.lorem.words(),
+                  "sentence": faker.lorem.sentence(),
+                  "sentences": faker.lorem.sentences(),
+                  "paragraph": faker.lorem.paragraph()
+              },
+              {
+                  "words": faker.lorem.words(),
+                  "sentence": faker.lorem.sentence(),
+                  "sentences": faker.lorem.sentences(),
+                  "paragraph": faker.lorem.paragraph()
+              }
+          ],
+          "accountHistory": [faker.helpers.createTransaction(), faker.helpers.createTransaction(), faker.helpers.createTransaction()]
+      };
+  };
+
+  /**
+   * contextualCard
+   *
+   * @method faker.helpers.contextualCard
+   */
+  self.contextualCard = function () {
+    var name = faker.name.firstName(),
+        userName = faker.internet.userName(name);
+    return {
+        "name": name,
+        "username": userName,
+        "avatar": faker.internet.avatar(),
+        "email": faker.internet.email(userName),
+        "dob": faker.date.past(50, new Date("Sat Sep 20 1992 21:35:02 GMT+0200 (CEST)")),
+        "phone": faker.phone.phoneNumber(),
+        "address": {
+            "street": faker.address.streetName(true),
+            "suite": faker.address.secondaryAddress(),
+            "city": faker.address.city(),
+            "zipcode": faker.address.zipCode(),
+            "geo": {
+                "lat": faker.address.latitude(),
+                "lng": faker.address.longitude()
+            }
+        },
+        "website": faker.internet.domainName(),
+        "company": {
+            "name": faker.company.companyName(),
+            "catchPhrase": faker.company.catchPhrase(),
+            "bs": faker.company.bs()
+        }
+    };
+  };
+
+
+  /**
+   * userCard
+   *
+   * @method faker.helpers.userCard
+   */
+  self.userCard = function () {
+      return {
+          "name": faker.name.findName(),
+          "username": faker.internet.userName(),
+          "email": faker.internet.email(),
+          "address": {
+              "street": faker.address.streetName(true),
+              "suite": faker.address.secondaryAddress(),
+              "city": faker.address.city(),
+              "zipcode": faker.address.zipCode(),
+              "geo": {
+                  "lat": faker.address.latitude(),
+                  "lng": faker.address.longitude()
+              }
+          },
+          "phone": faker.phone.phoneNumber(),
+          "website": faker.internet.domainName(),
+          "company": {
+              "name": faker.company.companyName(),
+              "catchPhrase": faker.company.catchPhrase(),
+              "bs": faker.company.bs()
+          }
+      };
+  };
+
+  /**
+   * createTransaction
+   *
+   * @method faker.helpers.createTransaction
+   */
+  self.createTransaction = function(){
+    return {
+      "amount" : faker.finance.amount(),
+      "date" : new Date(2012, 1, 2),  //TODO: add a ranged date method
+      "business": faker.company.companyName(),
+      "name": [faker.finance.accountName(), faker.finance.mask()].join(' '),
+      "type" : self.randomize(faker.definitions.finance.transaction_type),
+      "account" : faker.finance.account()
+    };
+  };
+
+  return self;
+
+};
+
+
+/*
+String.prototype.capitalize = function () { //v1.0
+    return this.replace(/\w+/g, function (a) {
+        return a.charAt(0).toUpperCase() + a.substr(1).toLowerCase();
+    });
+};
+*/
+
+module['exports'] = Helpers;

node_modules/faker/lib/image.js

@@ -0,0 +1,230 @@
+/**
+ *
+ * @namespace faker.image
+ * @property {object} lorempixel - faker.image.lorempixel
+ * @property {object} unsplash - faker.image.unsplash
+ * @property {object} unsplash - faker.image.lorempicsum
+ * @default Default provider is unsplash image provider
+ */
+var Image = function (faker) {
+
+  var self = this;
+  var Lorempixel = require('./image_providers/lorempixel');
+  var Unsplash = require('./image_providers/unsplash');
+  var LoremPicsum = require('./image_providers/lorempicsum');
+
+  /**
+   * image
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.image
+   */
+  self.image = function (width, height, randomize) {
+    var categories = ["abstract", "animals", "business", "cats", "city", "food", "nightlife", "fashion", "people", "nature", "sports", "technics", "transport"];
+    return self[faker.random.arrayElement(categories)](width, height, randomize);
+  };
+  /**
+   * avatar
+   *
+   * @method faker.image.avatar
+   */
+  self.avatar = function () {
+    return faker.internet.avatar();
+  };
+  /**
+   * imageUrl
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {string} category
+   * @param {boolean} randomize
+   * @method faker.image.imageUrl
+   */
+  self.imageUrl = function (width, height, category, randomize, https) {
+    var width = width || 640;
+    var height = height || 480;
+    var protocol = 'http://';
+    if (typeof https !== 'undefined' && https === true) {
+      protocol = 'https://';
+    }
+    var url = protocol + 'placeimg.com/' + width + '/' + height;
+    if (typeof category !== 'undefined') {
+      url += '/' + category;
+    }
+
+    if (randomize) {
+      url += '?' + faker.datatype.number()
+    }
+
+    return url;
+  };
+  /**
+   * abstract
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.abstract
+   */
+  self.abstract = function (width, height, randomize) {
+    return faker.image.imageUrl(width, height, 'abstract', randomize);
+  };
+  /**
+   * animals
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.animals
+   */
+  self.animals = function (width, height, randomize) {
+    return faker.image.imageUrl(width, height, 'animals', randomize);
+  };
+  /**
+   * business
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.business
+   */
+  self.business = function (width, height, randomize) {
+    return faker.image.imageUrl(width, height, 'business', randomize);
+  };
+  /**
+   * cats
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.cats
+   */
+  self.cats = function (width, height, randomize) {
+    return faker.image.imageUrl(width, height, 'cats', randomize);
+  };
+  /**
+   * city
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.city
+   */
+  self.city = function (width, height, randomize) {
+    return faker.image.imageUrl(width, height, 'city', randomize);
+  };
+  /**
+   * food
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.food
+   */
+  self.food = function (width, height, randomize) {
+    return faker.image.imageUrl(width, height, 'food', randomize);
+  };
+  /**
+   * nightlife
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.nightlife
+   */
+  self.nightlife = function (width, height, randomize) {
+    return faker.image.imageUrl(width, height, 'nightlife', randomize);
+  };
+  /**
+   * fashion
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.fashion
+   */
+  self.fashion = function (width, height, randomize) {
+    return faker.image.imageUrl(width, height, 'fashion', randomize);
+  };
+  /**
+   * people
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.people
+   */
+  self.people = function (width, height, randomize) {
+    return faker.image.imageUrl(width, height, 'people', randomize);
+  };
+  /**
+   * nature
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.nature
+   */
+  self.nature = function (width, height, randomize) {
+    return faker.image.imageUrl(width, height, 'nature', randomize);
+  };
+  /**
+   * sports
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.sports
+   */
+  self.sports = function (width, height, randomize) {
+    return faker.image.imageUrl(width, height, 'sports', randomize);
+  };
+  /**
+   * technics
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.technics
+   */
+  self.technics = function (width, height, randomize) {
+    return faker.image.imageUrl(width, height, 'technics', randomize);
+  };
+  /**
+   * transport
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.transport
+   */
+  self.transport = function (width, height, randomize) {
+    return faker.image.imageUrl(width, height, 'transport', randomize);
+  };
+  /**
+   * dataUri
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {string} color
+   * @method faker.image.dataUri
+   */
+  self.dataUri = function (width, height, color) {
+    color = color || 'grey';
+    var svgString = '<svg xmlns="http://www.w3.org/2000/svg" version="1.1" baseProfile="full" width="' + width + '" height="' + height + '"><rect width="100%" height="100%" fill="' + color + '"/><text x="' + width / 2 + '" y="' + height / 2 + '" font-size="20" alignment-baseline="middle" text-anchor="middle" fill="white">' + width + 'x' + height + '</text></svg>';
+    var rawPrefix = 'data:image/svg+xml;charset=UTF-8,';
+    return rawPrefix + encodeURIComponent(svgString);
+  };
+
+  self.lorempixel = new Lorempixel(faker);
+  self.unsplash = new Unsplash(faker);
+  self.lorempicsum = new LoremPicsum(faker);
+
+  // Object.assign(self, self.unsplash);
+  // How to set default as unsplash? should be image.default?
+}
+
+
+module["exports"] = Image;

node_modules/faker/lib/image_providers/lorempicsum.js

@@ -0,0 +1,108 @@
+/**
+ *
+ * @namespace lorempicsum
+ * @memberof faker.image
+ */
+var LoremPicsum = function (faker) {
+
+    var self = this;
+
+    /**
+     * image
+     *
+     * @param {number} width
+     * @param {number} height
+     * @param {boolean} grayscale
+     * @param {number} blur 1-10
+     * @method faker.image.lorempicsum.image
+     * @description search image from unsplash
+     */
+    self.image = function (width, height, grayscale, blur) {
+      return self.imageUrl(width, height, grayscale, blur);
+    };
+    /**
+     * imageGrayscaled
+     *
+     * @param {number} width
+     * @param {number} height
+     * @param {boolean} grayscale
+     * @method faker.image.lorempicsum.imageGrayscaled
+     * @description search grayscale image from unsplash
+     */
+    self.imageGrayscale = function (width, height, grayscale) {
+      return self.imageUrl(width, height, grayscale);
+    };
+    /**
+     * imageBlurred
+     *
+     * @param {number} width
+     * @param {number} height
+     * @param {number} blur 1-10
+     * @method faker.image.lorempicsum.imageBlurred
+     * @description search blurred image from unsplash
+     */
+    self.imageBlurred = function (width, height, blur) {
+      return self.imageUrl(width, height, undefined, blur);
+    };
+    /**
+     * imageRandomSeeded
+     *
+     * @param {number} width
+     * @param {number} height
+     * @param {boolean} grayscale
+     * @param {number} blur 1-10
+     * @param {string} seed
+     * @method faker.image.lorempicsum.imageRandomSeeded
+     * @description search same random image from unsplash, based on a seed
+     */
+    self.imageRandomSeeded = function (width, height, grayscale, blur, seed) {
+      return self.imageUrl(width, height, grayscale, blur, seed);
+    };
+    /**
+     * avatar
+     *
+     * @method faker.image.lorempicsum.avatar
+     */
+    self.avatar = function () {
+      return faker.internet.avatar();
+    };
+    /**
+     * imageUrl
+     *
+     * @param {number} width
+     * @param {number} height
+     * @param {boolean} grayscale
+     * @param {number} blur 1-10
+     * @param {string} seed
+     * @method faker.image.lorempicsum.imageUrl
+     */
+    self.imageUrl = function (width, height, grayscale, blur, seed) {
+        var width = width || 640;
+        var height = height || 480;
+  
+        var url = 'https://picsum.photos';
+          
+        if (seed) {
+          url += '/seed/' + seed;
+        }
+
+        url += '/' + width + '/' + height;
+        
+        if (grayscale && blur) {
+          return url + '?grayscale' + '&blur=' + blur;
+        }
+
+        if (grayscale) {
+          return url + '?grayscale';
+        }
+
+        if (blur) {
+          return url + '?blur=' + blur;
+        }
+    
+        return url;
+    };
+  }
+  
+  module["exports"] = LoremPicsum;
+  

node_modules/faker/lib/image_providers/lorempixel.js

@@ -0,0 +1,199 @@
+/**
+ *
+ * @namespace lorempixel
+ * @memberof faker.image
+ */
+var Lorempixel = function (faker) {
+
+  var self = this;
+
+  /**
+   * image
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.lorempixel.image
+   */
+  self.image = function (width, height, randomize) {
+    var categories = ["abstract", "animals", "business", "cats", "city", "food", "nightlife", "fashion", "people", "nature", "sports", "technics", "transport"];
+    return self[faker.random.arrayElement(categories)](width, height, randomize);
+  };
+  /**
+   * avatar
+   *
+   * @method faker.image.lorempixel.avatar
+   */
+  self.avatar = function () {
+    return faker.internet.avatar();
+  };
+  /**
+   * imageUrl
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {string} category
+   * @param {boolean} randomize
+   * @method faker.image.lorempixel.imageUrl
+   */
+  self.imageUrl = function (width, height, category, randomize) {
+      var width = width || 640;
+      var height = height || 480;
+
+      var url ='https://lorempixel.com/' + width + '/' + height;
+      if (typeof category !== 'undefined') {
+        url += '/' + category;
+      }
+
+      if (randomize) {
+        url += '?' + faker.datatype.number()
+      }
+
+      return url;
+  };
+  /**
+   * abstract
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.lorempixel.abstract
+   */
+  self.abstract = function (width, height, randomize) {
+    return faker.image.lorempixel.imageUrl(width, height, 'abstract', randomize);
+  };
+  /**
+   * animals
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.lorempixel.animals
+   */
+  self.animals = function (width, height, randomize) {
+    return faker.image.lorempixel.imageUrl(width, height, 'animals', randomize);
+  };
+  /**
+   * business
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.lorempixel.business
+   */
+  self.business = function (width, height, randomize) {
+    return faker.image.lorempixel.imageUrl(width, height, 'business', randomize);
+  };
+  /**
+   * cats
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.lorempixel.cats
+   */
+  self.cats = function (width, height, randomize) {
+    return faker.image.lorempixel.imageUrl(width, height, 'cats', randomize);
+  };
+  /**
+   * city
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.lorempixel.city
+   */
+  self.city = function (width, height, randomize) {
+    return faker.image.lorempixel.imageUrl(width, height, 'city', randomize);
+  };
+  /**
+   * food
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.lorempixel.food
+   */
+  self.food = function (width, height, randomize) {
+    return faker.image.lorempixel.imageUrl(width, height, 'food', randomize);
+  };
+  /**
+   * nightlife
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.lorempixel.nightlife
+   */
+  self.nightlife = function (width, height, randomize) {
+    return faker.image.lorempixel.imageUrl(width, height, 'nightlife', randomize);
+  };
+  /**
+   * fashion
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.lorempixel.fashion
+   */
+  self.fashion = function (width, height, randomize) {
+    return faker.image.lorempixel.imageUrl(width, height, 'fashion', randomize);
+  };
+  /**
+   * people
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.lorempixel.people
+   */
+  self.people = function (width, height, randomize) {
+    return faker.image.lorempixel.imageUrl(width, height, 'people', randomize);
+  };
+  /**
+   * nature
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.lorempixel.nature
+   */
+  self.nature = function (width, height, randomize) {
+    return faker.image.lorempixel.imageUrl(width, height, 'nature', randomize);
+  };
+  /**
+   * sports
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.lorempixel.sports
+   */
+  self.sports = function (width, height, randomize) {
+    return faker.image.lorempixel.imageUrl(width, height, 'sports', randomize);
+  };
+  /**
+   * technics
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.lorempixel.technics
+   */
+  self.technics = function (width, height, randomize) {
+    return faker.image.lorempixel.imageUrl(width, height, 'technics', randomize);
+  };
+  /**
+   * transport
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {boolean} randomize
+   * @method faker.image.lorempixel.transport
+   */
+  self.transport = function (width, height, randomize) {
+    return faker.image.lorempixel.imageUrl(width, height, 'transport', randomize);
+  }
+}
+
+module["exports"] = Lorempixel;

node_modules/faker/lib/image_providers/unsplash.js

@@ -0,0 +1,129 @@
+/**
+ *
+ * @namespace unsplash
+ * @memberof faker.image
+ */
+var Unsplash = function (faker) {
+
+  var self = this;
+  var categories = ["food", "nature", "people", "technology", "objects", "buildings"];
+
+  /**
+   * image
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {string} keyword
+   * @method faker.image.unsplash.image
+   * @description search image from unsplash
+   */
+  self.image = function (width, height, keyword) {
+    return self.imageUrl(width, height, undefined, keyword);
+  };
+  /**
+   * avatar
+   *
+   * @method faker.image.unsplash.avatar
+   */
+  self.avatar = function () {
+    return faker.internet.avatar();
+  };
+  /**
+   * imageUrl
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {string} category
+   * @param {string} keyword
+   * @method faker.image.unsplash.imageUrl
+   */
+  self.imageUrl = function (width, height, category, keyword) {
+      var width = width || 640;
+      var height = height || 480;
+
+      var url ='https://source.unsplash.com';
+
+      if (typeof category !== 'undefined') {
+          url += '/category/' + category;
+      }
+
+      url += '/' + width + 'x' + height;
+
+      if (typeof keyword !== 'undefined') {
+          var keywordFormat = new RegExp('^([A-Za-z0-9].+,[A-Za-z0-9]+)$|^([A-Za-z0-9]+)$');
+          if (keywordFormat.test(keyword)) {
+            url += '?' + keyword;
+          }
+      }
+
+      return url;
+  };
+  /**
+   * food
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {string} keyword
+   * @method faker.image.unsplash.food
+   */
+  self.food = function (width, height, keyword) {
+    return faker.image.unsplash.imageUrl(width, height, 'food', keyword);
+  };
+  /**
+   * people
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {string} keyword
+   * @method faker.image.unsplash.people
+   */
+  self.people = function (width, height, keyword) {
+    return faker.image.unsplash.imageUrl(width, height, 'people', keyword);
+  };
+  /**
+   * nature
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {string} keyword
+   * @method faker.image.unsplash.nature
+   */
+  self.nature = function (width, height, keyword) {
+    return faker.image.unsplash.imageUrl(width, height, 'nature', keyword);
+  };
+  /**
+   * technology
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {string} keyword
+   * @method faker.image.unsplash.technology
+   */
+  self.technology = function (width, height, keyword) {
+    return faker.image.unsplash.imageUrl(width, height, 'technology', keyword);
+  };
+  /**
+   * objects
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {string} keyword
+   * @method faker.image.unsplash.objects
+   */
+  self.objects = function (width, height, keyword) {
+    return faker.image.unsplash.imageUrl(width, height, 'objects', keyword);
+  };
+  /**
+   * buildings
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {string} keyword
+   * @method faker.image.unsplash.buildings
+   */
+  self.buildings = function (width, height, keyword) {
+    return faker.image.unsplash.imageUrl(width, height, 'buildings', keyword);
+  };
+}
+
+module["exports"] = Unsplash;

node_modules/faker/lib/index.js

@@ -0,0 +1,173 @@
+/*
+
+   this index.js file is used for including the faker library as a CommonJS module, instead of a bundle
+
+   you can include the faker library into your existing node.js application by requiring the entire /faker directory
+
+    var faker = require(./faker);
+    var randomName = faker.name.findName();
+
+   you can also simply include the "faker.js" file which is the auto-generated bundled version of the faker library
+
+    var faker = require(./customAppPath/faker);
+    var randomName = faker.name.findName();
+
+
+  if you plan on modifying the faker library you should be performing your changes in the /lib/ directory
+
+*/
+
+/**
+ *
+ * @namespace faker
+ */
+function Faker (opts) {
+
+  var self = this;
+
+  opts = opts || {};
+
+  // assign options
+  var locales = self.locales || opts.locales || {};
+  var locale = self.locale || opts.locale || "en";
+  var localeFallback = self.localeFallback || opts.localeFallback || "en";
+
+  self.locales = locales;
+  self.locale = locale;
+  self.localeFallback = localeFallback;
+
+  self.definitions = {};
+
+  var _definitions = {
+    "name": ["first_name", "last_name", "prefix", "suffix", "binary_gender", "gender", "title", "male_prefix", "female_prefix", "male_first_name", "female_first_name", "male_middle_name", "female_middle_name", "male_last_name", "female_last_name"],
+    "address": ["city_name", "city_prefix", "city_suffix", "street_suffix", "county", "country", "country_code", "country_code_alpha_3", "state", "state_abbr", "street_prefix", "postcode", "postcode_by_state", "direction", "direction_abbr", "time_zone"],
+    "animal": ["dog", "cat", "snake", "bear", "lion", "cetacean", "insect", "crocodilia", "cow", "bird", "fish", "rabbit", "horse", "type"],
+    "company": ["adjective", "noun", "descriptor", "bs_adjective", "bs_noun", "bs_verb", "suffix"],
+    "lorem": ["words"],
+    "hacker": ["abbreviation", "adjective", "noun", "verb", "ingverb", "phrase"],
+    "phone_number": ["formats"],
+    "finance": ["account_type", "transaction_type", "currency", "iban", "credit_card"],
+    "internet": ["avatar_uri", "domain_suffix", "free_email", "example_email", "password"],
+    "commerce": ["color", "department", "product_name", "price", "categories", "product_description"],
+    "database": ["collation", "column", "engine", "type"],
+    "system": ["mimeTypes", "directoryPaths"],
+    "date": ["month", "weekday"],
+    "vehicle": ["vehicle", "manufacturer", "model", "type", "fuel", "vin", "color"],
+    "music": ["genre"],
+    "title": "",
+    "separator": ""
+  };
+
+  // Create a Getter for all definitions.foo.bar properties
+  Object.keys(_definitions).forEach(function(d){
+    if (typeof self.definitions[d] === "undefined") {
+      self.definitions[d] = {};
+    }
+
+    if (typeof _definitions[d] === "string") {
+      self.definitions[d] = _definitions[d];
+      return;
+    }
+
+    _definitions[d].forEach(function(p){
+      Object.defineProperty(self.definitions[d], p, {
+        get: function () {
+          if (typeof self.locales[self.locale][d] === "undefined" || typeof self.locales[self.locale][d][p] === "undefined") {
+            // certain localization sets contain less data then others.
+            // in the case of a missing definition, use the default localeFallback to substitute the missing set data
+            // throw new Error('unknown property ' + d + p)
+            return self.locales[localeFallback][d][p];
+          } else {
+            // return localized data
+            return self.locales[self.locale][d][p];
+          }
+        }
+      });
+    });
+  });
+
+  var Fake = require('./fake');
+  self.fake = new Fake(self).fake;
+
+  var Unique = require('./unique');
+  self.unique = new Unique(self).unique;
+
+  var Mersenne = require('./mersenne');
+  self.mersenne = new Mersenne();
+
+  var Random = require('./random');
+  self.random = new Random(self);
+
+  var Helpers = require('./helpers');
+  self.helpers = new Helpers(self);
+
+  var Name = require('./name');
+  self.name = new Name(self);
+
+  var Address = require('./address');
+  self.address = new Address(self);
+
+  var Animal = require('./animal');
+  self.animal = new Animal(self);
+
+  var Company = require('./company');
+  self.company = new Company(self);
+
+  var Finance = require('./finance');
+  self.finance = new Finance(self);
+
+  var Image = require('./image');
+  self.image = new Image(self);
+
+  var Lorem = require('./lorem');
+  self.lorem = new Lorem(self);
+
+  var Hacker = require('./hacker');
+  self.hacker = new Hacker(self);
+
+  var Internet = require('./internet');
+  self.internet = new Internet(self);
+
+  var Database = require('./database');
+  self.database = new Database(self);
+
+  var Phone = require('./phone_number');
+  self.phone = new Phone(self);
+
+  var _Date = require('./date');
+  self.date = new _Date(self);
+
+  var _Time = require('./time');
+  self.time = new _Time(self);
+
+  var Commerce = require('./commerce');
+  self.commerce = new Commerce(self);
+
+  var System = require('./system');
+  self.system = new System(self);
+
+  var Git = require('./git');
+  self.git = new Git(self);
+
+  var Vehicle = require('./vehicle');
+  self.vehicle = new Vehicle(self);
+
+  var Music = require('./music');
+  self.music = new Music(self);
+
+  var Datatype = require('./datatype');
+  self.datatype = new Datatype(self);
+};
+
+Faker.prototype.setLocale = function (locale) {
+  this.locale = locale;
+}
+
+Faker.prototype.seed = function(value) {
+  var Random = require('./random');
+  var Datatype = require('./datatype');
+  this.seedValue = value;
+  this.random = new Random(this, this.seedValue);
+  this.datatype = new Datatype(this, this.seedValue);
+}
+module['exports'] = Faker;

node_modules/faker/lib/internet.js

@@ -0,0 +1,457 @@
+var random_ua = require('../vendor/user-agent');
+
+/**
+ *
+ * @namespace faker.internet
+ */
+var Internet = function (faker) {
+  var self = this;
+  /**
+   * avatar
+   *
+   * @method faker.internet.avatar
+   */
+  self.avatar = function () {
+    return 'https://cdn.fakercloud.com/avatars/' + faker.random.arrayElement(faker.definitions.internet.avatar_uri);
+  };
+
+  self.avatar.schema = {
+    "description": "Generates a URL for an avatar.",
+    "sampleResults": ["https://cdn.fakercloud.com/avatars/sydlawrence_128.jpg"]
+  };
+
+  /**
+   * email
+   *
+   * @method faker.internet.email
+   * @param {string} firstName
+   * @param {string} lastName
+   * @param {string} provider
+   */
+  self.email = function (firstName, lastName, provider) {
+    provider = provider || faker.random.arrayElement(faker.definitions.internet.free_email);
+    return  faker.helpers.slugify(faker.internet.userName(firstName, lastName)) + "@" + provider;
+  };
+
+  self.email.schema = {
+    "description": "Generates a valid email address based on optional input criteria",
+    "sampleResults": ["foo.bar@gmail.com"],
+    "properties": {
+      "firstName": {
+        "type": "string",
+        "required": false,
+        "description": "The first name of the user"
+      },
+      "lastName": {
+        "type": "string",
+        "required": false,
+        "description": "The last name of the user"
+      },
+      "provider": {
+        "type": "string",
+        "required": false,
+        "description": "The domain of the user"
+      }
+    }
+  };
+  /**
+   * exampleEmail
+   *
+   * @method faker.internet.exampleEmail
+   * @param {string} firstName
+   * @param {string} lastName
+   */
+  self.exampleEmail = function (firstName, lastName) {
+    var provider = faker.random.arrayElement(faker.definitions.internet.example_email);
+    return self.email(firstName, lastName, provider);
+  };
+
+  /**
+   * userName
+   *
+   * @method faker.internet.userName
+   * @param {string} firstName
+   * @param {string} lastName
+   */
+  self.userName = function (firstName, lastName) {
+    var result;
+    firstName = firstName || faker.name.firstName();
+    lastName = lastName || faker.name.lastName();
+    switch (faker.datatype.number(2)) {
+      case 0:
+        result = firstName + faker.datatype.number(99);
+        break;
+      case 1:
+        result = firstName + faker.random.arrayElement([".", "_"]) + lastName;
+        break;
+      case 2:
+        result = firstName + faker.random.arrayElement([".", "_"]) + lastName + faker.datatype.number(99);
+        break;
+    }
+    result = result.toString().replace(/'/g, "");
+    result = result.replace(/ /g, "");
+    return result;
+  };
+
+  self.userName.schema = {
+    "description": "Generates a username based on one of several patterns. The pattern is chosen randomly.",
+    "sampleResults": [
+      "Kirstin39",
+      "Kirstin.Smith",
+      "Kirstin.Smith39",
+      "KirstinSmith",
+      "KirstinSmith39",
+    ],
+    "properties": {
+      "firstName": {
+        "type": "string",
+        "required": false,
+        "description": "The first name of the user"
+      },
+      "lastName": {
+        "type": "string",
+        "required": false,
+        "description": "The last name of the user"
+      }
+    }
+  };
+
+  /**
+   * protocol
+   *
+   * @method faker.internet.protocol
+   */
+  self.protocol = function () {
+    var protocols = ['http','https'];
+    return faker.random.arrayElement(protocols);
+  };
+
+  self.protocol.schema = {
+    "description": "Randomly generates http or https",
+    "sampleResults": ["https", "http"]
+  };
+
+  /**
+   * method
+   *
+   * @method faker.internet.httpMethod
+   */
+  self.httpMethod = function () {
+    var httpMethods = ['GET','POST', 'PUT', 'DELETE', 'PATCH'];
+    return faker.random.arrayElement(httpMethods);
+  };
+
+  self.httpMethod.schema = {
+    "description": "Randomly generates HTTP Methods (GET, POST, PUT, DELETE, PATCH)",
+    "sampleResults": ["GET","POST", "PUT", "DELETE", "PATCH"]
+  };
+
+  /**
+   * url
+   *
+   * @method faker.internet.url
+   */
+  self.url = function () {
+    return faker.internet.protocol() + '://' + faker.internet.domainName();
+  };
+
+  self.url.schema = {
+    "description": "Generates a random URL. The URL could be secure or insecure.",
+    "sampleResults": [
+      "http://rashawn.name",
+      "https://rashawn.name"
+    ]
+  };
+
+  /**
+   * domainName
+   *
+   * @method faker.internet.domainName
+   */
+  self.domainName = function () {
+    return faker.internet.domainWord() + "." + faker.internet.domainSuffix();
+  };
+
+  self.domainName.schema = {
+    "description": "Generates a random domain name.",
+    "sampleResults": ["marvin.org"]
+  };
+
+  /**
+   * domainSuffix
+   *
+   * @method faker.internet.domainSuffix
+   */
+  self.domainSuffix = function () {
+    return faker.random.arrayElement(faker.definitions.internet.domain_suffix);
+  };
+
+  self.domainSuffix.schema = {
+    "description": "Generates a random domain suffix.",
+    "sampleResults": ["net"]
+  };
+
+  /**
+   * domainWord
+   *
+   * @method faker.internet.domainWord
+   */
+  self.domainWord = function () {
+    return faker.name.firstName().replace(/([\\~#&*{}/:<>?|\"'])/ig, '').toLowerCase();
+  };
+
+  self.domainWord.schema = {
+    "description": "Generates a random domain word.",
+    "sampleResults": ["alyce"]
+  };
+
+  /**
+   * ip
+   *
+   * @method faker.internet.ip
+   */
+  self.ip = function () {
+    var randNum = function () {
+      return (faker.datatype.number(255)).toFixed(0);
+    };
+
+    var result = [];
+    for (var i = 0; i < 4; i++) {
+      result[i] = randNum();
+    }
+
+    return result.join(".");
+  };
+
+  self.ip.schema = {
+    "description": "Generates a random IP.",
+    "sampleResults": ["97.238.241.11"]
+  };
+
+  /**
+   * ipv6
+   *
+   * @method faker.internet.ipv6
+   */
+  self.ipv6 = function () {
+    var randHash = function () {
+      var result = "";
+      for (var i = 0; i < 4; i++) {
+        result += (faker.random.arrayElement(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"]));
+      }
+      return result
+    };
+
+    var result = [];
+    for (var i = 0; i < 8; i++) {
+      result[i] = randHash();
+    }
+    return result.join(":");
+  };
+
+  self.ipv6.schema = {
+    "description": "Generates a random IPv6 address.",
+    "sampleResults": ["2001:0db8:6276:b1a7:5213:22f1:25df:c8a0"]
+  };
+
+  /**
+   * port
+   * 
+   * @method faker.internet.port
+   */
+  self.port = function() {
+    return faker.datatype.number({ min: 0, max: 65535 });
+  };
+
+  self.port.schema = {
+    "description": "Generates a random port number.",
+    "sampleResults": ["4422"]
+  };
+
+  /**
+   * userAgent
+   *
+   * @method faker.internet.userAgent
+   */
+  self.userAgent = function () {
+    return random_ua.generate(faker);
+  };
+
+  self.userAgent.schema = {
+    "description": "Generates a random user agent.",
+    "sampleResults": ["Mozilla/5.0 (Macintosh; U; PPC Mac OS X 10_7_5 rv:6.0; SL) AppleWebKit/532.0.1 (KHTML, like Gecko) Version/7.1.6 Safari/532.0.1"]
+  };
+
+  /**
+   * color
+   *
+   * @method faker.internet.color
+   * @param {number} baseRed255
+   * @param {number} baseGreen255
+   * @param {number} baseBlue255
+   */
+  self.color = function (baseRed255, baseGreen255, baseBlue255) {
+    baseRed255 = baseRed255 || 0;
+    baseGreen255 = baseGreen255 || 0;
+    baseBlue255 = baseBlue255 || 0;
+    // based on awesome response : http://stackoverflow.com/questions/43044/algorithm-to-randomly-generate-an-aesthetically-pleasing-color-palette
+    var red = Math.floor((faker.datatype.number(256) + baseRed255) / 2);
+    var green = Math.floor((faker.datatype.number(256) + baseGreen255) / 2);
+    var blue = Math.floor((faker.datatype.number(256) + baseBlue255) / 2);
+    var redStr = red.toString(16);
+    var greenStr = green.toString(16);
+    var blueStr = blue.toString(16);
+    return '#' +
+        (redStr.length === 1 ? '0' : '') + redStr +
+        (greenStr.length === 1 ? '0' : '') + greenStr +
+        (blueStr.length === 1 ? '0': '') + blueStr;
+
+  };
+
+  self.color.schema = {
+    "description": "Generates a random hexadecimal color.",
+    "sampleResults": ["#06267f"],
+    "properties": {
+      "baseRed255": {
+        "type": "number",
+        "required": false,
+        "description": "The red value. Valid values are 0 - 255."
+      },
+      "baseGreen255": {
+        "type": "number",
+        "required": false,
+        "description": "The green value. Valid values are 0 - 255."
+      },
+      "baseBlue255": {
+        "type": "number",
+        "required": false,
+        "description": "The blue value. Valid values are 0 - 255."
+      }
+    }
+  };
+
+  /**
+   * mac
+   *
+   * @method faker.internet.mac
+   * @param {string} sep
+   */
+  self.mac = function(sep){
+    var i, 
+      mac = "",
+      validSep = ':';
+
+    // if the client passed in a different separator than `:`, 
+    // we will use it if it is in the list of acceptable separators (dash or no separator)
+    if (['-', ''].indexOf(sep) !== -1) {
+      validSep = sep;
+    } 
+
+    for (i=0; i < 12; i++) {
+      mac+= faker.datatype.number(15).toString(16);
+      if (i%2==1 && i != 11) {
+        mac+=validSep;
+      }
+    }
+    return mac;
+  };
+
+  self.mac.schema = {
+    "description": "Generates a random mac address.",
+    "sampleResults": ["78:06:cc:ae:b3:81"]
+  };
+
+  /**
+   * password
+   *
+   * @method faker.internet.password
+   * @param {number} len
+   * @param {boolean} memorable
+   * @param {string} pattern
+   * @param {string} prefix
+   */
+  self.password = function (len, memorable, pattern, prefix) {
+    len = len || 15;
+    if (typeof memorable === "undefined") {
+      memorable = false;
+    }
+    /*
+      * password-generator ( function )
+      * Copyright(c) 2011-2013 Bermi Ferrer <bermi@bermilabs.com>
+      * MIT Licensed
+      */
+    var consonant, letter, vowel;
+    letter = /[a-zA-Z]$/;
+    vowel = /[aeiouAEIOU]$/;
+    consonant = /[bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ]$/;
+    var _password = function (length, memorable, pattern, prefix) {
+      var char, n;
+      if (length == null) {
+        length = 10;
+      }
+      if (memorable == null) {
+        memorable = true;
+      }
+      if (pattern == null) {
+        pattern = /\w/;
+      }
+      if (prefix == null) {
+        prefix = '';
+      }
+      if (prefix.length >= length) {
+        return prefix;
+      }
+      if (memorable) {
+        if (prefix.match(consonant)) {
+          pattern = vowel;
+        } else {
+          pattern = consonant;
+        }
+      }
+      n = faker.datatype.number(94) + 33;
+      char = String.fromCharCode(n);
+      if (memorable) {
+        char = char.toLowerCase();
+      }
+      if (!char.match(pattern)) {
+        return _password(length, memorable, pattern, prefix);
+      }
+      return _password(length, memorable, pattern, "" + prefix + char);
+    };
+    return _password(len, memorable, pattern, prefix);
+  }
+
+  self.password.schema = {
+    "description": "Generates a random password.",
+    "sampleResults": [
+      "AM7zl6Mg",
+      "susejofe"
+    ],
+    "properties": {
+      "length": {
+        "type": "number",
+        "required": false,
+        "description": "The number of characters in the password."
+      },
+      "memorable": {
+        "type": "boolean",
+        "required": false,
+        "description": "Whether a password should be easy to remember."
+      },
+      "pattern": {
+        "type": "regex",
+        "required": false,
+        "description": "A regex to match each character of the password against. This parameter will be negated if the memorable setting is turned on."
+      },
+      "prefix": {
+        "type": "string",
+        "required": false,
+        "description": "A value to prepend to the generated password. The prefix counts towards the length of the password."
+      }
+    }
+  };
+
+};
+
+
+module["exports"] = Internet;

node_modules/faker/lib/locales.js

@@ -0,0 +1,47 @@
+exports['az'] = require('./locales/az');
+exports['ar'] = require('./locales/ar');
+exports['cz'] = require('./locales/cz');
+exports['de'] = require('./locales/de');
+exports['de_AT'] = require('./locales/de_AT');
+exports['de_CH'] = require('./locales/de_CH');
+exports['en'] = require('./locales/en');
+exports['en_AU'] = require('./locales/en_AU');
+exports['en_AU_ocker'] = require('./locales/en_AU_ocker');
+exports['en_BORK'] = require('./locales/en_BORK');
+exports['en_CA'] = require('./locales/en_CA');
+exports['en_GB'] = require('./locales/en_GB');
+exports['en_IE'] = require('./locales/en_IE');
+exports['en_IND'] = require('./locales/en_IND');
+exports['en_US'] = require('./locales/en_US');
+exports['en_ZA'] = require('./locales/en_ZA');
+exports['es'] = require('./locales/es');
+exports['es_MX'] = require('./locales/es_MX');
+exports['he'] = require('./locales/he');
+exports['fa'] = require('./locales/fa');
+exports['fi'] = require('./locales/fi');
+exports['fr'] = require('./locales/fr');
+exports['fr_CA'] = require('./locales/fr_CA');
+exports['fr_CH'] = require('./locales/fr_CH');
+exports['ge'] = require('./locales/ge');
+exports['hy'] = require('./locales/hy');
+exports['hr'] = require('./locales/hr');
+exports['id_ID'] = require('./locales/id_ID');
+exports['it'] = require('./locales/it');
+exports['ja'] = require('./locales/ja');
+exports['ko'] = require('./locales/ko');
+exports['nb_NO'] = require('./locales/nb_NO');
+exports['ne'] = require('./locales/ne');
+exports['nl'] = require('./locales/nl');
+exports['nl_BE'] = require('./locales/nl_BE');
+exports['pl'] = require('./locales/pl');
+exports['pt_BR'] = require('./locales/pt_BR');
+exports['pt_PT'] = require('./locales/pt_PT');
+exports['ro'] = require('./locales/ro');
+exports['ru'] = require('./locales/ru');
+exports['sk'] = require('./locales/sk');
+exports['sv'] = require('./locales/sv');
+exports['tr'] = require('./locales/tr');
+exports['uk'] = require('./locales/uk');
+exports['vi'] = require('./locales/vi');
+exports['zh_CN'] = require('./locales/zh_CN');
+exports['zh_TW'] = require('./locales/zh_TW');

node_modules/faker/lib/locales/af_ZA/address/default_country.js

@@ -0,0 +1,3 @@
+module["exports"] = [
+  "South Africa"
+];

node_modules/faker/lib/locales/af_ZA/address/index.js

@@ -0,0 +1,4 @@
+var address = {};
+module['exports'] = address;
+address.default_country = require("./default_country");
+address.postcode = require("./postcode");

node_modules/faker/lib/locales/af_ZA/address/postcode.js

@@ -0,0 +1,4 @@
+module["exports"] = [
+  "#####",
+  "####"
+];

node_modules/faker/lib/locales/af_ZA/cell_phone/formats.js

@@ -0,0 +1,8 @@
+module["exports"] = [
+  "082 ### ####",
+  "084 ### ####",
+  "083 ### ####",
+  "065 ### ####",
+  "082#######",
+  "082 #######"
+];

node_modules/faker/lib/locales/af_ZA/cell_phone/index.js

@@ -0,0 +1,3 @@
+var cell_phone = {};
+module['exports'] = cell_phone;
+cell_phone.formats = require("./formats");

node_modules/faker/lib/locales/af_ZA/company/index.js

@@ -0,0 +1,3 @@
+var company = {};
+module['exports'] = company;
+company.suffix = require("./suffix");

node_modules/faker/lib/locales/af_ZA/company/suffix.js

@@ -0,0 +1,5 @@
+module["exports"] = [
+  "Pty Ltd",
+  "Ltd",
+  "CC"
+];

node_modules/faker/lib/locales/af_ZA/index.js

@@ -0,0 +1,8 @@
+var en_ZA = {};
+module['exports'] = en_ZA;
+en_ZA.title = "Afrikaans";
+en_ZA.address = require("./address");
+en_ZA.internet = require("./internet");
+en_ZA.phone_number = require("./phone_number");
+en_ZA.cell_phone = require("./cell_phone");
+en_ZA.company = require("./company");

node_modules/faker/lib/locales/af_ZA/internet/domain_suffix.js

@@ -0,0 +1,7 @@
+module["exports"] = [
+  "co.za",
+  "com",
+  "org.za",
+  "info",
+  "net.za"
+];

node_modules/faker/lib/locales/af_ZA/internet/index.js

@@ -0,0 +1,3 @@
+var internet = {};
+module['exports'] = internet;
+internet.domain_suffix = require("./domain_suffix");

node_modules/faker/lib/locales/af_ZA/name/female_first_name.js

@@ -0,0 +1,113 @@
+module["exports"] = [
+  "Susan",
+  "Monica",
+  "Linda",
+  "Elsa",
+  "Susan",
+  "Margaret",
+  "Lisa",
+  "Karen",
+  "Helen",
+  "Sandra",
+  "Sara",
+  "Kimberly",
+  "Angelique",
+  "Melissa",
+  "Brenda",
+  "Anna",
+  "Annelie",
+  "Katryn",
+  "Amanda",
+  "Stefanie",
+  "Marie",
+  "Janet",
+  "Rosemarie",
+  "Nicoleen",
+  "Paula",
+  "Robin",
+  "Rita",
+  "Edna",
+  "Carmen",
+  "Cindy",
+  "Edith",
+  "Ethel",
+  "Ellen",
+  "Elaine",
+  "Charlotte",
+  "Pauline",
+  "Juanita",
+  "Anita",
+  "Rhonda",
+  "Hazel",
+  "Debbie",
+  "Clara",
+  "Lucille",
+  "Eleanor",
+  "Alicia",
+  "Michele",
+  "Geraldine",
+  "Erika",
+  "Bernice",
+  "Audrey",
+  "Yvonne",
+  "Annette",
+  "Renette",
+  "Ida",
+  "Melanie",
+  "Jolanda",
+  "Vanessa",
+  "Alma",
+  "Sue-Marie",
+  "Elsa",
+  "Carla",
+  "Rosemary",
+  "Wilma",
+  "Kristin",
+  "Natalie",
+  "Charlene",
+  "Melinda",
+  "Maureen",
+  "Tanya",
+  "Marlene",
+  "Heidi",
+  "Lydia",
+  "Vickie",
+  "Nina",
+  "Leona",
+  "Jenny",
+  "Sonia",
+  "Kristina",
+  "Erika",
+  "Katrina",
+  "Belinda",
+  "Natasha",
+  "Cecile",
+  "Angie",
+  "Lynda",
+  "Amelia",
+  "Monique",
+  "Kayla",
+  "Yvette",
+  "Olivia",
+  "Antoinette",
+  "Bridgette",
+  "Karla",
+  "Leticia",
+  "Krista",
+  "Robyn",
+  "Rosalie",
+  "Bernadette",
+  "Krystal",
+  "Nadine",
+  "Estelle",
+  "Lynette",
+  "Eloise",
+  "Jana",
+  "Kerry",
+  "Jenna",
+  "Tasha",
+  "Sonja",
+  "Elsa",
+  "Elisa",
+  "Kristie"
+];

node_modules/faker/lib/locales/af_ZA/name/first_name.js

@@ -0,0 +1,227 @@
+module["exports"] = [
+  "Susan",
+  "Monica",
+  "Linda",
+  "Elsa",
+  "Susan",
+  "Margaret",
+  "Lisa",
+  "Karen",
+  "Helen",
+  "Sandra",
+  "Sara",
+  "Kimberly",
+  "Angelique",
+  "Melissa",
+  "Brenda",
+  "Anna",
+  "Annelie",
+  "Katryn",
+  "Amanda",
+  "Stefanie",
+  "Marie",
+  "Janet",
+  "Rosemarie",
+  "Nicoleen",
+  "Paula",
+  "Robin",
+  "Rita",
+  "Edna",
+  "Carmen",
+  "Cindy",
+  "Edith",
+  "Ethel",
+  "Ellen",
+  "Elaine",
+  "Charlotte",
+  "Pauline",
+  "Juanita",
+  "Anita",
+  "Rhonda",
+  "Hazel",
+  "Debbie",
+  "Clara",
+  "Lucille",
+  "Eleanor",
+  "Alicia",
+  "Michele",
+  "Geraldine",
+  "Erika",
+  "Bernice",
+  "Audrey",
+  "Yvonne",
+  "Annette",
+  "Renette",
+  "Ida",
+  "Melanie",
+  "Jolanda",
+  "Vanessa",
+  "Alma",
+  "Sue-Marie",
+  "Elsa",
+  "Carla",
+  "Rosemarie",
+  "Wilma",
+  "Kristin",
+  "Natalie",
+  "Charlene",
+  "Melinda",
+  "Maureen",
+  "Tanya",
+  "Marlene",
+  "Heidi",
+  "Lydia",
+  "Vickie",
+  "Nina",
+  "Leona",
+  "Jenny",
+  "Sonia",
+  "Kristina",
+  "Erika",
+  "Katrina",
+  "Belinda",
+  "Natasha",
+  "Cecile",
+  "Angie",
+  "Lynda",
+  "Amelia",
+  "Monique",
+  "Kayla",
+  "Yvette",
+  "Olivia",
+  "Antoinette",
+  "Bridgette",
+  "Karla",
+  "Leticia",
+  "Krista",
+  "Robyn",
+  "Rosalie",
+  "Bernadette",
+  "Krystal",
+  "Nadine",
+  "Estelle",
+  "Lynette",
+  "Eloise",
+  "Jana",
+  "Kerry",
+  "Jenna",
+  "Tasha",
+  "Sonja",
+  "Elsa",
+  "Elisa",
+  "Kristie",
+  "Johan",
+  "Robert",
+  "Michael",
+  "William",
+  "Willem",
+  "David",
+  "Richard",
+  "Thomas",
+  "Charl",
+  "Christopher",
+  "Daniel",
+  "Dante",
+  "Paul",
+  "Mark",
+  "George",
+  "Kenneth",
+  "Steven",
+  "Edward",
+  "Ronald",
+  "Anthony",
+  "Albert",
+  "Kevin",
+  "Jaco",
+  "Jacobus",
+  "Mathuys",
+  "Frankie",
+  "Stephen",
+  "Andre",
+  "Raymond",
+  "Joshua",
+  "Dennis",
+  "Pieter",
+  "Henrie",
+  "Rigard",
+  "Riaan",
+  "Joe",
+  "Johannes",
+  "Hannes",
+  "Gerald",
+  "Gerhard",
+  "Willie",
+  "Roy",
+  "Adam",
+  "Harry",
+  "Wayne",
+  "Billy",
+  "Steve",
+  "Louis",
+  "Eugene",
+  "Russell",
+  "Bobbie",
+  "Victor",
+  "Martin",
+  "Ernest",
+  "Phillip",
+  "Craig",
+  "Alan",
+  "Shawn",
+  "Chris",
+  "Earl",
+  "Jimmy",
+  "Brian",
+  "Mike",
+  "Leonard",
+  "Dale",
+  "Allen",
+  "Vincent",
+  "Francois",
+  "Eddie",
+  "Alexander",
+  "Bernard",
+  "Markus",
+  "Micheal",
+  "Theo",
+  "Oscar",
+  "Derek",
+  "Wesley",
+  "Derrick",
+  "Herman",
+  "Rick",
+  "Ruben",
+  "Cecil",
+  "Andre",
+  "Roland",
+  "Harvey",
+  "Adriaan",
+  "Karl",
+  "Erik",
+  "Neil",
+  "Ian",
+  "Iwan",
+  "Julian",
+  "Nick",
+  "Shaun",
+  "Cameron",
+  "Wilbur",
+  "Rudolph",
+  "Rudy",
+  "Bennie",
+  "Lukas",
+  "Simon",
+  "Rufus",
+  "Hugo",
+  "Conrad",
+  "Tommie",
+  "Jan",
+  "Jacques",
+  "Morne",
+  "Vernon",
+  "Duanne",
+  "Theunis",
+  "Theuns",
+  "Wessel",
+  "Stephaans"
+];

node_modules/faker/lib/locales/af_ZA/name/index.js

@@ -0,0 +1,6 @@
+var name = {};
+module['exports'] = name;
+name.male_first_name = require("./male_first_name");
+name.female_first_name = require("./female_first_name");
+name.first_name = require("./first_name");
+name.last_name = require("./last_name");

node_modules/faker/lib/locales/af_ZA/name/last_name.js

@@ -0,0 +1,167 @@
+module["exports"] = [
+  "van de Merwe",
+  "Schoeman",
+  "Barnard",
+  "de Kock",
+  "Meintjies",
+  "le Roux",
+  "Koen",
+  "Morkel",
+  "Viljoen",
+  "Smit",
+  "Nel",
+  "Grobelaar",
+  "Oppenheimer",
+  "Castelyn",
+  "du Preez",
+  "Cronnje",
+  "Donald",
+  "Pringle",
+  "Snell",
+  "Burger",
+  "van Heerden",
+  "van de Heefer",
+  "Wessels",
+  "Eksteen",
+  "Kirsten",
+  "de Villiers",
+  "Olivier",
+  "Steyn",
+  "Kallis",
+  "Ackerman",
+  "Dippenaar",
+  "Strydon",
+  "Boje",
+  "Pretorius",
+  "Langeveldt",
+  "Botha",
+  "Duminy",
+  "Fuller",
+  "Philander",
+  "Daniels",
+  "Fichardt",
+  "van Zyl",
+  "de Bruyn",
+  "van der Bijl",
+  "Dyer",
+  "van Buuren",
+  "Boyes",
+  "Versfeld",
+  "Bisset",
+  "Castens",
+  "Louw",
+  "Powell",
+  "Snedden",
+  "van Renen",
+  "Myburg",
+  "Bredenkamp",
+  "Mellett",
+  "Hertzog",
+  "Theunissen",
+  "de Waal",
+  "Cloete",
+  "Krige",
+  "Melker",
+  "Loubser",
+  "Stegmann",
+  "Joubert",
+  "Luyt",
+  "Roos",
+  "Lombard",
+  "van der Hoff",
+  "Immelman",
+  "Els",
+  "Delaney",
+  "Strauss",
+  "Meyer",
+  "Pienaar",
+  "du Plessis",
+  "van Rooyen",
+  "Kruger",
+  "Mostert",
+  "Scholtz",
+  "Aucamp",
+  "Albertyn",
+  "Bosman",
+  "Bester",
+  "Truter",
+  "Prinsloo",
+  "van Niekerk",
+  "Zimmerman",
+  "Venter",
+  "van den Berg",
+  "de Wet",
+  "Marais",
+  "van Jaarsveld",
+  "Jordaan",
+  "Malan",
+  "Viviers",
+  "Myburgh",
+  "Hoffman",
+  "Bekker",
+  "Rossouw",
+  "Rens",
+  "Lochner",
+  "Hanekom",
+  "Schmidt",
+  "Bekker",
+  "Wentzel",
+  "van Zyl",
+  "Bezuidenhout",
+  "Cilliers",
+  "Truter",
+  "Naude",
+  "de Vos",
+  "Goosen",
+  "Durand",
+  "Potgieter",
+  "van Deventer",
+  "de Klerk",
+  "Spies",
+  "Snyman",
+  "Oosthuizen",
+  "Bosch",
+  "Vogel",
+  "Fourie",
+  "van Staden",
+  "Wagenaar",
+  "Wolmerans",
+  "Veldsman",
+  "Tromp",
+  "Serfontein",
+  "Claasen",
+  "Heunis",
+  "Visagie",
+  "Ferreira",
+  "Erasmus",
+  "Knoetze",
+  "Jansen van Rensburg",
+  "Styger",
+  "Roberts",
+  "Richter",
+  "Lotter",
+  "Swart",
+  "Badenhorst",
+  "Laubscher",
+  "Hattingh",
+  "Visser",
+  "Brink",
+  "Theron",
+  "Paulse",
+  "Basson",
+  "van der Westhuyzen",
+  "Gerber",
+  "Human",
+  "Uys",
+  "Hougaard",
+  "Steenkamp",
+  "Pieterse",
+  "Brits",
+  "Jantjies",
+  "Etzebeth",
+  "de Jager",
+  "Boshoff",
+  "Kriel",
+  "Vosloo",
+  "Carstens"
+];

node_modules/faker/lib/locales/af_ZA/name/male_first_name.js

@@ -0,0 +1,116 @@
+module["exports"] = [
+  "Johan",
+  "Robert",
+  "Michael",
+  "William",
+  "Willem",
+  "David",
+  "Richard",
+  "Thomas",
+  "Charl",
+  "Christopher",
+  "Daniel",
+  "Dante",
+  "Paul",
+  "Mark",
+  "George",
+  "Kenneth",
+  "Steven",
+  "Edward",
+  "Ronald",
+  "Anthony",
+  "Albert",
+  "Kevin",
+  "Jaco",
+  "Jacobus",
+  "Mathuys",
+  "Frankie",
+  "Stephen",
+  "Andre",
+  "Raymond",
+  "Joshua",
+  "Dennis",
+  "Pieter",
+  "Henrie",
+  "Rigard",
+  "Riaan",
+  "Joe",
+  "Johannes",
+  "Hannes",
+  "Gerald",
+  "Gerhard",
+  "Willie",
+  "Roy",
+  "Adam",
+  "Harry",
+  "Wayne",
+  "Billy",
+  "Steve",
+  "Louis",
+  "Eugene",
+  "Russell",
+  "Bobbie",
+  "Victor",
+  "Martin",
+  "Ernest",
+  "Phillip",
+  "Craig",
+  "Alan",
+  "Shawn",
+  "Chris",
+  "Earl",
+  "Jimmy",
+  "Brian",
+  "Mike",
+  "Leonard",
+  "Dale",
+  "Allen",
+  "Vincent",
+  "Francois",
+  "Eddie",
+  "Alexander",
+  "Bernard",
+  "Markus",
+  "Micheal",
+  "Theo",
+  "Oscar",
+  "Derek",
+  "Wesley",
+  "Derrick",
+  "Herman",
+  "Rick",
+  "Ruben",
+  "Cecil",
+  "Andre",
+  "Roland",
+  "Harvey",
+  "Adriaan",
+  "Karl",
+  "Erik",
+  "Neil",
+  "Ian",
+  "Iwan",
+  "Julian",
+  "Nick",
+  "Shaun",
+  "Cameron",
+  "Wilbur",
+  "Rudolph",
+  "Rudy",
+  "Bennie",
+  "Lukas",
+  "Simon",
+  "Rufus",
+  "Hugo",
+  "Conrad",
+  "Tommie",
+  "Jan",
+  "Jacques",
+  "Morne",
+  "Vernon",
+  "Duanne",
+  "Theunis",
+  "Theuns",
+  "Wessel",
+  "Stephaans"
+];

node_modules/faker/lib/locales/af_ZA/phone_number/formats.js

@@ -0,0 +1,11 @@
+module["exports"] = [
+  "01# ### #####",
+  "02# ### #####",
+  "03# ### #####",
+  "04# ### #####",
+  "05# ### #####",
+  "0800 ### ###",
+  "0860 ### ###",
+  "01#########",
+  "01# ########",
+];

node_modules/faker/lib/locales/af_ZA/phone_number/index.js

@@ -0,0 +1,3 @@
+var phone_number = {};
+module['exports'] = phone_number;
+phone_number.formats = require("./formats");

node_modules/faker/lib/locales/ar/address/building_number.js

@@ -0,0 +1,5 @@
+module["exports"] = [
+  "#####",
+  "####",
+  "###"
+];

node_modules/faker/lib/locales/ar/address/city.js

@@ -0,0 +1,3 @@
+module["exports"] = [
+  "#{city_name}"
+];

node_modules/faker/lib/locales/ar/address/city_name.js

@@ -0,0 +1,144 @@
+module["exports"] = [
+  "مكة",
+  "المدينة",
+  "القاهرة",
+  "جدة",
+  "تونس",
+  "طرابلس",
+  "بيروت",
+  "الإسكندرية",
+  "بنغازي",
+  "صفاقس",
+  "مراكش",
+  "الدار البيضاء",
+  "غرناطة",
+  "فاس",
+  "وهران",
+  "الجزائر",
+  "الخرطوم",
+  "مقديشو",
+  "القدس",
+  "غزة",
+  "جنين",
+  "نابلس",
+  "دمشق",
+  "بغداد",
+  "البصرة",
+  "صلاح الدين",
+  "الكوفة",
+  "عمان",
+  "صنعاء",
+  "حضرموت",
+  "المنامة",
+  "صيدا",
+  "بنزرت",
+  "سوسة",
+  "نابل",
+  "الحمامات",
+  "جربة",
+  "حلب",
+  "الرياض",
+  "الدّمام",
+  "أبها",
+  "جازان",
+  "القطيف",
+  "الدرعية",
+  "عُنيزة",
+  "نجد",
+  "رابغ",
+  "دبي",
+  "العين",
+  "رأس الخيمة",
+  "أبو ظبي",
+  "عجمان",
+  "الفجيرة",
+  "الرويس",
+  "مصفح",
+  "دوز",
+  "السلع",
+  "الرحبة",
+  "الجهراء",
+  "الكويت",
+  "الفرْوانية",
+  "حَوَلِّـي",
+  "الأحمدي",
+  "الدوحة",
+  "الريان",
+  "دخان",
+  "الخور",
+  "أبو الظلوف",
+  "العريش",
+  "الغنيم",
+  "الغرية",
+  "الموصل",
+  "أربيل",
+  "نينوى",
+  "الأنبار",
+  "الحلة",
+  "سامراء",
+  "ذي قار",
+  "بابل",
+  "واسط",
+  "القادسية",
+  "العقبة",
+  "الكرك",
+  "إربد",
+  "عنجرة",
+  "المفرق",
+  "الفحيص",
+  "أريحا",
+  "يافا",
+  "عكا",
+  "رام الله",
+  "جنين",
+  "بيت لحم",
+  "الرملة",
+  "بيسان",
+  "صفد",
+  "قلقيلية",
+  "طولكرم",
+  "بيت حانون",
+  "صور",
+  "بعلبك",
+  "مرجعيون",
+  "عنجر",
+  "الخيام",
+  "الشرقية",
+  "حمص",
+  "اللاذقية",
+  "تدمر",
+  "حماة",
+  "طرسوس",
+  "بصرى",
+  "معرة النعمان",
+  "دير الزور",
+  "داريا",
+  "دوما",
+  "التل",
+  "إدلب",
+  "عدن",
+  "مأرب",
+  "إب",
+  "عمران",
+  "الشحر",
+  "البيضاء",
+  "بيحان",
+  "يريم",
+  "تريم",
+  "معبر",
+  "الضالع",
+  "بورسعيد",
+  "أسيوط",
+  "الأقصر",
+  "أسوان",
+  "العريش",
+  "المنيا",
+  "سوهاج",
+  "دمياط",
+  "قنا",
+  "سبك الأحد",
+  "نواكشوط",
+  "شمقيط",
+  "وادان",
+  "دورا"
+];

node_modules/faker/lib/locales/ar/address/country.js

@@ -0,0 +1,244 @@
+module["exports"] = [
+  "أفغانستان",
+  "ألبانيا",
+  "الجزائر",
+  "أمريكا ساماو",
+  "أندورا",
+  "أنجولا",
+  "أنجويلا",
+  "أنتاركتيكا",
+  "أنتيغوا وباربودا",
+  "الأرجنتين",
+  "أرمينيا",
+  "أروبا",
+  "أرستراليا",
+  "أستريا",
+  "أذرابيجان",
+  "بهماس",
+  "البحرين",
+  "بنغلادش",
+  "بربادوس",
+  "بلاروسيا",
+  "بلجيكا",
+  "بليز",
+  "بينين",
+  "برمودا",
+  "بوتان",
+  "بوليفيا",
+  "البوسنة والهرسك",
+  "بوتسوانا",
+  "جزيرة بوفيه",
+  "البرازيل",
+  "إقليم المحيط الهندي البريطاني",
+  "برونوي دار السلام",
+  "بلغاريا",
+  "بوركينا فاسو",
+  "بوروندي",
+  "كمبوديا",
+  "كاميرون",
+  "كندا",
+  "الرأس الأخضر",
+  "جزر كايمان",
+  "جمهورية إفريقيا الوسطى",
+  "التشاد",
+  "شيلي",
+  "الصين",
+  "جزيرة عيد الميلاد",
+  "جزر كوكوس",
+  "كولومبيا",
+  "جزر القمر",
+  "كونجو",
+  "جزر كوك",
+  "كوستا ريكا",
+  "ساحل العاج",
+  "كرواتيا",
+  "كوبا",
+  "قبرص",
+  "التشيك",
+  "دنمارك",
+  "جيبوتي",
+  "دومينيكا",
+  "جمهورية الدومينيكان",
+  "إكوادور",
+  "مصر",
+  "السلفادور",
+  "غينيا الاستوائية",
+  "إريتريا",
+  "إستونيا",
+  "أثيوبيا",
+  "جزر فارو",
+  "جزر فوكلاند",
+  "فيجي",
+  "فلندا",
+  "فرنست",
+  "غويانا الفرنسية",
+  "بولينزيا الفرنسية",
+  "أراض فرنسية جنوبية وأنتارتيكية",
+  "جابون",
+  "غمبيا",
+  "جورجيا",
+  "ألمانيا",
+  "غانا",
+  "جبل طارق",
+  "اليونان",
+  "الأرض الخضراء",
+  "غرينادا",
+  "غوادلوب",
+  "غوام",
+  "غواتيمالا",
+  "غيرنزي",
+  "غينيا",
+  "غينيا بيساو",
+  "غيانا",
+  "هايتي",
+  "جزيرة هيرد وجزر ماكدونالد",
+  "الفاتيكان",
+  "هندوراس",
+  "هونكونغ",
+  "هنقاريا",
+  "إسلاند",
+  "الهند",
+  "أندونيسيا",
+  "إيران",
+  "العراق",
+  "إيرلامدا",
+  "جزيرة مان",
+  "إيطاليا",
+  "جامايكا",
+  "اليابان",
+  "جيرزي",
+  "الأردن",
+  "كازاخستان",
+  "كنيا",
+  "كيريباتي",
+  "كوريا الشمالية",
+  "كوريا الجنوبية",
+  "الكويت",
+  "قيرغيزستان",
+  "لاوس",
+  "لتفيا",
+  "لبنان",
+  "ليسوتو",
+  "ليبيريا",
+  "ليبيا",
+  "ليختنشتاين",
+  "ليتيواتيا",
+  "ليكسمبورغ",
+  "ماكاو",
+  "مقدونيا",
+  "مدغشقر",
+  "ملاوي",
+  "ماليزيا",
+  "ملديف",
+  "مالي",
+  "مالطا",
+  "جزر مارشال",
+  "مارتينيك",
+  "موريتانيا",
+  "موريشيوس",
+  "مايوت",
+  "المكسيك",
+  "ولايات ميكرونيسيا المتحدة",
+  "مولدوفا",
+  "موناكو",
+  "منغوليا",
+  "مونتينيغرو",
+  "مونتسرات",
+  "المغرب",
+  "موزنبيق",
+  "ميانمار",
+  "ناميبيا",
+  "ناورو",
+  "نيبال",
+  "جزر الأنتيل الهولندية",
+  "هولاندا",
+  "كالودونيا الجديدة",
+  "زيلاندا الجديدة",
+  "نيكاراغوا",
+  "النيجر",
+  "نيجيريا",
+  "نييوي",
+  "جزيرة نورفولك",
+  "جزر ماريانا الشمالية",
+  "نورواي",
+  "عمان",
+  "باكستان",
+  "بالاو",
+  "فلسطين",
+  "بانما",
+  "بابوا غينيا الجديدة",
+  "باراغواي",
+  "بيرو",
+  "الفيليبين",
+  "جزر بيتكيرن",
+  "بولندا",
+  "البرتغال",
+  "بورتو ريكو",
+  "قطر",
+  "لا ريونيون",
+  "رومانيا",
+  "روسيا",
+  "روندا",
+  "سان بارتيلمي",
+  "سانت هيلانة",
+  "سانت كيتس ونيفيس",
+  "سانت لوسيا",
+  "سانت نرتان",
+  "سان بيير وميكلون",
+  "سانت فينسنت والغرينادين",
+  "ساماو",
+  "سان مارينو",
+  "ساو تومي وبرينسيب",
+  "السعودية",
+  "السنغال",
+  "صربيا",
+  "سيشال",
+  "سيراليون",
+  "سنغفورة",
+  "سلوفاكيا",
+  "سلوفينيا",
+  "جزر سليمان",
+  "الصومال",
+  "جنوب إفريقيا",
+  "جورجيا الجنوبية وجزر ساندويتش الجنوبية",
+  "إسبانيا",
+  "سيري لانكا",
+  "السودان",
+  "سيرينام",
+  "سفالبارد ويان ماين",
+  "سوازيلاند",
+  "السويد",
+  "سويسرا",
+  "سوريا",
+  "تايوات",
+  "طاجكستان",
+  "تنزانيا",
+  "تايلاند",
+  "تيمور الشرقية",
+  "توغو",
+  "توكيلاو",
+  "تونغوا",
+  "ترينيداد وتوباغو",
+  "تونس",
+  "تركيا",
+  "تركمنستان",
+  "جزر توركس وكايكوس",
+  "توفالو",
+  "أوغندا",
+  "أكرانيا",
+  "الإمارات العربية المتحدة",
+  "بريطانيا",
+  "أمريكا",
+  "جزر الولايات المتحدة الصغيرة النائية",
+  "أرغواي",
+  "أزباكستان",
+  "فانواتو",
+  "فينيزويلا",
+  "فيتنام",
+  "جزر العذراء البريطانية",
+  "جزر العذراء الأمريكية",
+  "واليس وفوتونا",
+  "اليمن",
+  "زمبيا",
+  "زمبابوي"
+];

node_modules/faker/lib/locales/ar/address/default_country.js

@@ -0,0 +1,3 @@
+module["exports"] = [
+  "المملكة العربية السعودية"
+];

node_modules/faker/lib/locales/ar/address/index.js

@@ -0,0 +1,12 @@
+var address = {};
+module['exports'] = address;
+address.country = require("./country");
+address.building_number = require("./building_number");
+address.secondary_address = require("./secondary_address");
+address.postcode = require("./postcode");
+address.postcode_by_state = require("./postcode_by_state");
+address.state = require("./state");
+address.city = require("./city");
+address.street_name = require("./street_name");
+address.street_address = require("./street_address");
+address.default_country = require("./default_country");

node_modules/faker/lib/locales/ar/address/postcode.js

@@ -0,0 +1,4 @@
+module["exports"] = [
+  "#####",
+  "#####-####"
+];

node_modules/faker/lib/locales/ar/address/postcode_by_state.js

@@ -0,0 +1,4 @@
+module["exports"] = [
+  "#####",
+  "#####-####"
+];

node_modules/faker/lib/locales/ar/address/secondary_address.js

@@ -0,0 +1,7 @@
+module["exports"] = [
+  "### عمارة",
+  "### طابق",
+  "### شقة",
+  "### بناية",
+  "### بيت"
+];

node_modules/faker/lib/locales/ar/address/state.js

@@ -0,0 +1,113 @@
+module["exports"] = [
+  "القدس",
+  "تل الربيع",
+  "صفد",
+  "أريحا",
+  "بئر السبع",
+  "غزة",
+  "نابلس",
+  "الناصرة",
+  "بيت لحم",
+  "الخليل",
+  "يافا",
+  "حيفا",
+  "اللد",
+  "الرملة",
+  "عكا",
+  "سخنين",
+  "قلنسوة",
+  "طيرة",
+  "عرابة",
+  "رام الله",
+  "طولكرم",
+  "بئر السبع ",
+  "تونس",
+  "بن عروس",
+  "أريانة",
+  "باجة",
+  "بنزرت",
+  "قابس",
+  "قفصة",
+  "جندوبة",
+  "القيروان",
+  "القصرين",
+  "قبلي",
+  "الكاف",
+  "المهدية",
+  "منوبة",
+  "مدنين",
+  "المنستير",
+  "نابل",
+  "صفاقس",
+  "بوزيد",
+  "سليانة",
+  "سوسة",
+  "تطاوين",
+  "توزر",
+  "زغوان",
+  "أدرار",
+  "الشلف",
+  "الأغواط",
+  "أم البواقي",
+  "باتنة",
+  "بجاية",
+  "بسكرة",
+  "بشار",
+  "البليدة",
+  "البويرة",
+  "تمنراست",
+  "تبسة",
+  "تلمسان",
+  "تيارت",
+  "تيزي وزو",
+  "الجزائر",
+  "الجلفة",
+  "جيجل",
+  "سطيف",
+  "سعيدة",
+  "سكيكدة",
+  "بلعباس",
+  "عنابة",
+  "قالمة",
+  "قسنطينة",
+  "المدية",
+  "عمان",
+  "الزرقاء",
+  "إربد",
+  "العقبة",
+  "السلط",
+  "المفرق",
+  "جرش",
+  "معان",
+  "عجلون",
+  "حلب",
+  "دمشق",
+  "حمص",
+  "اللاذقية",
+  "حماة",
+  "طرطوس",
+  "دير الزور",
+  "السويداء",
+  "الحسكة",
+  "درعا",
+  "إدلب",
+  "بيروت",
+  "طرابلس",
+  "صيدا",
+  "صور",
+  "النبطية",
+  "زحلة",
+  "جونيه",
+  "حبوش",
+  "بعلبك",
+  "بغداد",
+  "البصرة",
+  "نينوى",
+  "أربيل",
+  "النجف",
+  "كركوك",
+  "المثنى",
+  "القادسية",
+  " بابل",
+  "كربلاء",
+];

node_modules/faker/lib/locales/ar/address/street_address.js

@@ -0,0 +1,3 @@
+module["exports"] = [
+  "#{building_number} #{street_name}"
+];

node_modules/faker/lib/locales/ar/address/street_name.js

@@ -0,0 +1,4 @@
+module["exports"] = [
+  "#{street_prefix} #{Name.first_name}",
+  "#{street_prefix} #{Name.last_name}"
+];

node_modules/faker/lib/locales/ar/address/street_prefix.js

@@ -0,0 +1,10 @@
+module["exports"] = [
+  "درب، طريق",
+  "شارع",
+  "سبيل",
+  "جادة",
+  "رصيف",
+  "مَمَر",
+  "طريق مسدود",
+  "ساحة"
+];

node_modules/faker/lib/locales/ar/cell_phone/formats.js

@@ -0,0 +1,6 @@
+module["exports"] = [
+  "###-###-####",
+  "(###) ###-####",
+  "1-###-###-####",
+  "###.###.####"
+];

node_modules/faker/lib/locales/ar/cell_phone/index.js

@@ -0,0 +1,3 @@
+var cell_phone = {};
+module['exports'] = cell_phone;
+cell_phone.formats = require("./formats");

node_modules/faker/lib/locales/ar/commerce/color.js

@@ -0,0 +1,34 @@
+module["exports"] = [
+  "أحمر",
+  "أحمر غامق",
+  "أحمر فاتح",
+  "أخضر",
+  "أخضر غامق",
+  "أخضر فاتح",
+  "زيتوني",
+  "فيروزي",
+  "أزرق",
+  "أزرق غامق",
+  "أزرق فاتح",
+  "تركواز",
+  "أزرق سماوي",
+  "أصفر",
+  "ليموني",
+  "أرجواني",
+  "بنفسجي",
+  "أرجواني فاتح",
+  "أرجواني خفيف",
+  "أبيض",
+  "أسود",
+  "برتقالي",
+  "زهري",
+  "بني",
+  "كستنائي",
+  "أسمر",
+  "عاجي",
+  "نيلي",
+  "ذهبي",
+  "فضي",
+  "رمادي",
+  "رصاصي"
+];

node_modules/faker/lib/locales/ar/commerce/department.js

@@ -0,0 +1,22 @@
+module["exports"] = [
+  "كتب",
+  "ألعاب",
+  "إلكترونيات",
+  "حواسيب",
+  "بيت",
+  "حديقة",
+  "أدوات",
+  "بقالة",
+  "صحة",
+  "جمال",
+  "ألعاب",
+  "أطفال",
+  "رضع",
+  "ملابس",
+  "أحذية",
+  "مجوهرات",
+  "أغراض رياضية",
+  "في الهواء الطلق",
+  "السيارات",
+  "صناعة"
+];

node_modules/faker/lib/locales/ar/commerce/index.js

@@ -0,0 +1,5 @@
+var commerce = {};
+module["exports"] = commerce;
+commerce.color = require("./color");
+commerce.department = require("./department");
+commerce.product_name = require("./product_name");

node_modules/faker/lib/locales/ar/commerce/product_name.js

@@ -0,0 +1,59 @@
+module["exports"] = {
+  "adjective": [
+    "صغير",
+    "مريح",
+    "ريفي",
+    "ذكي",
+    "رائع",
+    "لا يصدق",
+    "عملي",
+    "أملس",
+    "ممتاز",
+    "عام",
+    "يدويا",
+    "صنع يدوي",
+    "مرخص",
+    "مشتق",
+    "بدون علامة",
+    "طيب المذاق"
+  ],
+  "material": [
+    "فولاذ",
+    "خشبي",
+    "خرسانة",
+    "بلاستيك",
+    "قطن",
+    "صوان",
+    "مطاط",
+    "معدن",
+    "ناعم",
+    "طازج",
+    "مجمد"
+  ],
+  "product": [
+    "كرسي",
+    "سيارة",
+    "حاسوب",
+    "لوحة المفاتيح",
+    "فأر",
+    "دراجة هوائية",
+    "كرة",
+    "قفازات",
+    "بنطال",
+    "قميص",
+    "طاولة",
+    "أحذية",
+    "قبعة",
+    "مناشف",
+    "صابون",
+    "تونة",
+    "دجاج",
+    "سمك",
+    "جبن",
+    "لحم خنزير مقدد",
+    "بيتزا",
+    "سلطة",
+    "سجق",
+    "رقائق بطاطس"
+  ]
+};

node_modules/faker/lib/locales/ar/date/index.js

@@ -0,0 +1,4 @@
+var date = {};
+module["exports"] = date;
+date.month = require("./month");
+date.weekday = require("./weekday");

node_modules/faker/lib/locales/ar/date/month.js

@@ -0,0 +1,63 @@
+// Source: http://unicode.org/cldr/trac/browser/tags/release-27/common/main/en.xml#L1799
+module["exports"] = {
+  wide: [
+    "كَانُون ٱلثَّانِي",
+    "شُبَاط",
+    "آذَار",
+    "نَيْسَان",
+    "أَيَّار",
+    "حَزِيرَان",
+    "تَمُّوز",
+    "آب",
+    "أَيْلُول",
+    "تِشْرِين ٱلْأَوَّل",
+    "تِشْرِين ٱلثَّانِي",
+    "كَانُون ٱلْأَوَّل",
+  ],
+  // Property "wide_context" is optional, if not set then "wide" will be used instead
+  // It is used to specify a word in context, which may differ from a stand-alone word
+  wide_context: [
+    "كَانُون ٱلثَّانِي",
+    "شُبَاط",
+    "آذَار",
+    "نَيْسَان",
+    "أَيَّار",
+    "حَزِيرَان",
+    "تَمُّوز",
+    "آب",
+    "أَيْلُول",
+    "تِشْرِين ٱلْأَوَّل",
+    "تِشْرِين ٱلثَّانِي",
+    "كَانُون ٱلْأَوَّل",
+  ],
+  abbr: [
+    "يناير",
+    "فبراير",
+    "مارس",
+    "إبريل",
+    "مايو",
+    "يونيو",
+    "يوليو",
+    "أغسطس",
+    "سبتمبر",
+    "أكتوبر",
+    "نوفمبر",
+    "ديسمبر",
+  ],
+  // Property "abbr_context" is optional, if not set then "abbr" will be used instead
+  // It is used to specify a word in context, which may differ from a stand-alone word
+  abbr_context: [
+    "يناير",
+    "فبراير",
+    "مارس",
+    "إبريل",
+    "مايو",
+    "يونيو",
+    "يوليو",
+    "أغسطس",
+    "سبتمبر",
+    "أكتوبر",
+    "نوفمبر",
+    "ديسمبر",
+  ],
+};

node_modules/faker/lib/locales/ar/date/weekday.js

@@ -0,0 +1,22 @@
+// Source: http://unicode.org/cldr/trac/browser/tags/release-27/common/main/en.xml#L1847
+module["exports"] = {
+  wide: [
+    "الأحَد",
+    "الإثنين",
+    "الثلاثاء",
+    "الأربعاء",
+    "الخميس",
+    "الجمعة",
+    "السبت",
+  ],
+
+  wide_context: [
+    "الأحَد",
+    "الإثنين",
+    "الثلاثاء",
+    "الأربعاء",
+    "الخميس",
+    "الجمعة",
+    "السبت",
+  ],
+};

node_modules/faker/lib/locales/ar/index.js

@@ -0,0 +1,12 @@
+var ar = {};
+module["exports"] = ar;
+ar.title = "Arabic";
+ar.separator = " & ";
+ar.address = require("./address");
+ar.name = require("./name");
+ar.phone_number = require("./phone_number");
+ar.cell_phone = require("./cell_phone");
+ar.commerce = require("./commerce");
+ar.vehicle = require("./vehicle");
+ar.team = require("./team");
+ar.date = require("./date");

node_modules/faker/lib/locales/ar/name/first_name.js

@@ -0,0 +1,329 @@
+module["exports"] = [
+  "محمد",
+  "أحمد",
+  "آسر",
+  "أركان",
+  "أسامة",
+  "أسعد",
+  "أشرف",
+  "أكرم",
+  "أليف",
+  "أمان",
+  "أمجد",
+  "أمير",
+  "أمين",
+  "أنس",
+  "أنيس",
+  "أوس",
+  "أيمن",
+  "إسلام",
+  "إيهاب",
+  "إياد",
+  "إياس",
+  "القاسم",
+  "المقداد",
+  "باسل",
+  "باسم",
+  "بدر",
+  "بدران",
+  "بركات",
+  "برهان",
+  "بسام",
+  "بسيم",
+  "بشار",
+  "بلال",
+  "بلبل",
+  "بليغ",
+  "بندر",
+  "بهيج",
+  "تميم",
+  "توفيق",
+  "تيسير",
+  "ثابت",
+  "جابر",
+  "جاد",
+  "جاسر",
+  "جاسم",
+  "جبريل",
+  "جسور",
+  "جعفر",
+  "جلال",
+  "جليل",
+  "جمال",
+  "جمعة",
+  "جميل",
+  "جهاد",
+  "جوهر",
+  "حاتم",
+  "حاجب",
+  "حارث",
+  "حازم",
+  "حافظ",
+  "حامد",
+  "حبيب",
+  "حذيفة",
+  "حسام",
+  "حسان",
+  "حسني",
+  "حسون",
+  "حطاب",
+  "حفيظ",
+  "حكيم",
+  "حلمي",
+  "حليم",
+  "حمدان",
+  "حمدي",
+  "حمزة",
+  "حمودة",
+  "حميد",
+  "حيدرة",
+  "خالد",
+  "خباب",
+  "خلدون",
+  "خليل",
+  "خيري",
+  "داوود",
+  "دريد",
+  "ديسم",
+  "ذاكر",
+  "رؤوف",
+  "رائد",
+  "رائف",
+  "رابح",
+  "راتب",
+  "راسم",
+  "راشد",
+  "راغب",
+  "راكان",
+  "رامز",
+  "رامي",
+  "ربيع",
+  "رتيب",
+  "رجب",
+  "رزق",
+  "رسلان",
+  "رشاد",
+  "رشدي",
+  "رشيد",
+  "رضا",
+  "رضوان",
+  "رعد",
+  "رفيع",
+  "رفيق",
+  "ركان",
+  "رمزي",
+  "رمضان",
+  "رنيم",
+  "رياض",
+  "ريان",
+  "زاهر",
+  "زياد",
+  "زيدون",
+  "زين الدين",
+  "سالم",
+  "سامح",
+  "سامر",
+  "سامي",
+  "سراج",
+  "سرحان",
+  "سرمد",
+  "سريج",
+  "سعد",
+  "سعيد",
+  "سفيان",
+  "سلامة",
+  "سلمان",
+  "سليم",
+  "سماح",
+  "سمير",
+  "سهيل",
+  "سيف",
+  "شادي",
+  "شاكر",
+  "شريف",
+  "شعبان",
+  "شفيع",
+  "شفيق",
+  "شكري",
+  "شكيب",
+  "شمس الدين",
+  "شهاب",
+  "شوقي",
+  "صابر",
+  "صادق",
+  "صبحي",
+  "صبري",
+  "صخر",
+  "صداح",
+  "صدقي",
+  "صفوان",
+  "صقر",
+  "صلاح",
+  "صهيب",
+  "ضياء",
+  "طارق",
+  "طاهر",
+  "طلال",
+  "طيب",
+  "ظافر",
+  "عادل",
+  "عارف",
+  "عاشور",
+  "عاصم",
+  "عاصي",
+  "عاطف",
+  "عامر",
+  "عباس",
+  "عثمان",
+  "عجمي",
+  "عدلان",
+  "عدلي",
+  "عدنان",
+  "عدي",
+  "عرفات",
+  "عرفان",
+  "عز الدين",
+  "عزام",
+  "عزمي",
+  "عزيز",
+  "عطا",
+  "عطية",
+  "عفيف",
+  "علاء",
+  "علوي",
+  "علي",
+  "عماد",
+  "عمار",
+  "عمر",
+  "عمران",
+  "عياض",
+  "غازي",
+  "غانم",
+  "غسان",
+  "غفار",
+  "غيث",
+  "فؤاد",
+  "فائز",
+  "فاخر",
+  "فادي",
+  "فارس",
+  "فاروق",
+  "فاضل",
+  "فاكر",
+  "فتاح",
+  "فتحي",
+  "فخري",
+  "فراس",
+  "فرج",
+  "فرحات",
+  "فريد",
+  "فضل",
+  "فضيل",
+  "فكري",
+  "فهد",
+  "فهمي",
+  "فواز",
+  "فوزي",
+  "فيصل",
+  "قاسم",
+  "قدري",
+  "قيس",
+  "كاظم",
+  "كامل",
+  "كرم",
+  "كمال",
+  "لبيب",
+  "لطفي",
+  "ليث",
+  "مأمون",
+  "مؤمن",
+  "مؤنس",
+  "ماجد",
+  "مازن",
+  "مبارك",
+  "مبروك",
+  "مجاهد",
+  "مجد",
+  "مجدي",
+  "مجيد",
+  "محجوب",
+  "محرز",
+  "محسن",
+  "محفوظ",
+  "محمود",
+  "مختار",
+  "مخلص",
+  "مراد",
+  "مرتضى",
+  "مرزوق",
+  "مرسي",
+  "مرشد",
+  "مرعي",
+  "مروان",
+  "مستعين",
+  "مسعد",
+  "مسعود",
+  "مصطفى",
+  "مصعب",
+  "مصلح",
+  "مطيع",
+  "معاذ",
+  "معتز",
+  "معز",
+  "معين",
+  "مفتاح",
+  "مقداد",
+  "ممتاز",
+  "ممدوح",
+  "منتصر",
+  "منذر",
+  "منصف",
+  "منصور",
+  "منعم",
+  "منيب",
+  "منير",
+  "مهدي",
+  "مهند",
+  "مهيب",
+  "ناجح",
+  "ناجي",
+  "نادر",
+  "ناصح",
+  "ناصر",
+  "ناصف",
+  "ناظم",
+  "نافع",
+  "نبيل",
+  "نجيب",
+  "نديم",
+  "نزار",
+  "نزيه",
+  "نسيم",
+  "نصحي",
+  "نصر",
+  "نضال",
+  "نعمان",
+  "نعيم",
+  "نهاد",
+  "نور الدين",
+  "نوري",
+  "نوفل",
+  "هاشم",
+  "هاني",
+  "هشام",
+  "هيثم",
+  "هيكل",
+  "وائل",
+  "واصف",
+  "وجدي",
+  "وديع",
+  "وسام",
+  "وسيم",
+  "وصفي",
+  "وليد",
+  "ياسر",
+  "ياسين",
+  "يافع",
+  "يامن",
+  "يحيى"
+];

node_modules/faker/lib/locales/ar/name/index.js

@@ -0,0 +1,7 @@
+var name = {};
+module['exports'] = name;
+name.first_name = require("./first_name");
+name.last_name = require("./last_name");
+name.prefix = require("./prefix");
+name.title = require("./title");
+name.name = require("./name");

node_modules/faker/lib/locales/ar/name/last_name.js

@@ -0,0 +1,80 @@
+module["exports"] = [
+  "يافع",
+  "هذيل",
+  "همدان",
+  "يافع",
+  "الأشراف",
+  "الكراي",
+  "الرقيق",
+  "بودوارة",
+  "خنفير",
+  "السقا",
+  "الطريقي",
+  "الشريف",
+  "المنيف",
+  "النفير",
+  "الشتيوي",
+  "الشيباني",
+  "الخليفي",
+  "المولدي",
+  "الكافي",
+  "العواني",
+  "بن عبد السلام",
+  "عاشور",
+  "النفطي",
+  "بن عثمان",
+  "بن عاشور",
+  "البشيري",
+  "السقاط",
+  "ادريس",
+  "بن حسين",
+  ,"القلشاني",
+  "الحجيج",
+  "بن عبد الكريم",
+  "فقوسة",
+  "بن حمودة",
+  "العنابي",
+  "القلال",
+  "الدنوني",
+  "النقاش",
+  "الغربي",
+  "نيفر",
+  "العطار",
+  "المحجوب",
+  "زقية",
+  "تومي",
+  "بن عبدالله",
+  "سعيد",
+  "النابلي",
+  "بن عمر",
+  "شنيق",
+  "عنون",
+  "الرصاع",
+  "النخلي",
+  "الصفار",
+  "الزوابي",
+  "العلاني",
+  "الع لويني",
+  "الحمامي",
+  "جاوحدو",
+  "شقرون",
+  "العلايمي",
+  "العواني",
+  "الصغير",
+  "جابالله",
+  "بنسلامة",
+  "جراد",
+  "بوديبة",
+  "الدرقاش",
+  "بوهاها",
+  "عطالله",
+  "سويس",
+  "عظومة",
+  "المدقي",
+  "الوحيشي",
+  "لخشين",
+  "زروق",
+  "النجار",
+  "غويلة",
+  "الطويل"
+];

node_modules/faker/lib/locales/ar/name/name.js

@@ -0,0 +1,5 @@
+module["exports"] = [
+  "#{prefix} #{first_name} #{last_name}",
+  "#{first_name} #{last_name}",
+  "#{last_name} #{first_name}"
+];

node_modules/faker/lib/locales/ar/name/prefix.js

@@ -0,0 +1,7 @@
+module["exports"] = [
+  "سيد",
+  "سيدة",
+  "آنسة",
+  "دكتور",
+  "بروفيسور"
+];

node_modules/faker/lib/locales/ar/name/title.js

@@ -0,0 +1,22 @@
+module["exports"] = {
+  "job": [
+    "مشرف",
+    "تنفيذي",
+    "مدير",
+    "مهندس",
+    "متخصص",
+    "رئيس مؤسسة",
+    "منسق",
+    "إداري",
+    "مخطط",
+    "محلل",
+    "مصمم",
+    "تقني",
+    "مبرمج",
+    "منتج",
+    "مستشار",
+    "مساعد",
+    "وكيل",
+    "متدرب"
+  ]
+};

node_modules/faker/lib/locales/ar/phone_number/formats.js

@@ -0,0 +1,22 @@
+module["exports"] = [
+  "###-###-####",
+  "(###) ###-####",
+  "1-###-###-####",
+  "###.###.####",
+  "###-###-####",
+  "(###) ###-####",
+  "1-###-###-####",
+  "###.###.####",
+  "###-###-#### x###",
+  "(###) ###-#### x###",
+  "1-###-###-#### x###",
+  "###.###.#### x###",
+  "###-###-#### x####",
+  "(###) ###-#### x####",
+  "1-###-###-#### x####",
+  "###.###.#### x####",
+  "###-###-#### x#####",
+  "(###) ###-#### x#####",
+  "1-###-###-#### x#####",
+  "###.###.#### x#####"
+];

node_modules/faker/lib/locales/ar/phone_number/index.js

@@ -0,0 +1,3 @@
+var phone_number = {};
+module['exports'] = phone_number;
+phone_number.formats = require("./formats");

node_modules/faker/lib/locales/ar/team/creature.js

@@ -0,0 +1,69 @@
+module["exports"] = [
+  "النمل",
+  "الخفافيش",
+  "تتحمل",
+  "النحل",
+  "الطيور",
+  "الجاموس",
+  "القطط",
+  "دجاجة",
+  "ماشية",
+  "الكلاب",
+  "الدلافين",
+  "البط",
+  "الفيلة",
+  "الأسماك",
+  "الثعالب",
+  "الضفادع",
+  "أوز",
+  "الماعز",
+  "خيل",
+  "الكنغر",
+  "الأسود",
+  "القرود",
+  "البوم",
+  "الثيران",
+  "طيور البطريق",
+  "اشخاص",
+  "الخنازير",
+  "الأرانب",
+  "خروف",
+  "النمور",
+  "الحيتان",
+  "الذئاب",
+  "حمار",
+  "الشؤم",
+  "الغربان",
+  "قطط سوداء",
+  "الوهم",
+  "أشباح",
+  "المتآمرين",
+  "التنين",
+  "الأقزام",
+  "الجان",
+  "السحرة",
+  "التعويذيون",
+  "أبناء",
+  "الأعداء",
+  "العمالقة",
+  "التماثيل",
+  "العفاريت",
+  "لحم الوز",
+  "العنقاء",
+  "استذئاب",
+  "عدو",
+  "الغيلان",
+  "أقوال",
+  "الأنبياء",
+  "السحرة",
+  "العناكب",
+  "معنويات",
+  "مصاصي دماء",
+  "السحرة",
+  "الثعالب",
+  "ذئاب ضارية",
+  "السحرة",
+  "عبدة",
+  "الاموات الاحياء",
+  "درويدس"
+];

node_modules/faker/lib/locales/ar/team/index.js

@@ -0,0 +1,4 @@
+var team = {};
+module['exports'] = team;
+team.creature = require("./creature");
+team.name = require("./name");

node_modules/faker/lib/locales/ar/team/name.js

@@ -0,0 +1,3 @@
+module["exports"] = [
+  "#{Address.state} #{creature}"
+];

node_modules/faker/lib/locales/ar/vehicle/fuel.js

@@ -0,0 +1 @@
+module["exports"] = ["ديزل", "كهربائي", "بنزين", "هجين"];

node_modules/faker/lib/locales/ar/vehicle/index.js

@@ -0,0 +1,7 @@
+var vehicle = {};
+
+module["exports"] = vehicle;
+vehicle.fuel = require("./fuel");
+vehicle.manufacturer = require("./manufacturer");
+vehicle.module = require("./model");
+vehicle.type = require("./vehicle_type");

node_modules/faker/lib/locales/ar/vehicle/manufacturer.js

@@ -0,0 +1,30 @@
+module["exports"] = [
+  "شيفروليه",
+  "كاديلاك",
+  "فورد",
+  "كرايسلر",
+  "دودج",
+  "جيب",
+  "تسلا",
+  "تويوتا",
+  "هوندا",
+  "نيسان",
+  "أودي",
+  "مرسيدس بنز",
+  "بي إم دبليو",
+  "فولكس واجن",
+  "بورش",
+  "جاكوار",
+  "استون مارتن",
+  "لاند روفر",
+  "بنتلي",
+  "ميني",
+  "رولزرويس",
+  "فيات",
+  "لامبورغيني",
+  "مازيراتي",
+  "فيراري",
+  "بوجاتي",
+  "كيا",
+  "هيونداي"
+];

node_modules/faker/lib/locales/ar/vehicle/model.js

@@ -0,0 +1,47 @@
+module["exports"] = [
+  "فييستا",
+  "التركيز",
+  "الثور",
+  "موستانج",
+  "اكسبلورر",
+  "البعثة",
+  "نموذج T",
+  "رانتشيرو",
+  "فولت",
+  "كروز",
+  "ماليبو",
+  "إمبالا",
+  "كامارو",
+  "كورفيت",
+  "كولورادو",
+  "سيلفرادو",
+  "ش كامينو",
+  "إسكاليد",
+  "جبال الألب",
+  "شاحن",
+  "لو بارون",
+  "بي تي كروزر",
+  "تشالنجر",
+  "دورانجو",
+  "القافلة الكبرى",
+  "رانجلر",
+  "جراند شيروكي",
+  "رودستر",
+  "عارضات ازياء",
+  "النموذج 3",
+  "كامري",
+  "بريوس",
+  "لاند كروزر",
+  "اتفاق",
+  "المدنية",
+  "جزء",
+  "سنترا",
+  "ألتيما",
+  "خنفساء",
+  "جيتا",
+  "جولف",
+  "سبايدر",
+  "الكونتاش",
+  "مورسيلاغو",
+  "أفينتادور"
+];

node_modules/faker/lib/locales/ar/vehicle/vehicle_type.js

@@ -0,0 +1,13 @@
+module["exports"] = [
+  "كارغو فان",
+  "مكشوفة",
+  "كوبيه",
+  "طاقم الكابينة بيك آب",
+  "تمديد الكابينة بيك آب",
+  "هاتشباك",
+  "ميني فان",
+  "سيارة الركاب",
+  "سيارة رياضية",
+  "سيدان",
+  "عربة"
+];

node_modules/faker/lib/locales/az/address/building_number.js

@@ -0,0 +1,3 @@
+module["exports"] = [
+  "###"
+];

node_modules/faker/lib/locales/az/address/city.js

@@ -0,0 +1,3 @@
+module["exports"] = [
+  "#{Address.city_name}"
+];

node_modules/faker/lib/locales/az/address/city_name.js

@@ -0,0 +1,80 @@
+module["exports"] = [
+  "Ağcabədi",
+  "Ağdam",
+  "Ağdaş",
+  "Ağdərə",
+  "Ağstafa",
+  "Ağsu",
+  "Astara",
+  "Bakı",
+  "Balakən",
+  "Beyləqan",
+  "Bərdə",
+  "Biləsuvar",
+  "Cəbrayıl",
+  "Cəlilabad",
+  "Culfa",
+  "Daşkəsən",
+  "Dəliməmmədli",
+  "Füzuli",
+  "Gədəbəy",
+  "Gəncə",
+  "Goranboy",
+  "Göyçay",
+  "Göygöl",
+  "Göytəpə",
+  "Hacıqabul",
+  "Horadiz",
+  "Xaçmaz",
+  "Xankəndi",
+  "Xocalı",
+  "Xocavənd",
+  "Xırdalan",
+  "Xızı",
+  "Xudat",
+  "İmişli",
+  "İsmayıllı",
+  "Kəlbəcər",
+  "Kürdəmir",
+  "Qax",
+  "Qazax",
+  "Qəbələ",
+  "Qobustan",
+  "Qovlar",
+  "Quba",
+  "Qubadlı",
+  "Qusar",
+  "Laçın",
+  "Lerik",
+  "Lənkəran",
+  "Liman",
+  "Masallı",
+  "Mingəçevir",
+  "Naftalan",
+  "Naxçıvan (şəhər)",
+  "Neftçala",
+  "Oğuz",
+  "Ordubad",
+  "Saatlı",
+  "Sabirabad",
+  "Salyan",
+  "Samux",
+  "Siyəzən",
+  "Sumqayıt",
+  "Şabran",
+  "Şahbuz",
+  "Şamaxı",
+  "Şəki",
+  "Şəmkir",
+  "Şərur",
+  "Şirvan",
+  "Şuşa",
+  "Tərtər",
+  "Tovuz",
+  "Ucar",
+  "Yardımlı",
+  "Yevlax",
+  "Zaqatala",
+  "Zəngilan",
+  "Zərdab"
+];

node_modules/faker/lib/locales/az/address/country.js

@@ -0,0 +1,241 @@
+module["exports"] = [
+  "Akrotiri və Dekeliya",
+  "Aland adaları",
+  "Albaniya",
+  "Almaniya",
+  "Amerika Samoası",
+  "Andorra",
+  "Angilya",
+  "Anqola",
+  "Antiqua və Barbuda",
+  "Argentina",
+  "Aruba",
+  "Avstraliya",
+  "Avstriya",
+  "Azərbaycan",
+  "Baham adaları",
+  "Banqladeş",
+  "Barbados",
+  "Belçika",
+  "Beliz",
+  "Belarus",
+  "Benin",
+  "Bermud adaları",
+  "BƏƏ",
+  "ABŞ",
+  "Boliviya",
+  "Bolqarıstan",
+  "Bosniya və Herseqovina",
+  "Botsvana",
+  "Böyük Britaniya",
+  "Braziliya",
+  "Bruney",
+  "Burkina-Faso",
+  "Burundi",
+  "Butan",
+  "Bəhreyn",
+  "Cersi",
+  "Cəbəli-Tariq",
+  "CAR",
+  "Cənubi Sudan",
+  "Cənubi Koreya",
+  "Cibuti",
+  "Çad",
+  "Çexiya",
+  "Monteneqro",
+  "Çili",
+  "ÇXR",
+  "Danimarka",
+  "Dominika",
+  "Dominikan Respublikası",
+  "Efiopiya",
+  "Ekvador",
+  "Ekvatorial Qvineya",
+  "Eritreya",
+  "Ermənistan",
+  "Estoniya",
+  "Əfqanıstan",
+  "Əlcəzair",
+  "Farer adaları",
+  "Fələstin Dövləti",
+  "Fici",
+  "Kot-d’İvuar",
+  "Filippin",
+  "Finlandiya",
+  "Folklend adaları",
+  "Fransa",
+  "Fransa Polineziyası",
+  "Gernsi",
+  "Gürcüstan",
+  "Haiti",
+  "Hindistan",
+  "Honduras",
+  "Honkonq",
+  "Xorvatiya",
+  "İndoneziya",
+  "İordaniya",
+  "İraq",
+  "İran",
+  "İrlandiya",
+  "İslandiya",
+  "İspaniya",
+  "İsrail",
+  "İsveç",
+  "İsveçrə",
+  "İtaliya",
+  "Kabo-Verde",
+  "Kamboca",
+  "Kamerun",
+  "Kanada",
+  "Kayman adaları",
+  "Keniya",
+  "Kipr",
+  "Kiribati",
+  "Kokos adaları",
+  "Kolumbiya",
+  "Komor adaları",
+  "Konqo Respublikası",
+  "KDR",
+  "Kosovo",
+  "Kosta-Rika",
+  "Kuba",
+  "Kuk adaları",
+  "Küveyt",
+  "Qabon",
+  "Qambiya",
+  "Qana",
+  "Qətər",
+  "Qayana",
+  "Qazaxıstan",
+  "Qərbi Sahara",
+  "Qırğızıstan",
+  "Qrenada",
+  "Qrenlandiya",
+  "Quam",
+  "Qvatemala",
+  "Qvineya",
+  "Qvineya-Bisau",
+  "Laos",
+  "Latviya",
+  "Lesoto",
+  "Liberiya",
+  "Litva",
+  "Livan",
+  "Liviya",
+  "Lixtenşteyn",
+  "Lüksemburq",
+  "Macarıstan",
+  "Madaqaskar",
+  "Makao",
+  "Makedoniya",
+  "Malavi",
+  "Malayziya",
+  "Maldiv adaları",
+  "Mali",
+  "Malta",
+  "Marşall adaları",
+  "Mavriki",
+  "Mavritaniya",
+  "Mayotta",
+  "Meksika",
+  "Men adası",
+  "Mərakeş",
+  "MAR",
+  "Mikroneziya",
+  "Milad adası",
+  "Misir",
+  "Myanma",
+  "Moldova",
+  "Monako",
+  "Monqolustan",
+  "Montserrat",
+  "Mozambik",
+  "Müqəddəs Yelena, Askenson və Tristan-da-Kunya adaları",
+  "Namibiya",
+  "Nauru",
+  "Nepal",
+  "Niderland",
+  "Niderland Antil adaları",
+  "Niger",
+  "Nigeriya",
+  "Nikaraqua",
+  "Niue",
+  "Norfolk adası",
+  "Norveç",
+  "Oman",
+  "Özbəkistan",
+  "Pakistan",
+  "Palau",
+  "Panama",
+  "Papua-Yeni Qvineya",
+  "Paraqvay",
+  "Peru",
+  "Pitkern adaları",
+  "Polşa",
+  "Portuqaliya",
+  "Prednestroviya",
+  "Puerto-Riko",
+  "Ruanda",
+  "Rumıniya",
+  "Rusiya",
+  "Salvador",
+  "Samoa",
+  "San-Marino",
+  "San-Tome və Prinsipi",
+  "Seneqal",
+  "Sen-Bartelemi",
+  "Sent-Kits və Nevis",
+  "Sent-Lüsiya",
+  "Sen-Marten",
+  "Sen-Pyer və Mikelon",
+  "Sent-Vinsent və Qrenadina",
+  "Serbiya",
+  "Seyşel adaları",
+  "Səudiyyə Ərəbistanı",
+  "Sinqapur",
+  "Slovakiya",
+  "Sloveniya",
+  "Solomon adaları",
+  "Somali",
+  "Somalilend",
+  "Sudan",
+  "Surinam",
+  "Suriya",
+  "Svazilend",
+  "Syerra-Leone",
+  "Şərqi Timor",
+  "Şimali Marian adaları",
+  "Şpisbergen və Yan-Mayen",
+  "Şri-Lanka",
+  "Tacikistan",
+  "Tanzaniya",
+  "Tailand",
+  "Çin Respublikası",
+  "Törks və Kaykos adaları",
+  "Tokelau",
+  "Tonqa",
+  "Toqo",
+  "Trinidad və Tobaqo",
+  "Tunis",
+  "Tuvalu",
+  "Türkiyə",
+  "Türkmənistan",
+  "Ukrayna",
+  "Uollis və Futuna",
+  "Uqanda",
+  "Uruqvay",
+  "Vanuatu",
+  "Vatikan",
+  "Venesuela",
+  "Amerika Virgin adaları",
+  "Britaniya Virgin adaları",
+  "Vyetnam",
+  "Yamayka",
+  "Yaponiya",
+  "Yeni Kaledoniya",
+  "Yeni Zelandiya",
+  "Yəmən",
+  "Yunanıstan",
+  "Zambiya",
+  "Zimbabve"
+];

node_modules/faker/lib/locales/az/address/default_country.js

@@ -0,0 +1,3 @@
+module["exports"] = [
+  "Azərbaycan"
+];

node_modules/faker/lib/locales/az/address/index.js

@@ -0,0 +1,14 @@
+var address = {};
+module['exports'] = address;
+address.country = require("./country");
+address.building_number = require("./building_number");
+address.street_suffix = require("./street_suffix");
+address.secondary_address = require("./secondary_address");
+address.postcode = require("./postcode");
+address.state = require("./state");
+address.street_title = require("./street_title");
+address.city_name = require("./city_name");
+address.city = require("./city");
+address.street_name = require("./street_name");
+address.street_address = require("./street_address");
+address.default_country = require("./default_country");

node_modules/faker/lib/locales/az/address/postcode.js

@@ -0,0 +1,3 @@
+module["exports"] = [
+  "AZ####"
+];

node_modules/faker/lib/locales/az/address/secondary_address.js

@@ -0,0 +1,3 @@
+module["exports"] = [
+  "m. ###"
+];

node_modules/faker/lib/locales/az/address/state.js

@@ -0,0 +1,3 @@
+module["exports"] = [
+
+];

node_modules/faker/lib/locales/az/address/street_address.js

@@ -0,0 +1,3 @@
+module["exports"] = [
+  "#{street_name}, #{building_number}"
+];

node_modules/faker/lib/locales/az/address/street_name.js

@@ -0,0 +1,4 @@
+module["exports"] = [
+  "#{street_suffix} #{Address.street_title}",
+  "#{Address.street_title} #{street_suffix}"
+];

node_modules/faker/lib/locales/az/address/street_suffix.js

@@ -0,0 +1,8 @@
+module["exports"] = [
+  "küç.",
+  "küçəsi",
+  "prospekti",
+  "pr.",
+  "sahəsi",
+  "sh."
+];

node_modules/faker/lib/locales/az/address/street_title.js

@@ -0,0 +1,237 @@
+module["exports"] = [
+  "Abbas Fətullayev",
+  "Abbas Mirzə Şərifzadə",
+  "Abbas Səhhət",
+  "Abdulla Şaiq",
+  "Afiyəddin Cəlilov",
+  "Axundov",
+  "Ağa Nemətulla",
+  "Ağadadaş Qurbanov",
+  "Akademik Həsən Əliyev",
+  "Akademik Lətif İmanov",
+  "Alı Mustafayev",
+  "Almas İldırım",
+  "Asəf Zeynallı",
+  "Asif Əsədullayev",
+  "Aşıq Alı",
+  "Aşıq Ələsgər",
+  "Azadlıq prospekti",
+  "Bakıxanov",
+  "Balababa Məcidov",
+  "Balaəmi Dadaşov",
+  "Behbud Şaxtantinski",
+  "Bəkir Çobanzadə",
+  "Bəsti Bağırova",
+  "Bəşir Səfəroğlu",
+  "Böyük Qala",
+  "Cabir Əliyev",
+  "Camal Hacıəliyev",
+  "Cavadxan",
+  "Cavanşir",
+  "Ceyhun Səlimov",
+  "Ceyhunbəy Hacıbəyli",
+  "Cəbiyev",
+  "Cəfər Xəndan",
+  "Cəfər Cabbarlı",
+  "Cəlal Qurbanov",
+  "Cəlil Məmmədquluzadə",
+  "Çingiz Mustafayev",
+  "Çobanzadə",
+  "Dadaş Bünyadzadə",
+  "Dağlı Yunus",
+  "Dilarə Əliyeva",
+  "Elçin Əzimov",
+  "Eldar və Abdulla Əlibəyovlar",
+  "Elxan Həsənov",
+  "Elşən Mehdiyev",
+  "Elşən Süleymanov",
+  "Etibar Bəkirov",
+  "Əbdüləzəl Dəmirçizadə",
+  "Əbdülhəsən Anaplı",
+  "Əbdülkərim Əlizadə",
+  "Əhməd bəy Ağaoğlu",
+  "Əhməd Cavad",
+  "Əhməd Cəmil",
+  "Əhməd Mehbalıyev",
+  "Əhməd Rəcəbli",
+  "Əjdər Xanbabayev",
+  "Əkrəm Cəfərov",
+  "Ələsgər Qayıbov",
+  "Əliağa Vahid",
+  "Əli Bəy Hüseynzadə",
+  "Əlimərdan bəy Topçubaşov",
+  "Əliyar Əliyev",
+  "Əlövsət Abdulrəhimov",
+  "Əlövsət Quliyev",
+  "Əmir Bağırov",
+  "Əsəd Əhmədov",
+  "Əşrəf Yunusov",
+  "Əzim Əzimzadə",
+  "Əziz Əliyev",
+  "Heybət Heybətov",
+  "Həqiqət Rzayeva",
+  "Həmid Araslı",
+  "Hənifə Ələsgərova",
+  "Hərbçilər",
+  "Həsənoğu",
+  "Həsən Seyidbəyli",
+  "Hətəm Allahverdiyev",
+  "Həzi Aslanov",
+  "Hüsü Hacıyev",
+  "Hüseynqulu Sarabski",
+  "Fətəli xan Xoyski",
+  "Fəzail Bayramov",
+  "Fikrət Əmirov",
+  "Fuad İbrahimbəyov",
+  "Fuad Yusifov",
+  "General Əliağa Şıxlinski",
+  "Gülayə Qədirbəyova",
+  "Gənclik",
+  "Xaqani",
+  "Xan Şuşinski",
+  "Xanlar",
+  "Xudu Məmmədov",
+  "İbrahimpaşa Dadaşov",
+  "İdris Süleymanov",
+  "İlqar Abbasov",
+  "İlqar İsmayılov",
+  "İmran Qasımov",
+  "İnqilab İsmayılov",
+  "İsfəndiyar Zülalov",
+  "İslam Abışov",
+  "İslam Səfərli",
+  "İsmayıl bəy Qutqaşınlı",
+  "İsmayıl Mirzəgülov",
+  "İstiqlaliyyət",
+  "28 May",
+  "İsgəndərov",
+  "İvan Turgenev",
+  "İzmir",
+  "İzzət Həmidov",
+  "İzzət Orucova",
+  "Kamal Rəhimov",
+  "Kazım Kazımzadə",
+  "Kazımağa Kərimov",
+  "Kərəm İsmayılov",
+  "Kiçik Qala",
+  "Koroğlu Rəhimov",
+  "Qaçaq Nəbi",
+  "Qarabağ",
+  "Qədirbəyov",
+  "Qəzənfər Musabəyov",
+  "Qəzənfər Vəliyev",
+  "Leyla Məmmədbəyova",
+  "Mahmud İbrahimov",
+  "Malik Məmmədov",
+  "Mehdi Abbasov",
+  "Mehdi Mehdizadə",
+  "Məhəmməd Əmin Rəsulzadə",
+  "Məhəmməd Hadi",
+  "Məhəmməd Xiyabani",
+  "Məhəmməd ibn Hinduşah Naxçıvani",
+  "Məhsəti Gəncəvi",
+  "Məmmədyarov",
+  "Mərdanov qardaşları",
+  "Mətləb Ağayev",
+  "Məşədi Hilal",
+  "Məzahir Rüstəmov",
+  "Mikayıl Müşviq",
+  "Mingəçevir",
+  "Mirəli Qaşqay",
+  "Mirəli Seyidov",
+  "Mirzağa Əliyev",
+  "Mirzə İbrahimov",
+  "Mirzə Mənsur",
+  "Mirzə Mustafayev",
+  "Murtuza Muxtarov",
+  "Mustafa Topçubaşov",
+  "Müqtədir Aydınbəyov",
+  "Müslüm Maqomayev",
+  "Müzəffər Həsənov",
+  "Nabat Aşurbəyova",
+  "Naxçıvani",
+  "Naximov",
+  "Nazim İsmaylov",
+  "Neapol",
+  "Neftçi Qurban Abbasov",
+  "Neftçilər prospekti",
+  "Nəcəfbəy Vəzirov",
+  "Nəcəfqulu Rəfiyev",
+  "Nəriman Nərimanov",
+  "Nəsirəddin Tusi",
+  "Nigar Rəfibəyli",
+  "Niyazi",
+  "Nizami",
+  "Nizami Abdullayev",
+  "Nobel prospekti",
+  "Novruz",
+  "Novruzov qardaşları",
+  "Oqtay Vəliyev",
+  "Parlament",
+  "Puşkin",
+  "Rafiq Ağayev",
+  "Ramiz Qəmbərov",
+  "Rəşid Behbudov",
+  "Rəşid Məcidov",
+  "Ruhulla Axundov",
+  "Ruslan Allahverdiyev",
+  "Rüstəm Rüstəmov",
+  "Tahir Bağırov",
+  "Tarzan Hacı Məmmədov",
+  "Tbilisi prospekti",
+  "Təbriz (Bakı)",
+  "Təbriz Xəlilbəyli",
+  "Tofiq Məmmədov",
+  "Tolstoy",
+  "Sabit Orucov",
+  "Sabit Rəhman",
+  "Sahib Hümmətov",
+  "Salatın Əsgərova",
+  "Sarayevo",
+  "Seyid Əzim Şirvani",
+  "Seyid Şuşinski",
+  "Seyidov",
+  "Səməd bəy Mehmandarov",
+  "Səməd Vurğun",
+  "Səttar Bəhlulzadə",
+  "Sona xanım Vəlixanlı",
+  "Sübhi Salayev",
+  "Süleyman Əhmədov",
+  "Süleyman Rəhimov",
+  "Süleyman Rüstəm",
+  "Süleyman Sani Axundov",
+  "Süleyman Vəzirov",
+  "Şahin Səmədov",
+  "Şamil Əzizbəyov",
+  "Şamil Kamilov",
+  "Şeyx Şamil",
+  "Şəfayət Mehdiyev",
+  "Şəmsi Bədəlbəyli",
+  "Şirin Mirzəyev",
+  "Şıxəli Qurbanov",
+  "Şövkət Ələkbərova",
+  "Ülvi Bünyadzadə",
+  "Üzeyir Hacıbəyov",
+  "Vasif Əliyev",
+  "Vəli Məmmədov",
+  "Vladislav Plotnikov",
+  "Vüqar Quliyev",
+  "Vunq Tau",
+  "Yaqub Əliyev",
+  "Yaşar Abdullayev",
+  "Yaşar Əliyev",
+  "Yavər Əliyev",
+  "Yesenin",
+  "Yəhya Hüseynov",
+  "Yılmaz Axundzadə",
+  "Yüsif Eyvazov",
+  "Yusif Qasımov",
+  "Yusif Məmmədəliyev",
+  "Yusif Səfərov",
+  "Yusif Vəzir Çəmənzəminli",
+  "Zahid Əliyev",
+  "Zahid Xəlilov",
+  "Zaur Kərimov",
+  "Zavod",
+  "Zərgərpalan"
+];

node_modules/faker/lib/locales/az/commerce/color.js

@@ -0,0 +1,20 @@
+module["exports"] = [
+  "ala",
+  "açıq bənövşəyi",
+  "ağ",
+  "mavi",
+  "boz",
+  "bənövşəyi",
+  "göy rəng",
+  "gümüşü",
+  "kardinal",
+  "narıncı",
+  "qara",
+  "qırmızı",
+  "qəhvəyi",
+  "tünd göy",
+  "tünd qırmızı",
+  "xlorofil",
+  "yaşıl",
+  "çəhrayı"
+];

node_modules/faker/lib/locales/az/commerce/department.js

@@ -0,0 +1,20 @@
+module["exports"] = [
+  "Kitablar",
+  "Filmlər",
+  "musiqi",
+  "oyunlar",
+  "Elektronika",
+  "Kompyuterlər",
+  "Ev",
+  "садинструмент",
+  "Səhiyyə",
+  "gözəllik",
+  "Oyuncaqlar",
+  "uşaq üçün",
+  "Geyim",
+  "Ayyaqqabı",
+  "bəzək",
+  "İdman",
+  "turizm",
+  "Avtomobil",
+];

node_modules/faker/lib/locales/az/commerce/index.js

@@ -0,0 +1,5 @@
+var commerce = {};
+module['exports'] = commerce;
+commerce.color = require("./color");
+commerce.department = require("./department");
+commerce.product_name = require("./product_name");

node_modules/faker/lib/locales/az/commerce/product_name.js

@@ -0,0 +1,33 @@
+module["exports"] = {
+  "adjective": [
+    "Balaca",
+    "Ergonomik",
+    "Kobud",
+    "İntellektual",
+    "Möhtəşəm",
+    "İnanılmaz",
+    "Fantastik",
+    "Əlverişli",
+    "Parlaq",
+    "Mükəmməl"
+  ],
+  "material": [
+    "Polad",
+    "Ağac",
+    "Beton",
+    "Plastik",
+    "Pambıq",
+    "Qranit",
+    "Rezin"
+  ],
+  "product": [
+    "Stul",
+    "Avtomobil",
+    "Kompyuter",
+    "Beret",
+    "Kulon",
+    "Stol",
+    "Sviter",
+    "Kəmər"
+  ]
+};

node_modules/faker/lib/locales/az/company/index.js

@@ -0,0 +1,5 @@
+var company = {};
+module['exports'] = company;
+company.prefix = require("./prefix");
+company.suffix = require("./suffix");
+company.name = require("./name");

node_modules/faker/lib/locales/az/company/name.js

@@ -0,0 +1,10 @@
+module["exports"] = [
+  "#{prefix} #{Name.female_first_name}",
+  "#{prefix} #{Name.male_first_name}",
+  "#{prefix} #{Name.male_last_name}",
+  "#{prefix} #{suffix}#{suffix}",
+  "#{prefix} #{suffix}#{suffix}#{suffix}",
+  "#{prefix} #{Address.city_name}#{suffix}",
+  "#{prefix} #{Address.city_name}#{suffix}#{suffix}",
+  "#{prefix} #{Address.city_name}#{suffix}#{suffix}#{suffix}"
+];

node_modules/faker/lib/locales/az/company/prefix.js

@@ -0,0 +1,5 @@
+module["exports"] = [
+  "ASC",
+  "MMC",
+  "QSC",
+];

node_modules/faker/lib/locales/az/company/suffix.js

@@ -0,0 +1,3 @@
+module["exports"] = [
+
+];

node_modules/faker/lib/locales/az/date/index.js

@@ -0,0 +1,4 @@
+var date = {};
+module["exports"] = date;
+date.month = require("./month");
+date.weekday = require("./weekday");

node_modules/faker/lib/locales/az/date/month.js

@@ -0,0 +1,59 @@
+// source: http://unicode.org/cldr/trac/browser/tags/release-27/common/main/ru.xml#L1734
+module["exports"] = {
+  wide: [
+    "yanvar",
+    "fevral",
+    "mart",
+    "aprel",
+    "may",
+    "iyun",
+    "iyul",
+    "avqust",
+    "sentyabr",
+    "oktyabr",
+    "noyabr",
+    "dekabr"
+  ],
+  wide_context: [
+    "января",
+    "февраля",
+    "марта",
+    "апреля",
+    "мая",
+    "июня",
+    "июля",
+    "августа",
+    "сентября",
+    "октября",
+    "ноября",
+    "декабря"
+  ],
+  abbr: [
+    "янв.",
+    "февр.",
+    "март",
+    "апр.",
+    "май",
+    "июнь",
+    "июль",
+    "авг.",
+    "сент.",
+    "окт.",
+    "нояб.",
+    "дек."
+  ],
+  abbr_context: [
+    "янв.",
+    "февр.",
+    "марта",
+    "апр.",
+    "мая",
+    "июня",
+    "июля",
+    "авг.",
+    "сент.",
+    "окт.",
+    "нояб.",
+    "дек."
+  ]
+};

node_modules/faker/lib/locales/az/date/weekday.js

@@ -0,0 +1,39 @@
+// source: http://unicode.org/cldr/trac/browser/tags/release-27/common/main/ru.xml#L1825
+module["exports"] = {
+  wide: [
+    "Bazar",
+    "Bazar ertəsi",
+    "Çərşənbə axşamı",
+    "Çərşənbə",
+    "Cümə axşamı",
+    "Cümə",
+    "Şənbə"
+  ],
+  wide_context: [
+    "воскресенье",
+    "понедельник",
+    "вторник",
+    "среда",
+    "четверг",
+    "пятница",
+    "суббота"
+  ],
+  abbr: [
+    "Ba",
+    "BE",
+    "ÇA",
+    "Çə",
+    "CA",
+    "Cü",
+    "Şə"
+  ],
+  abbr_context: [
+    "вс",
+    "пн",
+    "вт",
+    "ср",
+    "чт",
+    "пт",
+    "сб"
+  ]
+};