inital commit

node_modules/accept-language/Build/Source/AcceptLanguage.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var bcp47 = require("bcp47");
+var AcceptLanguage = /** @class */ (function () {
+    function AcceptLanguage() {
+        this.languageTagsWithValues = {};
+        this.defaultLanguageTag = null;
+    }
+    AcceptLanguage.prototype.languages = function (definedLanguages) {
+        var _this = this;
+        if (definedLanguages.length < 1) {
+            throw new Error('No language tags defined. Provide at least 1 language tag to match.');
+        }
+        this.languageTagsWithValues = {};
+        definedLanguages.forEach(function (languageTagString) {
+            var languageTag = bcp47.parse(languageTagString);
+            if (!languageTag) {
+                throw new TypeError("'".concat(languageTagString, "' is not bcp47 compliant. More about bcp47 https://tools.ietf.org/html/bcp47."));
+            }
+            var language = languageTag.langtag.language.language;
+            if (!language) {
+                throw new TypeError("".concat(languageTagString, " is not supported."));
+            }
+            var langtag = languageTag.langtag;
+            var languageTagWithValues = langtag;
+            languageTagWithValues.value = languageTagString;
+            var lowerCasedLanguageTagWithValues = {
+                language: {
+                    language: langtag.language.language.toLowerCase(),
+                    extlang: langtag.language.extlang.map(function (e) { return e.toLowerCase(); }),
+                },
+                region: langtag.region && langtag.region.toLowerCase(),
+                script: langtag.script && langtag.script.toLowerCase(),
+                variant: langtag.variant.map(function (v) { return v.toLowerCase(); }),
+                privateuse: langtag.privateuse.map(function (p) { return p.toLowerCase(); }),
+                extension: langtag.extension.map(function (e) {
+                    return {
+                        extension: e.extension && e.extension.map(function (e) { return e.toLowerCase(); }),
+                        singleton: e.singleton.toLowerCase(),
+                    };
+                }),
+                value: languageTagString,
+            };
+            if (!_this.languageTagsWithValues[language]) {
+                _this.languageTagsWithValues[language] = [lowerCasedLanguageTagWithValues];
+            }
+            else {
+                _this.languageTagsWithValues[language].push(lowerCasedLanguageTagWithValues);
+            }
+        });
+        this.defaultLanguageTag = definedLanguages[0];
+    };
+    AcceptLanguage.prototype.get = function (languagePriorityList) {
+        return this.parse(languagePriorityList)[0];
+    };
+    AcceptLanguage.prototype.create = function () {
+        return null;
+    };
+    AcceptLanguage.prototype.parse = function (languagePriorityList) {
+        if (!languagePriorityList) {
+            return [this.defaultLanguageTag];
+        }
+        var parsedAndSortedLanguageTags = parseAndSortLanguageTags(languagePriorityList);
+        var result = [];
+        for (var _i = 0, parsedAndSortedLanguageTags_1 = parsedAndSortedLanguageTags; _i < parsedAndSortedLanguageTags_1.length; _i++) {
+            var languageTag = parsedAndSortedLanguageTags_1[_i];
+            var requestedLang = bcp47.parse(languageTag.tag);
+            if (!requestedLang) {
+                continue;
+            }
+            var requestedLangTag = requestedLang.langtag;
+            if (!this.languageTagsWithValues[requestedLangTag.language.language]) {
+                continue;
+            }
+            middle: for (var _a = 0, _b = this.languageTagsWithValues[requestedLangTag.language.language]; _a < _b.length; _a++) {
+                var definedLangTag = _b[_a];
+                var unmatchedRequestedSubTag = 0;
+                for (var _c = 0, _d = ['privateuse', 'extension', 'variant', 'region', 'script']; _c < _d.length; _c++) {
+                    var prop = _d[_c];
+                    var definedLanguagePropertValue = definedLangTag[prop];
+                    if (!definedLanguagePropertValue) {
+                        var requestedLanguagePropertyValue_1 = requestedLangTag[prop];
+                        if (requestedLanguagePropertyValue_1) {
+                            unmatchedRequestedSubTag++;
+                        }
+                        switch (prop) {
+                            case 'privateuse':
+                            case 'variant':
+                                for (var i = 0; i < requestedLanguagePropertyValue_1.length; i++) {
+                                    if (requestedLanguagePropertyValue_1[i]) {
+                                        unmatchedRequestedSubTag++;
+                                    }
+                                }
+                                break;
+                            case 'extension':
+                                for (var i = 0; i < requestedLanguagePropertyValue_1.length; i++) {
+                                    var extension = requestedLanguagePropertyValue_1[i].extension;
+                                    for (var ei = 0; ei < extension.length; ei++) {
+                                        if (!requestedLanguagePropertyValue_1[i].extension[ei]) {
+                                            unmatchedRequestedSubTag++;
+                                        }
+                                    }
+                                }
+                                break;
+                        }
+                        continue;
+                    }
+                    // Filter out wider requested languages first. If someone requests 'zh'
+                    // and my defined language is 'zh-Hant'. I cannot match 'zh-Hant', because
+                    // 'zh' is wider than 'zh-Hant'.
+                    var requestedLanguagePropertyValue = requestedLangTag[prop];
+                    if (!requestedLanguagePropertyValue) {
+                        continue middle;
+                    }
+                    switch (prop) {
+                        case 'privateuse':
+                        case 'variant':
+                            for (var i = 0; i < definedLanguagePropertValue.length; i++) {
+                                if (!requestedLanguagePropertyValue[i] || definedLanguagePropertValue[i] !== requestedLanguagePropertyValue[i].toLowerCase()) {
+                                    continue middle;
+                                }
+                            }
+                            break;
+                        case 'extension':
+                            for (var i = 0; i < definedLanguagePropertValue.length; i++) {
+                                var extension = definedLanguagePropertValue[i].extension;
+                                for (var ei = 0; ei < extension.length; ei++) {
+                                    if (!requestedLanguagePropertyValue[i]) {
+                                        continue middle;
+                                    }
+                                    if (!requestedLanguagePropertyValue[i].extension[ei]) {
+                                        continue middle;
+                                    }
+                                    if (extension[ei] !== requestedLanguagePropertyValue[i].extension[ei].toLowerCase()) {
+                                        continue middle;
+                                    }
+                                }
+                            }
+                            break;
+                        default:
+                            if (definedLanguagePropertValue !== requestedLanguagePropertyValue.toLowerCase()) {
+                                continue middle;
+                            }
+                    }
+                }
+                result.push({
+                    unmatchedRequestedSubTag: unmatchedRequestedSubTag,
+                    quality: languageTag.quality,
+                    languageTag: definedLangTag.value
+                });
+            }
+        }
+        return result.length > 0 ? result.sort(function (a, b) {
+            var quality = b.quality - a.quality;
+            if (quality != 0) {
+                return quality;
+            }
+            return a.unmatchedRequestedSubTag - b.unmatchedRequestedSubTag;
+        }).map(function (l) { return l.languageTag; }) : [this.defaultLanguageTag];
+        function parseAndSortLanguageTags(languagePriorityList) {
+            return languagePriorityList.split(',').map(function (weightedLanguageRange) {
+                var components = weightedLanguageRange.replace(/\s+/, '').split(';');
+                return {
+                    tag: components[0],
+                    quality: components[1] ? parseFloat(components[1].split('=')[1]) : 1.0
+                };
+            })
+                // Filter non-defined language tags
+                .filter(function (languageTag) {
+                if (!languageTag) {
+                    return false;
+                }
+                if (!languageTag.tag) {
+                    return false;
+                }
+                return languageTag;
+            });
+        }
+    };
+    return AcceptLanguage;
+}());
+function create() {
+    var al = new AcceptLanguage();
+    al.create = function () {
+        return new AcceptLanguage();
+    };
+    return al;
+}
+module.exports = create();
+module.exports.default = create();
+exports.default = create();
+//# sourceMappingURL=AcceptLanguage.js.map

