@akylas/nativescript-cli 8.7.2

package/lib/common/services/project-files-manager.js

@@ -0,0 +1,100 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectFilesManager = void 0;
+const minimatch_1 = require("minimatch");
+const path = require("path");
+const util = require("util");
+const _ = require("lodash");
+const yok_1 = require("../yok");
+class ProjectFilesManager {
+    constructor($fs, $localToDevicePathDataFactory, $logger, $projectFilesProvider) {
+        this.$fs = $fs;
+        this.$localToDevicePathDataFactory = $localToDevicePathDataFactory;
+        this.$logger = $logger;
+        this.$projectFilesProvider = $projectFilesProvider;
+    }
+    getProjectFiles(projectFilesPath, excludedProjectDirsAndFiles, filter, opts) {
+        const projectFiles = this.$fs.enumerateFilesInDirectorySync(projectFilesPath, (filePath, stat) => {
+            const isFileExcluded = this.isFileExcluded(path.relative(projectFilesPath, filePath), excludedProjectDirsAndFiles);
+            const isFileFiltered = filter ? filter(filePath, stat) : false;
+            return !isFileExcluded && !isFileFiltered;
+        }, opts);
+        this.$logger.trace("enumerateProjectFiles: %s", util.inspect(projectFiles));
+        return projectFiles;
+    }
+    isFileExcluded(filePath, excludedProjectDirsAndFiles) {
+        const isInExcludedList = !!_.find(excludedProjectDirsAndFiles, (pattern) => (0, minimatch_1.minimatch)(filePath, pattern, { nocase: true }));
+        return (isInExcludedList || this.$projectFilesProvider.isFileExcluded(filePath));
+    }
+    createLocalToDevicePaths(deviceAppData, projectFilesPath, files, excludedProjectDirsAndFiles, projectFilesConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceProjectRootPath = yield deviceAppData.getDeviceProjectRootPath();
+            files =
+                files ||
+                    this.getProjectFiles(projectFilesPath, excludedProjectDirsAndFiles, null, { enumerateDirectories: true });
+            const localToDevicePaths = Promise.all(files
+                .map((projectFile) => this.$projectFilesProvider.getProjectFileInfo(projectFile, deviceAppData.platform, projectFilesConfig))
+                .filter((projectFileInfo) => projectFileInfo.shouldIncludeFile)
+                .map((projectFileInfo) => __awaiter(this, void 0, void 0, function* () {
+                return this.$localToDevicePathDataFactory.create(projectFileInfo.filePath, projectFilesPath, projectFileInfo.onDeviceFileName, deviceProjectRootPath);
+            })));
+            return localToDevicePaths;
+        });
+    }
+    processPlatformSpecificFiles(directoryPath, platform, projectFilesConfig, excludedDirs) {
+        const contents = this.$fs.readDirectory(directoryPath);
+        const files = [];
+        _.each(contents, (fileName) => {
+            const filePath = path.join(directoryPath, fileName);
+            const fsStat = this.$fs.getFsStats(filePath);
+            if (fsStat.isDirectory() && !_.includes(excludedDirs, fileName)) {
+                this.processPlatformSpecificFilesCore(platform, this.$fs.enumerateFilesInDirectorySync(filePath), projectFilesConfig);
+            }
+            else if (fsStat.isFile()) {
+                files.push(filePath);
+            }
+        });
+        this.processPlatformSpecificFilesCore(platform, files, projectFilesConfig);
+    }
+    processPlatformSpecificFilesCore(platform, files, projectFilesConfig) {
+        _.each(files, (filePath) => {
+            const projectFileInfo = this.$projectFilesProvider.getProjectFileInfo(filePath, platform, projectFilesConfig);
+            if (!projectFileInfo.shouldIncludeFile) {
+                this.$fs.deleteFile(filePath);
+            }
+            else if (projectFileInfo.onDeviceFileName) {
+                const onDeviceFilePath = path.join(path.dirname(filePath), projectFileInfo.onDeviceFileName);
+                const extension = path.extname(projectFileInfo.onDeviceFileName);
+                if (onDeviceFilePath !== filePath) {
+                    if (extension === ".js" || extension === ".map") {
+                        const oldName = extension === ".map"
+                            ? this.getFileName(filePath, extension)
+                            : path.basename(filePath);
+                        const newName = extension === ".map"
+                            ? this.getFileName(projectFileInfo.onDeviceFileName, extension)
+                            : path.basename(projectFileInfo.onDeviceFileName);
+                        let fileContent = this.$fs.readText(filePath);
+                        fileContent = fileContent.replace(new RegExp(oldName, "g"), newName);
+                        this.$fs.writeFile(filePath, fileContent);
+                    }
+                    this.$fs.writeFile(onDeviceFilePath, this.$fs.readText(filePath));
+                    this.$fs.deleteFile(filePath);
+                }
+            }
+        });
+    }
+    getFileName(filePath, extension) {
+        return path.basename(filePath.replace(extension === ".map" ? ".js.map" : ".js", ""));
+    }
+}
+exports.ProjectFilesManager = ProjectFilesManager;
+yok_1.injector.register("projectFilesManager", ProjectFilesManager);

