@tolgee/cli 1.0.0-prerelease.1

package/dist/index.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const credentials_1 = require("./config/credentials");
+const tolgeerc_1 = __importDefault(require("./config/tolgeerc"));
+const client_1 = __importDefault(require("./client"));
+const errors_1 = require("./client/errors");
+const logger_1 = require("./utils/logger");
+const options_1 = require("./options");
+const constants_1 = require("./constants");
+const login_1 = require("./commands/login");
+const push_1 = __importDefault(require("./commands/push"));
+const pull_1 = __importDefault(require("./commands/pull"));
+const extract_1 = __importDefault(require("./commands/extract"));
+const compare_1 = __importDefault(require("./commands/sync/compare"));
+const sync_1 = __importDefault(require("./commands/sync/sync"));
+const NO_KEY_COMMANDS = ['login', 'logout', 'extract'];
+function topLevelName(command) {
+    return command.parent && command.parent.parent
+        ? topLevelName(command.parent)
+        : command.name();
+}
+async function validateApiKey(cmd) {
+    const opts = cmd.optsWithGlobals();
+    if (!opts.apiKey) {
+        // Attempt to load --api-key from config store if not specified
+        // This is not done as part of the init routine or via the mandatory flag, as this is dependent on the API URL.
+        const key = await (0, credentials_1.getApiKey)(opts.apiUrl, opts.projectId);
+        if (!key) {
+            (0, logger_1.error)('No API key has been provided. You must either provide one via --api-key, or login via `tolgee login`.');
+            process.exit(1);
+        }
+        cmd.setOptionValue('apiKey', key);
+        program.setOptionValue('_removeApiKeyFromStore', () => {
+            if (key.startsWith(constants_1.API_KEY_PAT_PREFIX)) {
+                (0, credentials_1.savePat)(opts.apiUrl);
+            }
+            else {
+                (0, credentials_1.savePak)(opts.apiUrl, opts.projectId);
+            }
+        });
+    }
+}
+function validateProjectId(cmd) {
+    const opts = cmd.optsWithGlobals();
+    // Validate --project-id is present when using Project API keys
+    if (opts.projectId === -1 && opts.apiKey.startsWith(constants_1.API_KEY_PAT_PREFIX)) {
+        (0, logger_1.error)('You must specify a Project ID.');
+        process.exit(1);
+    }
+    if (opts.apiKey.startsWith(constants_1.API_KEY_PAK_PREFIX)) {
+        // Parse the key to ensure we can access the specified Project ID
+        const projectId = client_1.default.projectIdFromKey(opts.apiKey);
+        program.setOptionValue('projectId', projectId);
+        if (opts.projectId !== -1 && opts.projectId !== projectId) {
+            (0, logger_1.error)('The specified API key cannot be used to perform operations on the specified project.');
+            (0, logger_1.info)(`The API key you specified is tied to project #${projectId}, you tried to perform operations on project #${opts.projectId}.`);
+            (0, logger_1.info)('Learn more about how API keys in Tolgee work here: https://tolgee.io/docs/platform/api-keys-and-pat-tokens');
+            process.exit(1);
+        }
+    }
+}
+async function preHandler(prog, cmd) {
+    if (!NO_KEY_COMMANDS.includes(topLevelName(cmd))) {
+        await validateApiKey(cmd);
+        await validateProjectId(cmd);
+        const opts = cmd.optsWithGlobals();
+        const client = new client_1.default({
+            apiUrl: opts.apiUrl,
+            apiKey: opts.apiKey,
+            projectId: opts.projectId,
+        });
+        cmd.setOptionValue('client', client);
+    }
+    // Apply verbosity
+    (0, logger_1.setDebug)(prog.opts().verbose);
+}
+const program = new commander_1.Command('tolgee')
+    .version(constants_1.VERSION)
+    .configureOutput({ writeErr: logger_1.error })
+    .description('Command Line Interface to interact with the Tolgee Platform')
+    .option('-v, --verbose', 'Enable verbose logging.')
+    .hook('preAction', preHandler);
+// Global options
+program.addOption(options_1.API_URL_OPT);
+program.addOption(options_1.API_KEY_OPT);
+program.addOption(options_1.PROJECT_ID_OPT);
+// Register commands
+program.addCommand(login_1.Login);
+program.addCommand(login_1.Logout);
+program.addCommand(push_1.default);
+program.addCommand(pull_1.default);
+program.addCommand(extract_1.default);
+program.addCommand(compare_1.default);
+program.addCommand(sync_1.default);
+async function loadConfig() {
+    const tgConfig = await (0, tolgeerc_1.default)();
+    if (tgConfig) {
+        for (const [key, value] of Object.entries(tgConfig)) {
+            program.setOptionValue(key, value);
+        }
+    }
+}
+async function handleHttpError(e) {
+    (0, logger_1.error)('An error occurred while requesting the API.');
+    (0, logger_1.error)(`${e.request.method} ${e.request.url}`);
+    (0, logger_1.error)(e.getErrorText());
+    // Remove token from store if necessary
+    if (e.response.status === 401) {
+        const removeFn = program.getOptionValue('_removeApiKeyFromStore');
+        if (removeFn) {
+            (0, logger_1.info)('Removing the API key from the authentication store.');
+            removeFn();
+        }
+    }
+    // Print server output for server errors
+    if ((0, logger_1.isDebugEnabled)()) {
+        // We cannot parse the response as JSON and pull error codes here as we may be here due to a 5xx error:
+        // by nature 5xx class errors can happen for a lot of reasons (e.g. upstream issues, server issues,
+        // catastrophic failure) which means the output is completely unpredictable. While some errors are
+        // formatted by the Tolgee server, reality is there's a huge chance the 5xx error hasn't been raised
+        // by Tolgee's error handler.
+        const res = await e.response.text();
+        (0, logger_1.debug)(`Server response:\n\n---\n${res}\n---`);
+    }
+}
+async function run() {
+    try {
+        await loadConfig();
+        await program.parseAsync();
+    }
+    catch (e) {
+        if (e instanceof errors_1.HttpError) {
+            await handleHttpError(e);
+            process.exit(1);
+        }
+        // If the error is uncaught, huge chance that either:
+        //  - The error should be handled here but isn't
+        //  - The error should be handled in the command but isn't
+        //  - Something went wrong with the code
+        (0, logger_1.error)('An unexpected error occurred while running the command.');
+        (0, logger_1.error)('Please report this to our issue tracker: https://github.com/tolgee/tolgee-cli/issues');
+        console.log(e.stack);
+        process.exit(1);
+    }
+}
+run();