node_modules/accept-language/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Tingan Ho
+
+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.
+
+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.

node_modules/accept-language/Library/Typings.d.ts

@@ -0,0 +1,27 @@
+
+declare module 'accept-language' {
+
+    interface AcceptLanguage {
+
+        /**
+         * Define your supported languages. The first language will be your default language.
+         */
+        languages(languages: string[]): void;
+
+        /**
+         * Get matched language. If no match, the default language will be returned.
+         */
+        get(priorityList: string | null | undefined): string | null;
+    }
+
+    interface AcceptLanguageModule extends AcceptLanguage {
+
+        /**
+         * Create instance of parser
+         */
+        create(): AcceptLanguage;
+    }
+
+    const __$export: AcceptLanguageModule & { default: AcceptLanguageModule };
+    export = __$export;
+}

node_modules/accept-language/README.md

@@ -0,0 +1,54 @@
+accept-language [![Build Status](https://travis-ci.org/tinganho/node-accept-language.png)](https://travis-ci.org/tinganho/node-accept-language)
+========================
+
+[![NPM](https://nodei.co/npm/accept-language.png?downloads=true&stars=true)](https://nodei.co/npm/accept-language/)
+
+`accept-language` parses HTTP Accept-Language header ([BCP47][] compliant) and returns a matched defined language.
+
+### Installation:
+
+```
+npm install accept-language --save
+```
+
+### Usage:
+
+```ts
+// var acceptLanguage = require('accept-language');
+import acceptLanguage from 'accept-language';
+acceptLanguage.languages(['en-US', 'zh-CN']);
+console.log(acceptLanguage.get('en-GB,en;q=0.8,sv'));
+/*
+
+'en-US'
+
+*/
+```
+
+### Usage with Express:
+If you are using Express server please use the middleware [express-request-language](https://www.npmjs.com/package/express-request-language).
+
+### API
+#### acceptLanguage.languages(Array languageTags);
+Provide your language tags in order of priority. The language tags must comply with [BCP47][] standard.
+
+```javascript
+acceptLanguage.languages(['en-US', 'zh-CN']);
+```
+
+#### acceptLanguage.get(String acceptLanguageString);
+Returns the most likely language given an `Accept-Language` string. At least 1 language tag must be provided.
+```javascript
+acceptLanguage.get('en-GB,en;q=0.8,sv');
+```
+
+### Maintainer
+
+Tingan Ho [@tingan87][]
+
+### License
+MIT
+
+[L10ns]: http://l10ns.org
+[BCP47]: https://tools.ietf.org/html/bcp47
+[@tingan87]: https://twitter.com/tingan87

node_modules/accept-language/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "accept-language",
+  "version": "3.0.20",
+  "description": "Accept-Language parser for nodejs",
+  "main": "Build/Source/AcceptLanguage.js",
+  "scripts": {
+    "build": "tsc",
+    "test": "node node_modules/mocha/bin/mocha Build/Tests/Test.js"
+  },
+  "types": "Library/Typings.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/tinganho/node-accept-language.git"
+  },
+  "keywords": [
+    "accept-language",
+    "i18n",
+    "http"
+  ],
+  "author": "Tingan Ho <tingan87@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/tinganho/node-accept-language/issues"
+  },
+  "homepage": "https://github.com/tinganho/node-accept-language",
+  "devDependencies": {
+    "@types/chai": "^3.4.32",
+    "@types/mocha": "^2.2.31",
+    "@types/node": "^8.0.31",
+    "chai": "~1.9.1",
+    "mocha": "^10.7.3",
+    "source-map-support": "^0.4.18"
+  },
+  "dependencies": {
+    "bcp47": "^1.1.2"
+  }
+}