package/lib/common/services/project-files-provider-base.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectFilesProviderBase = void 0;
+const path = require("path");
+const util = require("util");
+const constants_1 = require("../constants");
+class ProjectFilesProviderBase {
+    constructor($mobileHelper, $options) {
+        this.$mobileHelper = $mobileHelper;
+        this.$options = $options;
+    }
+    getPreparedFilePath(filePath, projectFilesConfig) {
+        const projectFileInfo = this.getProjectFileInfo(filePath, "", projectFilesConfig);
+        return path.join(path.dirname(filePath), projectFileInfo.onDeviceFileName);
+    }
+    getProjectFileInfo(filePath, platform, projectFilesConfig) {
+        if (!filePath) {
+            return {
+                filePath: filePath,
+                onDeviceFileName: filePath,
+                shouldIncludeFile: false,
+            };
+        }
+        let parsed = this.parseFile(filePath, this.$mobileHelper.platformNames, platform || "");
+        const basicConfigurations = [
+            constants_1.Configurations.Debug.toLowerCase(),
+            constants_1.Configurations.Release.toLowerCase(),
+        ];
+        if (!parsed) {
+            const validValues = basicConfigurations.concat((projectFilesConfig && projectFilesConfig.additionalConfigurations) ||
+                []), value = (projectFilesConfig && projectFilesConfig.configuration) ||
+                basicConfigurations[0];
+            parsed = this.parseFile(filePath, validValues, value);
+        }
+        return (parsed || {
+            filePath: filePath,
+            onDeviceFileName: path.basename(filePath),
+            shouldIncludeFile: true,
+        });
+    }
+    parseFile(filePath, validValues, value) {
+        const regex = util.format("^(.+?)[.](%s)([.].+?)$", validValues.join("|"));
+        const parsed = filePath.match(new RegExp(regex, "i"));
+        if (parsed) {
+            return {
+                filePath: filePath,
+                onDeviceFileName: path.basename(parsed[1] + parsed[3]),
+                shouldIncludeFile: parsed[2].toLowerCase() === value.toLowerCase(),
+            };
+        }
+        return null;
+    }
+}
+exports.ProjectFilesProviderBase = ProjectFilesProviderBase;

package/lib/common/services/proxy-service.js

@@ -0,0 +1,64 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyService = void 0;
+const path = require("path");
+const os_1 = require("os");
+const constants_1 = require("../constants");
+const yok_1 = require("../yok");
+const proxyLib = require("proxy-lib");
+class ProxyService {
+    constructor($settingsService, $staticConfig) {
+        this.$settingsService = $settingsService;
+        this.$staticConfig = $staticConfig;
+        this.proxyCacheFilePath = path.join(this.$settingsService.getProfileDir(), constants_1.Proxy.CACHE_FILE_NAME);
+        this.credentialsKey = `${this.$staticConfig.CLIENT_NAME}_PROXY`;
+    }
+    setCache(settings) {
+        settings.userSpecifiedSettingsFilePath =
+            settings.userSpecifiedSettingsFilePath || this.proxyCacheFilePath;
+        settings.credentialsKey = settings.credentialsKey || this.credentialsKey;
+        return proxyLib.setProxySettings(settings);
+    }
+    getCache() {
+        const settings = {
+            credentialsKey: this.credentialsKey,
+            userSpecifiedSettingsFilePath: this.proxyCacheFilePath,
+        };
+        return proxyLib.getProxySettings(settings);
+    }
+    clearCache() {
+        const settings = {
+            credentialsKey: this.credentialsKey,
+            userSpecifiedSettingsFilePath: this.proxyCacheFilePath,
+        };
+        return proxyLib.clearProxySettings(settings);
+    }
+    getInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let message = "";
+            const proxyCache = yield this.getCache();
+            if (proxyCache) {
+                message = `Proxy Url: ${proxyCache.protocol}//${proxyCache.hostname}:${proxyCache.port}`;
+                if (proxyCache.username) {
+                    message += `${os_1.EOL}Username: ${proxyCache.username}`;
+                }
+                message += `${os_1.EOL}Proxy is Enabled`;
+            }
+            else {
+                message = "No proxy set";
+            }
+            return message;
+        });
+    }
+}
+exports.ProxyService = ProxyService;
+yok_1.injector.register("proxyService", ProxyService);