package/dist/options.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXTRACTOR = exports.API_URL_OPT = exports.PROJECT_ID_OPT = exports.API_KEY_OPT = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const commander_1 = require("commander");
+const constants_1 = require("./constants");
+function parseProjectId(v) {
+    const val = Number(v);
+    if (isNaN(val) || val < 1) {
+        throw new commander_1.InvalidArgumentError('Not a valid project ID.');
+    }
+    return val;
+}
+function parseUrlArgument(v) {
+    try {
+        return new URL(v);
+    }
+    catch {
+        throw new commander_1.InvalidArgumentError('Malformed URL.');
+    }
+}
+function parsePath(v) {
+    const path = (0, path_1.resolve)(v);
+    if (!(0, fs_1.existsSync)(path)) {
+        throw new commander_1.InvalidArgumentError(`The specified path "${v}" does not exist.`);
+    }
+    return path;
+}
+exports.API_KEY_OPT = new commander_1.Option('-ak, --api-key <key>', 'Tolgee API Key. Can be a Project API Key or a Personal Access Token.').env('TOLGEE_API_KEY');
+exports.PROJECT_ID_OPT = new commander_1.Option('-p, --project-id <id>', 'Project ID. Only required when using a Personal Access Token.')
+    .default(-1)
+    .argParser(parseProjectId);
+exports.API_URL_OPT = new commander_1.Option('-au, --api-url <url>', 'The url of Tolgee API.')
+    .default(constants_1.DEFAULT_API_URL)
+    .argParser(parseUrlArgument);
+exports.EXTRACTOR = new commander_1.Option('-e, --extractor <extractor>', `A path to a custom extractor to use instead of the default one.`).argParser(parsePath);

package/dist/utils/ask.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askBoolean = exports.askString = void 0;
+const readline_1 = __importDefault(require("readline")); // readline/promises is Node 17, currently supporting Node 16+
+async function askString(question) {
+    return new Promise((resolve) => {
+        const rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question(`${question} `, (a) => {
+            resolve(a);
+            rl.close();
+        });
+    });
+}
+exports.askString = askString;
+async function askBoolean(question, def = false) {
+    const yn = def === true ? '[Y/n]' : '[y/N]';
+    let res = def;
+    const str = await askString(`${question} ${yn}`);
+    const strRes = str[0]?.toLowerCase();
+    if (strRes === 'y') {
+        res = true;
+    }
+    else if (strRes === 'n') {
+        res = false;
+    }
+    return res;
+}
+exports.askBoolean = askBoolean;

package/dist/utils/configPath.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const os_1 = require("os");
+const path_1 = require("path");
+function getConfigPath() {
+    switch (process.platform) {
+        case 'win32':
+            return (0, path_1.resolve)(process.env.APPDATA, 'tolgee');
+        case 'darwin':
+            return (0, path_1.resolve)((0, os_1.homedir)(), 'Library', 'Application Support', 'tolgee');
+        default:
+            return process.env.XDG_CONFIG_HOME
+                ? (0, path_1.resolve)(process.env.XDG_CONFIG_HOME, 'tolgee')
+                : (0, path_1.resolve)((0, os_1.homedir)(), '.config', 'tolgee');
+    }
+}
+exports.default = getConfigPath;

package/dist/utils/deferred.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeferred = void 0;
+function createDeferred() {
+    const deferred = {};
+    deferred.promise = new Promise((resolve, reject) => {
+        Object.assign(deferred, { resolve: resolve, reject: reject });
+    });
+    return deferred;
+}
+exports.createDeferred = createDeferred;

package/dist/utils/logger.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loading = exports.error = exports.warn = exports.success = exports.info = exports.debug = exports.isDebugEnabled = exports.setDebug = void 0;
+const SYMBOLS = ['      🐁', '    🐁  ', '  🐁    ', '🐁      '];
+let debugEnabled = false;
+/**
+ * Enables or disables debugging messages.
+ *
+ * @param enabled Whether debugging messages should be logged.
+ */
+function setDebug(enabled) {
+    debugEnabled = enabled;
+}
+exports.setDebug = setDebug;
+/**
+ * Gets the current status of debug logging.
+ *
+ * @returns Whether debugging is enabled.
+ */
+function isDebugEnabled() {
+    return debugEnabled;
+}
+exports.isDebugEnabled = isDebugEnabled;
+/**
+ * Logs a debug message to the console if debugging is enabled.
+ *
+ * @param msg The message.
+ */
+function debug(msg) {
+    if (debugEnabled) {
+        console.log(`⚪ ${msg}`);
+    }
+}
+exports.debug = debug;
+/**
+ * Logs an informative message to the console.
+ *
+ * @param msg The message.
+ */
+function info(msg) {
+    console.log(`🔵 ${msg}`);
+}
+exports.info = info;
+/**
+ * Logs a success to the console.
+ *
+ * @param msg The message.
+ */
+function success(msg) {
+    console.log(`✅ ${msg}`);
+}
+exports.success = success;
+/**
+ * Logs a warning message to the console.
+ *
+ * @param msg The message.
+ */
+function warn(msg) {
+    console.log(`🟡 ${msg}`);
+}
+exports.warn = warn;
+/**
+ * Logs an error message to the console.
+ *
+ * @param msg The message.
+ */
+function error(msg) {
+    console.log(`🔴 ${msg}`);
+}
+exports.error = error;
+/**
+ * Shows a loading indicator for a Promise until it resolves.
+ *
+ * @param comment Comment to display.
+ * @param promise The promise to watch.
+ * @returns The promise passed in parameter. Useful for decorating without using a buffer variable.
+ */
+function loading(comment, promise) {
+    let symbolPosition = 0;
+    const interval = setInterval(() => {
+        process.stdout.write(`\r${SYMBOLS[symbolPosition]} ${comment}`);
+        symbolPosition = (symbolPosition + 1) % 4;
+    }, 250);
+    promise.then(() => {
+        clearInterval(interval);
+        process.stdout.write(`\r🐭✅     ${comment}\n`);
+    }, () => {
+        clearInterval(interval);
+        process.stdout.write(`\r🐭🔴     ${comment}\n`);
+    });
+    return promise;
+}
+exports.loading = loading;

package/dist/utils/moduleLoader.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadModule = void 0;
+const path_1 = require("path");
+let tsService;
+function realImport(file) {
+    return eval('import(file)');
+}
+async function registerTsNode() {
+    if (!tsService) {
+        try {
+            const tsNode = require('ts-node');
+            tsService = tsNode.register({ compilerOptions: { module: 'CommonJS' } });
+        }
+        catch (e) {
+            if (e.code === 'ERR_MODULE_NOT_FOUND') {
+                throw new Error('ts-node is required to load TypeScript files.');
+            }
+            throw e;
+        }
+    }
+}
+async function importTypeScript(file) {
+    if ((0, path_1.extname)(__filename) === '.ts') {
+        return require(file);
+    }
+    await registerTsNode();
+    tsService.enabled(true);
+    const mdl = await realImport(file);
+    tsService.enabled(false);
+    return mdl;
+}
+async function loadModule(module) {
+    if (module.endsWith('.ts')) {
+        return importTypeScript(module);
+    }
+    const mdl = await realImport(module);
+    if (mdl.default?.default) {
+        return mdl.default;
+    }
+    return mdl;
+}
+exports.loadModule = loadModule;