package/lib/common/services/qr.js

@@ -0,0 +1,39 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QrCodeGenerator = void 0;
+const qr_image_1 = require("qr-image");
+const querystring_1 = require("querystring");
+const yok_1 = require("../yok");
+class QrCodeGenerator {
+    constructor($staticConfig, $logger) {
+        this.$staticConfig = $staticConfig;
+        this.$logger = $logger;
+    }
+    generateDataUri(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let result = null;
+            try {
+                const qrSvg = (0, qr_image_1.imageSync)(data, {
+                    size: this.$staticConfig.QR_SIZE,
+                    type: "svg",
+                }).toString();
+                result = `data:image/svg+xml;utf-8,${(0, querystring_1.escape)(qrSvg)}`;
+            }
+            catch (err) {
+                this.$logger.trace(`Failed to generate QR code for ${data}`, err);
+            }
+            return result;
+        });
+    }
+}
+exports.QrCodeGenerator = QrCodeGenerator;
+yok_1.injector.register("qr", QrCodeGenerator);

package/lib/common/services/settings-service.js

@@ -0,0 +1,42 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettingsService = void 0;
+const decorators_1 = require("../decorators");
+const path = require("path");
+const os_1 = require("os");
+const yok_1 = require("../yok");
+class SettingsService {
+    constructor($staticConfig, $hostInfo) {
+        this.$staticConfig = $staticConfig;
+        this.$hostInfo = $hostInfo;
+        this._profileDir = this.getDefaultProfileDir();
+    }
+    setSettings(settings) {
+        if (settings && settings.userAgentName) {
+            this.$staticConfig.USER_AGENT_NAME = settings.userAgentName;
+        }
+        if (settings && settings.profileDir) {
+            this._profileDir = path.resolve(settings.profileDir);
+        }
+    }
+    getProfileDir() {
+        return this._profileDir;
+    }
+    getDefaultProfileDir() {
+        const defaultProfileDirLocation = this.$hostInfo.isWindows
+            ? process.env.AppData
+            : path.join((0, os_1.homedir)(), ".local", "share");
+        return path.join(defaultProfileDirLocation, this.$staticConfig.PROFILE_DIR_NAME);
+    }
+}
+__decorate([
+    (0, decorators_1.exported)("settingsService")
+], SettingsService.prototype, "setSettings", null);
+exports.SettingsService = SettingsService;
+yok_1.injector.register("settingsService", SettingsService);

package/lib/common/services/xcode-select-service.js

@@ -0,0 +1,62 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XcodeSelectService = void 0;
+const path = require("path");
+const decorators_1 = require("../decorators");
+const yok_1 = require("../yok");
+class XcodeSelectService {
+    constructor($childProcess, $errors, $hostInfo, $injector) {
+        this.$childProcess = $childProcess;
+        this.$errors = $errors;
+        this.$hostInfo = $hostInfo;
+        this.$injector = $injector;
+    }
+    getDeveloperDirectoryPath() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.$hostInfo.isDarwin) {
+                this.$errors.fail("xcode-select is only available on Mac OS X.");
+            }
+            const childProcess = yield this.$childProcess.spawnFromEvent("xcode-select", ["-print-path"], "close", {}, { throwError: false }), result = childProcess.stdout.trim();
+            if (!result) {
+                this.$errors.fail("Cannot find path to Xcode.app - make sure you've installed Xcode correctly.");
+            }
+            return result;
+        });
+    }
+    getContentsDirectoryPath() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return path.join(yield this.getDeveloperDirectoryPath(), "..");
+        });
+    }
+    getXcodeVersion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sysInfo = this.$injector.resolve("sysInfo");
+            const xcodeVer = yield sysInfo.getXcodeVersion();
+            if (!xcodeVer) {
+                this.$errors.fail("xcodebuild execution failed. Make sure that you have latest Xcode and tools installed.");
+            }
+            const [major, minor, patch] = xcodeVer.split(".");
+            return { major, minor, patch };
+        });
+    }
+}
+__decorate([
+    (0, decorators_1.cache)()
+], XcodeSelectService.prototype, "getXcodeVersion", null);
+exports.XcodeSelectService = XcodeSelectService;
+yok_1.injector.register("xcodeSelectService", XcodeSelectService);