package/dist/utils/overwriteDir.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.overwriteDir = void 0;
+const path_1 = require("path");
+const promises_1 = require("fs/promises");
+const ask_1 = require("./ask");
+const logger_1 = require("./logger");
+async function overwriteDir(path, overwrite) {
+    try {
+        const stats = await (0, promises_1.stat)(path);
+        if (!stats.isDirectory()) {
+            (0, logger_1.error)('The specified path already exists and is not a directory.');
+            process.exit(1);
+        }
+        if (!overwrite) {
+            if (!process.stdout.isTTY) {
+                (0, logger_1.error)('The specified path already exists.');
+                process.exit(1);
+            }
+            (0, logger_1.warn)(`The specified path ${(0, path_1.resolve)(path)} already exists.`);
+            const userOverwrite = await (0, ask_1.askBoolean)('Do you want to overwrite data? *BE CAREFUL, ALL THE CONTENTS OF THE DESTINATION FOLDER WILL BE DESTROYED*.');
+            if (!userOverwrite) {
+                (0, logger_1.error)('Aborting.');
+                process.exit(1);
+            }
+            // Purge data as requested.
+            await (0, promises_1.rm)(path, { recursive: true });
+        }
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT') {
+            throw e;
+        }
+    }
+    // Create the directory
+    await (0, promises_1.mkdir)(path, { recursive: true });
+}
+exports.overwriteDir = overwriteDir;

package/dist/utils/zip.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unzip = exports.unzipBuffer = void 0;
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const yauzl_1 = require("yauzl");
+const ZIP_PARSER_OPTS = {
+    strictFileNames: true,
+    decodeStrings: true,
+    lazyEntries: true,
+};
+function dumpFile(zip, entry, dest) {
+    zip.openReadStream(entry, (err, stream) => {
+        if (err)
+            throw err;
+        const writeStream = (0, fs_1.createWriteStream)(dest);
+        stream.pipe(writeStream);
+        // Unlock reading loop
+        stream.on('end', () => zip.readEntry());
+    });
+}
+/**
+ * Unzips a ZIP blob to a destination on disk.
+ *
+ * @param zipBlob The ZIP blob
+ * @param dest The destination path
+ */
+function unzipBuffer(zipBlob, dest) {
+    return new Promise((resolve, reject) => {
+        zipBlob.arrayBuffer().then((buffer) => {
+            const nodeBuffer = Buffer.from(buffer);
+            (0, yauzl_1.fromBuffer)(nodeBuffer, ZIP_PARSER_OPTS, (err, zip) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve(unzip(zip, dest));
+            });
+        });
+    });
+}
+exports.unzipBuffer = unzipBuffer;
+/**
+ * Unzips a ZIP file loaded in memory to a destination on disk.
+ *
+ * @param file The ZIP file
+ * @param dest The destination path
+ */
+function unzip(zip, dest) {
+    // Enforce expected & security options.
+    // Lazy entries is what this reader is based upon.
+    // Decode strings ensures file paths are sanitized by yazul
+    // and does not present any security threat to the machine.
+    if (!zip.lazyEntries || !zip.decodeStrings) {
+        throw new TypeError('Invalid ZIP file: lazyEntries and decodeStrings both must be set to true.');
+    }
+    return new Promise((resolve, reject) => {
+        zip.on('error', reject);
+        zip.on('end', resolve);
+        // There is no mechanism for zip files to contain directories
+        // by standards, and implementations diverge. Some make an explicit
+        // directory entry (ending with /), some don't make any specific treatment.
+        // The "safest" way is to check the path on files and create them as necessary.
+        const seenDirectories = new Set([dest]);
+        zip.readEntry();
+        zip.on('entry', (entry) => {
+            if (entry.fileName.endsWith('/')) {
+                zip.readEntry();
+                return;
+            }
+            const entryPath = (0, path_1.join)(dest, entry.fileName);
+            // Handle directory creation
+            const entryDirName = (0, path_1.dirname)(entryPath);
+            if (!seenDirectories.has(entryDirName)) {
+                (0, promises_1.mkdir)(entryDirName, { recursive: true }).then(() => dumpFile(zip, entry, entryPath));
+            }
+            else {
+                dumpFile(zip, entry, entryPath);
+            }
+        });
+    });
+}
+exports.unzip = unzip;

package/extractor.d.ts

@@ -0,0 +1,21 @@
+export type Key = {
+    keyName: string;
+    defaultValue?: string;
+    namespace?: string;
+};
+export type ExtractedKey = Key & {
+    line: number;
+};
+export type Warning = {
+    warning: string;
+    line: number;
+};
+export type Extractor = (fileContents: string, fileName: string) => string[];
+export type ExtractionResult = {
+    keys: ExtractedKey[];
+    warnings: Warning[];
+};
+export type ExtractionResults = Map<string, {
+    keys: ExtractedKey[];
+    warnings: Warning[];
+}>;

package/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "@tolgee/cli",
+  "version": "1.0.0-prerelease.1",
+  "type": "commonjs",
+  "description": "A tool to interact with the Tolgee Platform through CLI",
+  "bin": {
+    "tolgee": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "rimraf dist dist-types && tsc && cp dist-types/extractor/index.d.ts extractor.d.ts",
+    "test": "npm run test:unit && npm run test:e2e && npm run test:package",
+    "test:unit": "jest -c jest.unit.config.ts",
+    "pretest:e2e": "npm run tolgee:start",
+    "posttest:e2e": "npm run tolgee:stop",
+    "test:e2e": "jest -c jest.e2e.config.ts --runInBand",
+    "test:e2e-run": "jest -c jest.e2e.config.ts --runInBand",
+    "test:package": "node scripts/validatePackage.mjs",
+    "tolgee:start": "node scripts/startDocker.mjs",
+    "tolgee:stop": "docker stop tolgee_cli_e2e",
+    "lint": "prettier --check ./src ./test ./scripts jest.config.ts jest.*.config.ts",
+    "prettier": "prettier --write ./src ./test ./scripts jest.config.ts jest.*.config.ts",
+    "run-dev": "ts-node ./src/index.ts",
+    "schema": "openapi-typescript http://localhost:22222/v3/api-docs/All%20Internal%20-%20for%20Tolgee%20Web%20application --output src/client/internal/schema.generated.ts",
+    "release": "semantic-release"
+  },
+  "author": "Jan Cizmar",
+  "license": "MIT",
+  "dependencies": {
+    "ansi-colors": "^4.1.3",
+    "base32-decode": "^1.0.0",
+    "commander": "^10.0.0",
+    "cosmiconfig": "^8.0.0",
+    "form-data": "^4.0.0",
+    "glob": "^8.1.0",
+    "json5": "^2.2.3",
+    "undici": "^5.15.0",
+    "vscode-oniguruma": "^1.7.0",
+    "vscode-textmate": "^8.0.0",
+    "xstate": "^4.35.2",
+    "yauzl": "^2.10.0"
+  },
+  "devDependencies": {
+    "@jest/types": "^29.3.1",
+    "@semantic-release/changelog": "^6.0.2",
+    "@semantic-release/git": "^10.0.1",
+    "@types/glob": "^8.0.0",
+    "@types/jest": "^29.2.5",
+    "@types/node": "^18.11.18",
+    "@types/yauzl": "^2.10.0",
+    "jest": "^29.3.1",
+    "openapi-typescript": "^6.1.0",
+    "prettier": "^2.8.3",
+    "rimraf": "^4.0.7",
+    "semantic-release": "^20.0.2",
+    "ts-jest": "^29.0.5",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.4"
+  },
+  "engines": {
+    "node": ">= 18"
+  },
+  "files": [
+    "dist",
+    "textmate",
+    "extractor.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "release": {
+    "branches": [
+      "main",
+      {
+        "name": "next",
+        "channel": "next"
+      },
+      {
+        "name": "prerelease",
+        "channel": "rc",
+        "prerelease": true
+      }
+    ],
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      [
+        "@semantic-release/git",
+        {
+          "assets": [
+            "package.json",
+            "CHANGELOG.md"
+          ]
+        }
+      ],
+      "@semantic-release/npm",
+      "@semantic-release/github"
+    ]
+  }
+}

package/textmate/THIRD_PARTY_NOTICE

@@ -0,0 +1,31 @@
+THIRD PARTY LICENSES
+===
+
+Licensing information for the following files:
+ - TypeScript.tmLanguage
+ - TypeScriptReact.tmLanguage
+
+Copyright (c) Microsoft Corporation
+All rights reserved.
+
+MIT License
+
+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.
+
+---