package/lib/common/utils.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Utils = void 0;
+const yok_1 = require("./yok");
+class Utils {
+    constructor($options, $logger) {
+        this.$options = $options;
+        this.$logger = $logger;
+    }
+    getParsedTimeout(defaultTimeout) {
+        let timeout = defaultTimeout;
+        if (this.$options.timeout) {
+            const parsedValue = parseInt(this.$options.timeout);
+            if (!isNaN(parsedValue) && parsedValue >= 0) {
+                timeout = parsedValue;
+            }
+            else {
+                this.$logger.warn("Specify timeout in a number of seconds to wait. Default value: " +
+                    timeout +
+                    " seconds will be used.");
+            }
+        }
+        return timeout;
+    }
+    getMilliSecondsTimeout(defaultTimeout) {
+        const timeout = this.getParsedTimeout(defaultTimeout);
+        return timeout * 1000;
+    }
+}
+exports.Utils = Utils;
+yok_1.injector.register("utils", Utils);

package/lib/common/validators/project-name-validator.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectNameValidator = void 0;
+const path = require("path");
+const _ = require("lodash");
+const helpers = require("../helpers");
+const ValidationResult = require("./validation-result");
+const yok_1 = require("../yok");
+class ProjectNameValidator {
+    constructor($errors) {
+        this.$errors = $errors;
+    }
+    validateName(name) {
+        const validNameRegex = /^[a-zA-Z0-9_.\- ]*$/g;
+        const ext = path.extname(name);
+        if (helpers.isNullOrWhitespace(name)) {
+            return new ValidationResult.ValidationResult(ProjectNameValidator.EMPTY_FILENAME_ERROR_MESSAGE);
+        }
+        if (!validNameRegex.test(name)) {
+            return new ValidationResult.ValidationResult(ProjectNameValidator.NOT_VALID_NAME_ERROR_MESSAGE);
+        }
+        if (_.includes(ProjectNameValidator.INVALID_FILENAMES, name.split(".")[0])) {
+            return new ValidationResult.ValidationResult(ProjectNameValidator.RESERVED_NAME_ERROR_MESSAGE);
+        }
+        if (ext !== "" &&
+            _.includes(ProjectNameValidator.INVALID_EXTENSIONS, ext)) {
+            return new ValidationResult.ValidationResult(ProjectNameValidator.INVALID_EXTENSION_ERROR_MESSAGE);
+        }
+        if (name.length > ProjectNameValidator.MAX_FILENAME_LENGTH) {
+            return new ValidationResult.ValidationResult(ProjectNameValidator.TOO_LONG_NAME_ERROR_MESSAGE);
+        }
+        if (_.startsWith(name, " ")) {
+            return new ValidationResult.ValidationResult(ProjectNameValidator.LEADING_SPACES_ERROR_MESSAGE);
+        }
+        if (_.endsWith(name, ".")) {
+            return new ValidationResult.ValidationResult(ProjectNameValidator.TRAILING_DOTS_ERROR_MESSAGE);
+        }
+        if (_.endsWith(name, " ")) {
+            return new ValidationResult.ValidationResult(ProjectNameValidator.TRAILING_SPACES_ERROR_MESSAGE);
+        }
+        return ValidationResult.ValidationResult.Successful;
+    }
+    validate(name) {
+        const validationResult = this.validateName(name);
+        const isSuccessful = validationResult.isSuccessful;
+        if (!isSuccessful) {
+            this.$errors.fail(validationResult.error);
+        }
+        return isSuccessful;
+    }
+}
+ProjectNameValidator.MAX_FILENAME_LENGTH = 30;
+ProjectNameValidator.EMPTY_FILENAME_ERROR_MESSAGE = "Name cannot be empty.";
+ProjectNameValidator.NOT_VALID_NAME_ERROR_MESSAGE = "Name should contain only the following symbols: A-Z, a-z, 0-9, _, ., - and space";
+ProjectNameValidator.RESERVED_NAME_ERROR_MESSAGE = "Name is among the reserved names: ~, CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, and LPT9.";
+ProjectNameValidator.INVALID_EXTENSION_ERROR_MESSAGE = "Unsupported file type.";
+ProjectNameValidator.TOO_LONG_NAME_ERROR_MESSAGE = "Name is too long.";
+ProjectNameValidator.TRAILING_DOTS_ERROR_MESSAGE = "Name cannot contain trailing dots.";
+ProjectNameValidator.LEADING_SPACES_ERROR_MESSAGE = "Name cannot contain leading spaces.";
+ProjectNameValidator.TRAILING_SPACES_ERROR_MESSAGE = "Name cannot contain trailing spaces.";
+ProjectNameValidator.INVALID_FILENAMES = [
+    "~",
+    "CON",
+    "PRN",
+    "AUX",
+    "NUL",
+    "COM1",
+    "COM2",
+    "COM3",
+    "COM4",
+    "COM5",
+    "COM6",
+    "COM7",
+    "COM8",
+    "COM9",
+    "LPT1",
+    "LPT2",
+    "LPT3",
+    "LPT4",
+    "LPT5",
+    "LPT6",
+    "LPT7",
+    "LPT8",
+    "LPT9",
+];
+ProjectNameValidator.INVALID_EXTENSIONS = [];
+exports.ProjectNameValidator = ProjectNameValidator;
+yok_1.injector.register("projectNameValidator", ProjectNameValidator);

package/lib/common/validators/validation-result.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationResult = void 0;
+class ValidationResult {
+    constructor(errorMsg) {
+        this.errorMsg = errorMsg;
+    }
+    get error() {
+        return this.errorMsg;
+    }
+    get isSuccessful() {
+        return !this.errorMsg;
+    }
+}
+ValidationResult.Successful = new ValidationResult(null);
+exports.ValidationResult = ValidationResult;

package/lib/common/vendor/License.txt

@@ -0,0 +1,4 @@
+Please access the license terms currently located here: http://www.telerik.com/analytics/terms-of-service
+
+Please contact sales@telerik.com for further information
+

package/lib/common/vendor/jaro-winkler_distance.js

@@ -0,0 +1,111 @@
+/*
+Copyright (c) 2012, Adam Phillabaum, Chris Umbel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+Unless otherwise stated by a specific section of code
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+// Computes the Jaro distance between two string -- intrepreted from:
+// http://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance
+// s1 is the first string to compare
+// s2 is the second string to compare
+function distance(s1, s2) {
+    if (typeof(s1) != "string" || typeof(s2) != "string") return 0;
+    if (s1.length == 0 || s2.length == 0) 
+        return 0;
+    s1 = s1.toLowerCase(), s2 = s2.toLowerCase();
+    var matchWindow = (Math.floor(Math.max(s1.length, s2.length) / 2.0)) - 1;
+    var matches1 = new Array(s1.length);
+    var matches2 = new Array(s2.length);
+    var m = 0; // number of matches
+    var t = 0; // number of transpositions
+
+    //debug helpers
+    //console.log("s1: " + s1 + "; s2: " + s2);
+    //console.log(" - matchWindow: " + matchWindow);
+
+    // find matches
+    for (var i = 0; i < s1.length; i++) {
+	var matched = false;
+
+	// check for an exact match
+	if (s1[i] ==  s2[i]) {
+		matches1[i] = matches2[i] = matched = true;
+		m++
+	}
+
+	// check the "match window"
+	else {
+        	// this for loop is a little brutal
+        	for (k = (i <= matchWindow) ? 0 : i - matchWindow;
+        		(k <= i + matchWindow) && k < s2.length && !matched;
+			k++) {
+            		if (s1[i] == s2[k]) {
+                		if(!matches1[i] && !matches2[k]) {
+                	    		m++;
+               		}
+
+        	        matches1[i] = matches2[k] = matched = true;
+        	    }
+        	}
+	}
+    }
+
+    if(m == 0)
+        return 0.0;
+
+    // count transpositions
+    var k = 0;
+
+    for(var i = 0; i < s1.length; i++) {
+    	if(matches1[k]) {
+    	    while(!matches2[k] && k < matches2.length)
+                k++;
+	        if(s1[i] != s2[k] &&  k < matches2.length)  {
+                t++;
+            }
+
+    	    k++;
+    	}
+    }
+    
+    //debug helpers:
+    //console.log(" - matches: " + m);
+    //console.log(" - transpositions: " + t);
+    t = t / 2.0;
+    return (m / s1.length + m / s2.length + (m - t) / m) / 3;
+}
+
+// Computes the Winkler distance between two string -- intrepreted from:
+// http://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance
+// s1 is the first string to compare
+// s2 is the second string to compare
+// dj is the Jaro Distance (if you've already computed it), leave blank and the method handles it
+function JaroWinklerDistance(s1, s2, dj) {
+    var jaro;
+    (typeof(dj) == 'undefined')? jaro = distance(s1,s2) : jaro = dj;
+    var p = 0.1; //
+    var l = 0 // length of the matching prefix
+    while(s1[l] == s2[l] && l < 4)
+        l++;
+    
+    return jaro + l * p * (1 - jaro);
+}
+module.exports = JaroWinklerDistance;