@elo/elo-cli 1.0.2

package/dist/index.js

@@ -0,0 +1,3827 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { unlinkSync, readFileSync as readFileSync$1 } from "fs";
+import pathLib, { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { createHash, createDecipheriv, randomBytes, createCipheriv } from "node:crypto";
+import { readFile, writeFile as writeFile$2, accessSync, readFileSync, readdirSync, createReadStream, mkdirSync, createWriteStream } from "node:fs";
+import { access, writeFile as writeFile$1, rm, readFile as readFile$1, readdir } from "node:fs/promises";
+import chalk from "chalk";
+import archiver from "archiver";
+import axios from "axios";
+import { wrapper } from "axios-cookiejar-support";
+import { JSDOM } from "jsdom";
+import readline from "readline";
+import { CookieJar } from "tough-cookie";
+import { Client, LockC, PackageC, ConflictHandlingE } from "@elo/ix-client-typescript";
+import { pipeline } from "stream/promises";
+import prompts from "prompts";
+import { execSync, exec } from "child_process";
+import { readdir as readdir$1 } from "fs/promises";
+import readline$1 from "node:readline";
+import FastGlob from "fast-glob";
+import os from "os";
+const CONSTANTS = {
+  PLACEHOLDER: {
+    PATH: "[path]",
+    URL: "[url]",
+    LANG: "[lang]",
+    NAME: "[name]",
+    NUMBER: "[number]",
+    YESNO: "[y/n]",
+    PW: "[pw]"
+  },
+  MANIFESTFILE: "manifest.json",
+  MAINTSFILE: "main.ts",
+  MAINJSFILE: "main.js",
+  PACKAGEFILE: "package.json",
+  LICENSECASES: [
+    "LICENCE",
+    "LICENSE",
+    "License",
+    "license",
+    "LICENSE-MIT",
+    "LICENSE.txt",
+    "License.txt",
+    "license.txt",
+    "LICENSE.md",
+    "License.md",
+    "license.md",
+    "LICENSE.BSD",
+    "LICENSE-MIT.txt",
+    "LICENCE.md"
+  ],
+  NOTICECASES: [
+    "NOTICE",
+    "Notice",
+    "notice",
+    "NOTICE.txt",
+    "Notice.txt",
+    "notice.txt",
+    "NOTICE.md",
+    "Notice.md",
+    "notice.md"
+  ],
+  GLOBBYPATTERN: "**/*.{js,ts,vue}",
+  GLOBBYOPTIONS: {
+    ignore: [
+      "public/**",
+      "coverage/**",
+      "dist/**",
+      "node_modules/**",
+      "tests/**",
+      "elo-vue-libs/**",
+      "locales/**",
+      "src/locales/**",
+      "jsLocales/**",
+      "src/lib/jsLocales/**",
+      "src/lib/misc/**",
+      "main.js",
+      "babel.config.js",
+      "nyc.config.js",
+      "postcss.config.js",
+      "vue.config.js",
+      "nav.config"
+    ]
+  },
+  DEPENDENCIETYPES: ["dependencies", "devDependencies", "peerDependencies"],
+  DASHEDLINE: "--------------------------------------------------------------------------------",
+  LICENSEFILEHEADER: `THIRD-PARTY SOFTWARE LICENSES, NOTICES AND INFORMATION FOR %s.
+
+Do Not Translate or Localize
+
+This file is based on or incorporates material from third party (Third Party IP). Therefore this file contain third party notices or additional terms and conditions applicable to certain software technologies which may be used in one or more ELO products and/or services.
+Please be sure to consult the individual product files, about box and/or install or manual documentation for specific copyright notices and author attributions. Notices in this file are current for ELO products released on or after February, 2020.
+The original copyright notice and the license under which ELO received such Third Party IP, are set forth below. Such licenses and notices are provided for informational purposes only. ELO licenses the Third Party IP to you under the licensing terms for the ELO product.
+ELO reserves all other rights not expressly granted under this agreement, whether by implication, estoppel or otherwise.
+
+
+Written Offer for Source Code
+
+For Third-Partry IP received from ELO that are licensed under any version of the GNU General Public License (GPL) or the GNU LGPL, or another license that claim to provide the sources, you can receive a complete machine-readable copy of the source code by sending a written request to:
+
+ELO Digital Office GmbH
+ Tübinger Straße 43
+70178 Stuttgart
+
+Your request should include: (i) the name of the covered binary, (ii) the version number of the Oracle product containing the covered binary, (iii) your name, (iv) your company name (if applicable) and (v) your return mailing and email address (if available).
+
+We may charge you a nominal fee to cover the cost of the media and distribution.
+
+Your request must be sent within three (3) years of the date you received the GPL or LGPL covered code.
+
+Additionally, the source code may also be found at:
+ https://download.elo.com/oss/
+
+
+`
+};
+const STRING = {
+  INIT: {
+    INFO: "ELO Apps command line build system for Node.js.",
+    START: "Running init command",
+    DESCRIPTION: "Init nodejs web application as ELO app.",
+    OPTIONS: {
+      WFURL: { DESC: "Url to the ELOwf instance, for example: %s" },
+      INDEXHTML: { DESC: "The name of the index file, for example: %s" },
+      SORDTYPEICONS: {
+        DESC: "Are 'ELO Sordtype Icons' required for this project? For example: %s"
+      },
+      ARCHIVEICON: { DESC: "Are 'Archive Icons' required for this project? For example: %s" },
+      SRC: {
+        DESC: "The relative path where the source files, like the index.html, are, for example: %s"
+      },
+      DIST: {
+        DESC: "The relative path where the output files, like the index.html, will be, for example: %s"
+      },
+      INDEXHTMLPATH: {
+        DESC: "The relative path where the index.html file is located, for example in Vue2: %s for Vue3 it is ."
+      },
+      NAMESPACE: { DESC: "The app namespace, for example: %s" },
+      ID: { DESC: "The app id, for example: %s" },
+      DEFAULTLANGUAGE: { DESC: "The default language, for example: %s" },
+      BUILD: { DESC: "The build number of the app, for example: %s" },
+      USEELOSESSION: { DESC: "Enable, to use elo session, for example: %s" },
+      DEVREDIRECT: {
+        DESC: "Dev url of the app, which the login site of the ELOwf will redirect after successfull login. Necessary if elo session is enabled, for example: %s"
+      }
+    },
+    DEPLOY: {
+      OPTIONS: {
+        REPOSYTORY: { DESC: "Repository containing json config file, for example: %s" }
+      }
+    }
+  },
+  SETUP: {
+    DESC: "Create default settings for all upcoming initializations.",
+    OPTIONS: {
+      SERVERURL: { DESC: "Url of the server, for example: %s" },
+      ADMINNAME: { DESC: "Username of an administrator for a ix login." },
+      ADMINPW: {
+        DESC: "According administrator password. This password will be stored encrypted but the key is not secure and can be read from the current machines hard drive. Only use test installations."
+      },
+      NEWREPO: { DESC: "Creates new project archive settings." }
+    }
+  },
+  NEWREPO: {
+    DESC: "Creates '.elo-repositories/[archiveName].json' file containing project archive settings.",
+    OPTIONS: {}
+  },
+  DEPLOY: {
+    DESC: "Deploys the web application into the ELOwf",
+    OPTIONS: {
+      REPOSITORY: {
+        DESC: "Repository containing json config file, for example: %s"
+      },
+      NEON: {
+        DESC: "To deploy a Neon extension the client plugin, instead of an ELO App to the ELOwf."
+      }
+    }
+  },
+  BUILD: {
+    DESC: "Builds the web application.",
+    OPTIONS: {
+      KEY: {
+        DESC: "Sets the an arbitrary json key in the manifest.json, for example: %s"
+      },
+      VALUE: {
+        DESC: "Sets the value of the key value pair, defined by --key, for example: %s"
+      }
+    }
+  },
+  IMPORT: {
+    DESC: "Imports package or archive data into the ELO repository.",
+    OPTIONS: {
+      MODE: {
+        DESC: "The type of import 'archive' for archive data, 'workflow' for a workflow-template, 'entry' for an arbitrary file or 'package' for an ELO package."
+      },
+      GUID: {
+        DESC: "[archive|entry] The guid of the folder in the repository to import the data to. [workflow] The user id unknown person nodes will be replaced with."
+      },
+      SRC: {
+        DESC: "The file of the import data."
+      },
+      FLOWNAME: {
+        DESC: "[workflow] The template name of the imported workflow."
+      },
+      RELOADSCRIPTS: {
+        DESC: "[entry: type=script] Reloads the scripts after the import."
+      }
+    }
+  },
+  EXPORT: {
+    DESC: "Exports package or archive data from the ELO repository.",
+    OPTIONS: {
+      GUID: {
+        DESC: "The guid of the entry or the name/guid of the package to export."
+      },
+      DIST: {
+        DESC: "The file of the export data."
+      }
+    }
+  },
+  LOCALIZE: {
+    DESC: "Creates the language files for the web application.",
+    OPTIONS: {
+      SRC: { DESC: "The path where the properties files are." },
+      DIST: { DESC: "The path where the js files will be. The directory will be cleared." }
+    }
+  },
+  HELPER: {
+    CRYPTKEY: "NW7jFhExSLRtwtZWvMq9HKGb3yZTPS89d4ebEbR7mmWHcuVNYfU9XqJrbBw6Ms2uNTePNBBp67WV7KTe6FeVZNr7rdvGY3ZyjBYTWdNpxuVBKtDEfZRYm7Lqn8BHpNSsQp3tAqEuhva4wKwyTHwdEhx7qSwCAw7qaGxKdSYNqQeRuCCrKzDjX4URvAFmreTtruVrj88EBznS4CPeDHqnCsF6YAg2sSm9JyRgtCTwgGaQ6uFgvH8WZ6X4Hefvj8nZ",
+    DEPRECATED_ENCRYPTION: "The settings file uses an old, deprecated encryption. Please update the settings file using 'elo setup'.",
+    EMPTYPATH: "The file could not be located in the specified path.",
+    NOPATH: "The specified path does not exist.",
+    PATH_NOT_EXIST: "%s does not exist!"
+  },
+  UTILS: {
+    OPTION_NOT_VALID: "%s is not valid!"
+  },
+  INFO: {
+    SETTINGSBUILD: "Setting build to %s",
+    COPYFILES: "Copying files into ELOwf",
+    IXCONNECT: "Creating ix connection",
+    SETKEYVALUE: "Existing value of key '%s' will be overwritten in dist/manifest.json.",
+    CHARSREPLACED: "All restricted characters in 'id' were replaced with an underscore ('_').",
+    MANIFESTSTORED: "Manifest stored",
+    COPYMANIFEST: "Copying manifest into ELOwf",
+    WFREQUEST: "Sending request to ELOwf",
+    WFREQUESTSUCCESS: "ELOwf successfully called",
+    IXCONNSUCCESS: "Connection to ix was successful",
+    MAINJSEMPTY: "'main.js' is empty",
+    MAINJS: "Please make sure, that your 'main.js' looks like this:",
+    MAINTS: "Please make sure, that your 'main.ts' looks like this:",
+    INITCOMPLETE: "Initialization completed",
+    VUECONFJS: "Please create or modify your 'vue.config.js' file to the following:",
+    VITECONFTS: "Please create or modify your 'vite.config.ts' file to the following:",
+    NOVUEAPP: "No Vue.js app",
+    WFREFRESH: "Trying a refresh in ELOwf AppManager at: ",
+    WFREFRESHCOMPLETED: "Refresh in ELOwf AppManager completed",
+    WRITINGSETUP: "Writing setup file (%s)",
+    PATHCREATED: "'%s' created.",
+    REPOCONFSAVE: "Repository settings saved %s",
+    SETUPCOMPLETE: "Setup completed",
+    SKIP: "Pressing enter will skip the current option",
+    SETUPCOMPLETED: "Setup completed",
+    BUILDCOMPLETED: "Build completed",
+    DEPLOYCOMPLETED: "Deploy completed",
+    NEONDEPLOY: "Trying a send extension to neon: ",
+    NEONDEPLOYCOMPLETED: "Extension upload to neon was successful",
+    RELOADCOMPLETE: "The reload was successful",
+    IMPORTCOMPLETE: "The import was successful",
+    EXPORTCOMPLETE: "The export was successful",
+    LICENSESAVED: "in '3rdpartylicenses.txt' saved.",
+    NPMFOUND: "Detected npm as package manager.",
+    PNPMFOUND: "Detected pnpm as package manager.",
+    YARNFOUND: "Detected yarn as package manager.",
+    CREATINGPATH: "Creating path %s",
+    CREATINGDEFAULTLANGFILE: "Creating default language file",
+    CHECKDUPLICATEKEYS: "Checking '%s' file for key duplicates",
+    NOKEYDUPLICATESFOUND: "No key duplicates found",
+    CHECKUNUSEDKEYS: "Checking '%s' files for unused keys",
+    NOUNUSEDKEYSFOUND: "No unused keys in '%s' files found.",
+    CREATEDISTDIR: "Create dist folder at '%s'.",
+    CREATELOCALESDIR: "Create locales folder at '%s'.",
+    NOUNUSEDKEYS: "No unused keys found.",
+    PROPERTIESPROCESSED: "Process properties file '%s' completed.",
+    STARTINTIGRITYCHECK: "Starting language integrity check...",
+    LANGUAGEINTEGRITYCHECK: "Language integrity check for '%s' completed.",
+    NEWLANGUAGEFOUND: "Language '%s' found in properties file but not listed in manifest supported locales.",
+    WRITELOCALESFILE: "Completing writing locales file '%s'.",
+    LOCALIZATIONCOMPLETE: "Localization complete.",
+    WRITEREPORTFILE: "Writing localization report file to '%s'.",
+    REPORTCOMPOLETED: "Localization report file written.",
+    MUTATEPACKAGEJSON: "Mutating package.json versions for package '%s'.",
+    MUTATEMANIFEST: "Mutating manifest.json version for package '%s'.",
+    CONFIGVALIDATED: "Multi-repo configuration validated successfully.",
+    STARTPUBLISHCOMMAND: "Starting publish command...",
+    MULTIREPOMODE: "Multi-repo mode enabled.",
+    PUBLISHSUCCESS: "Publish for package '%s' successful.",
+    PUBLISHLATESTSUCCESS: "Publish latest tag for package '%s' successful.",
+    PUBLISHCOMMANDCOMPLETED: "Publish command completed successfully."
+  },
+  WARN: {
+    IXNOTINIT: "IXClient was not initialized.",
+    IDLENMSG: "'id' (ELO App id) exceeds the maximum amount of 30 characters ('id' length restriction). 'id' has currently %s characters.",
+    NOID: "'id' (ELO App id) is empty.",
+    NOCLILINKING: "Linking of 'elo-cli' is not supported by 'elo link'. This may fail. Consider removing it from your 'package.json' eloDependencies array key.",
+    LICENSENOTFOUND: "No license found for: %s",
+    CHANGELANGUAGEVALUE: "Key '%s' in language '%s' is missing. Using language '%s' value."
+  },
+  ERROR: {
+    INDEXHTMLNOTFOUND: "'index.html' not found in: %s",
+    WFREFRESHSKIP: "Skipped refresh in ELOwf AppManager, because %s is not given. It can be set with the elo setup command.",
+    IXCONNECTSKIP: "The try to connect to IX was skipped because credentials were not provided. This can be configured using the elo setup command.",
+    PATHNOTEXIST: "%s does not exist!",
+    NOVALUE: "--value <undefined>' parameter is undefined. Use '--key myKey --value myValue.",
+    NOKEY: "--key <undefined>' parameter is undefined. Use '--key myKey --value myValue.",
+    WFREFRESH: "Refresh in ELOwf AppManager failed",
+    IXCONN: "Could not create ix connection",
+    MAINJSNOTFOUND: "'main.js' not found!",
+    WFREQUEST: "Request to ELOwf failed",
+    PROMPT: "Couldnt prompt for input. If this has occurred during a password prompt, then your command line does not support this.",
+    OPTIONNOTVALID: "%s is not valid!",
+    NOSETTINGSPATH: "Path '%s' does not exist.",
+    NOSETTINGSFOUND: 'No settings found. Please run "elo setup" first.',
+    NOMANIFEST: "No 'manifest.json' found in the project root",
+    NEONDEPLOY: "Error uploading extension to neon.",
+    IMPORT: "Could not import file.",
+    EXPORT: "Could not export file.",
+    NOTENOUGHARGSFORINJECT: "Not enough arguments for an injection given!",
+    PACKAGENOTFOUND: 'Package "%s" does not exist in the repository.',
+    NOELODEPENDENCIES: "'No 'ELO Dependencies' found to link in 'package.json'.\nDoes 'package.json' contain 'eloDependencies' key?'",
+    LINKDEPENDENCY: "Could not link dependencies.",
+    NOPACKAGEMANAGERFOUND: "No supported package manager found in the project directory tree.",
+    SRCPATHREQIRED: "* Source path is required.",
+    DISTPATHREQIRED: "* Distribution path is required.",
+    NODEFAULTLANG: "* No default language found in manifest data.",
+    NOSUPPORTEDLOCALES: "* No supported locales found in manifest data.",
+    PROPERTIESNOTFOUND: "No properties file found in src directory.",
+    CREATENEWLOCALES: "Could not create new localization files: %s",
+    CHECKUNUSEDKEYS: "Error while checking unused keys: %s",
+    DUPDEFAULTLANGFILE: "Duplicate default language file found. Only one default language file is allowed.",
+    WRITELOCALESFILE: "Error while writing locales file: %s",
+    GETPROPERTYFILES: "Error while getting property files: %s",
+    GETKEYSCHECKDUPLICATES: "Error while getting keys and checking duplicates: %s",
+    CREATELOCALESMAP: "Error while creating locales map: %s",
+    MULTIREPOCONFIGEMPTYPART: 'Each repository in multi-repo configuration must have a "path" and "name" property.',
+    PACKAGEJSONNOTFOUND: "package.json not found at path: %s",
+    CREDENTIALSWROMGFORMAT: "Credentials must be in the format username:password",
+    CONFIGFILENOTFOUND: "Multi-repo configuration file not found at path: %s",
+    PUBLISHPRIVATEPACKAGE: 'Cannot publish a private package. Please set "private": false in package.json. Package: %s'
+  },
+  CODE: {
+    MAINJSCODE: [
+      "import Vue from 'vue';",
+      "import App from './App.vue';",
+      "import { WebApp } from '@elo/core';",
+      "// if IXConnecttion is needed",
+      "import de from '@elo/eloixclient';",
+      "// if ELO session is needed",
+      "import { Session } from '@elo/session';",
+      "",
+      "// Initialize Vue after initializing the ELO App.",
+      "WebApp.setOnLoad(function() {",
+      "    new Vue({",
+      "        render: (h) => h(App)",
+      "    }).$mount('#app');",
+      "});",
+      "// Initialize the ELO App.",
+      "// if no ELO session is needed",
+      "// WebApp.init();",
+      "// if ELO session is needed, but no IXConnection",
+      "// Session.init();",
+      "// if IXConnection is needed",
+      "Session.init(de.elo.ix.client);"
+    ],
+    MAINTSCODE: [
+      "import { createApp } from 'vue'",
+      "import { initEloBaseServices, ixService, logger } from '@elo/elo-base-lib';",
+      "import { LockC, EditInfoC } from '@elo/ix-client-typescript';",
+      "...",
+      "import App from './App.vue'",
+      "",
+      "// Initialize the elo base services",
+      "try {",
+      "  await initEloBaseServices() // perform redirect to ELO login if not authenticated.",
+      "",
+      "  // --- example call to ix: checkout root repository folder.",
+      "  const sord = await ixService.callIxEndpoint('checkoutSord', {",
+      "    objId: '1',",
+      "    editInfoZ: EditInfoC.mbSord,",
+      "    lockZ: LockC.NO",
+      "  })",
+      "  logger.info('Checked out sord:', sord.sord!.name);",
+      "  // ---",
+      "",
+      "  createApp(App).mount('#app') // <- mount the app after initialization is complete",
+      "} catch (error) {",
+      "  console.error('Failed to initialize ELO Base Lib:', error);",
+      "}"
+    ],
+    VITECONFTSCODE: [
+      "import { defineConfig, ProxyOptions } from 'vite'",
+      "import TestHelpers from '@elo/elo-cli'; // load global config from elo-cli",
+      "...",
+      "",
+      "TestHelpers.init(<repository?>); //repository is optional",
+      "",
+      "const config = {",
+      "   ...,",
+      "   base: '',",
+      "   server: {",
+      "       ...,",
+      "       port: <port>, // must be the same as devRedirect in manifest.json",
+      "       proxy: {} as Record<string, string | ProxyOptions>",
+      "   }",
+      "};",
+      "config.server.proxy[TestHelpers.getIxContext()] = {",
+      "    target: TestHelpers.getIxServer(),",
+      "    changeOrigin: true",
+      "};",
+      "export default defineConfig(config);"
+    ],
+    VUECONFJSCODE: [
+      "import TestHelpers from '@elo/elo-cli'; // load global config from elo-cli",
+      "",
+      "TestHelpers.init(<repository?>); //repository is optional",
+      "",
+      "let config = {",
+      "   publicPath: './',",
+      "   devServer: {",
+      "       disableHostCheck: true,",
+      "       proxy: {}",
+      "   }",
+      "};",
+      "config.devServer.proxy[TestHelpers.getIxContext()] = {",
+      "    target: TestHelpers.getIxServer(),",
+      "    secure: false,",
+      "    logLevel: `debug`",
+      "};",
+      "module.exports = config;"
+    ]
+  }
+};
+var messageTypes = /* @__PURE__ */ ((messageTypes2) => {
+  messageTypes2["INFO"] = "INFO";
+  messageTypes2["WARN"] = "WARN";
+  messageTypes2["ERROR"] = "ERROR";
+  messageTypes2["DEFAULT"] = "";
+  return messageTypes2;
+})(messageTypes || {});
+const EXIT_WITH_ERROR = 1;
+process.env.ELOBUILDSETTINGSPATH = `${process.env[process.platform === "win32" ? "USERPROFILE" : "HOME"]}/.elo-cli-settings.json`;
+const globalSettingsPath = process.env.ELOBUILDSETTINGSPATH;
+const cryptKey = STRING.HELPER.CRYPTKEY;
+function ensureSlash(text = "") {
+  return text.endsWith("/") ? text : `${text}/`;
+}
+function unixPathSep(path = "") {
+  return path.replace(/\\+/g, "/");
+}
+function message(type, msg, ..._opt) {
+  switch (type) {
+    case messageTypes.INFO:
+      console.log(chalk.cyan(`  [${type}] ${msg}`), ..._opt);
+      break;
+    case messageTypes.WARN:
+      console.log(chalk.yellow(`  [${type}] ${msg}`), ..._opt);
+      break;
+    case messageTypes.ERROR:
+      console.log(chalk.red(`  [${type}] ${msg}`), ..._opt);
+      break;
+    case messageTypes.DEFAULT:
+    default:
+      console.log(`      ${msg}`, ..._opt);
+  }
+}
+function error(error2, noExit, ..._opt) {
+  console.log(chalk.red(`  [${messageTypes.ERROR}] ${error2}`), ..._opt);
+  if (!noExit) {
+    process.exit(EXIT_WITH_ERROR);
+  }
+}
+function handleConnectionError(error2, msg) {
+  console.log(chalk.red(`  [${messageTypes.ERROR}] ${msg}`));
+  console.log(chalk.red(`  [${messageTypes.ERROR}] Message: ${error2.message}`));
+  if (error2.code !== void 0) {
+    console.log(chalk.red(`  [${messageTypes.ERROR}] Code: ${error2.code}`));
+  }
+  process.exit(EXIT_WITH_ERROR);
+}
+function encrypt(text) {
+  const iv = randomBytes(16);
+  const key = createHash("sha256").update(cryptKey).digest();
+  const cipher = createCipheriv("aes-256-ctr", key, iv);
+  const encrypted = Buffer.concat([cipher.update(text, "utf8"), cipher.final()]);
+  return {
+    iv: iv.toString("hex"),
+    content: encrypted.toString("hex")
+  };
+}
+function decrypt(encryptedData) {
+  if (encryptedData && encryptedData.value === "4c9cd7706a" && encryptedData.alg === "aes-256-ctr") {
+    message(messageTypes.WARN, STRING.HELPER.DEPRECATED_ENCRYPTION);
+    return "elo";
+  }
+  const key = createHash("sha256").update(cryptKey).digest();
+  const decipher = createDecipheriv("aes-256-ctr", key, Buffer.from(encryptedData.iv, "hex"));
+  const decrypted = Buffer.concat([
+    decipher.update(Buffer.from(encryptedData.content, "hex")),
+    decipher.final()
+  ]);
+  return decrypted.toString("utf8");
+}
+function getFileContentSync(filePath) {
+  let content;
+  if (existsSync(filePath)) {
+    content = String(readFileSyncFunction(filePath));
+    if (content !== "") {
+      return content;
+    } else {
+      message(messageTypes.WARN, STRING.HELPER.EMPTYPATH);
+    }
+  } else {
+    message(messageTypes.WARN, STRING.HELPER.NOPATH);
+  }
+}
+async function getFileContent(filePath) {
+  let content;
+  if (await exists(filePath)) {
+    content = await readFileFunction(filePath);
+    if (content !== "") {
+      return content;
+    } else {
+      message(messageTypes.WARN, STRING.HELPER.EMPTYPATH);
+    }
+  } else {
+    message(messageTypes.WARN, STRING.HELPER.NOPATH);
+  }
+}
+async function findRepository() {
+  try {
+    const dirNamePath = pathLib.resolve(".elo-repository");
+    const files = await readDir(dirNamePath);
+    if (files.length === 0) return "NONE";
+    if (files.length > 1)
+      message(
+        messageTypes.WARN,
+        "Multiple repositories found in .elo-repository. Using the first one found."
+      );
+    return files[0].replace(".json", "");
+  } catch (error2) {
+    message(messageTypes.WARN, `Can not reading .elo-repository directory: ${error2}`);
+    return "NONE";
+  }
+}
+function findRepositorySync() {
+  try {
+    const dirNamePath = pathLib.resolve(".elo-repository");
+    const files = readDirSync(dirNamePath);
+    if (files.length === 0) return "NONE";
+    if (files.length > 1)
+      message(
+        messageTypes.WARN,
+        "Multiple repositories found in .elo-repository. Using the first one found."
+      );
+    return String(files[0]).replace(".json", "");
+  } catch (error2) {
+    message(messageTypes.WARN, `Can not reading .elo-repository directory: ${error2}`);
+    return "NONE";
+  }
+}
+async function getRepositoryName(repoName) {
+  if (repoName === void 0 || repoName === "") {
+    const currentRepoPath = "./.elo-current-repository";
+    if (await exists(currentRepoPath)) {
+      repoName = await getFileContent(currentRepoPath);
+      message(messageTypes.INFO, `Using archive from file .elo-current-repository: ${repoName}`);
+    } else {
+      repoName = await findRepository();
+    }
+  }
+  return repoName?.trim() ?? "ELO_GLOBAL";
+}
+function getRepositoryNameSync(repoName) {
+  if (repoName === void 0 || repoName === "") {
+    const currentRepoPath = pathLib.resolve(".elo-current-repository");
+    if (existsSync(currentRepoPath)) {
+      repoName = getFileContentSync(currentRepoPath);
+      message(messageTypes.INFO, `Using archive from file .elo-current-repository: ${repoName}`);
+    } else {
+      repoName = findRepositorySync();
+    }
+  }
+  return repoName?.trim() ?? "ELO_GLOBAL";
+}
+function getSettingsJsonSync(repoName) {
+  repoName = getRepositoryNameSync(repoName);
+  message(messageTypes.INFO, `testhelpers.init:${repoName}`);
+  if (repoName === "ELO_GLOBAL") {
+    return getGlobalSettingsJsonSync();
+  } else {
+    return getLocalSettingsJsonSync(repoName, true);
+  }
+}
+async function getSettingsJson(repoName) {
+  repoName = await getRepositoryName(repoName);
+  message(messageTypes.INFO, `testhelpers.init:${repoName}`);
+  if (repoName === "ELO_GLOBAL") {
+    return await getGlobalSettingsJson();
+  } else {
+    return await getLocalSettingsJson(repoName, true);
+  }
+}
+function getGlobalSettingsJsonSync(errorIfNotExist = false) {
+  let settingsJson = {
+    manifest: {},
+    ixLogin: { adminName: "", adminPw: { content: "", iv: "" } }
+  };
+  if (existsSync(globalSettingsPath)) {
+    message(messageTypes.INFO, `path: ${globalSettingsPath}`);
+    settingsJson = JSON.parse(String(readFileSyncFunction(globalSettingsPath)));
+  } else if (errorIfNotExist) {
+    error(STRING.HELPER.PATH_NOT_EXIST, false, unixPathSep(globalSettingsPath));
+  }
+  return settingsJson;
+}
+async function getGlobalSettingsJson(errorIfNotExist = false) {
+  let settingsJson = {
+    manifest: {},
+    ixLogin: { adminName: "", adminPw: { content: "", iv: "" } }
+  };
+  if (await exists(globalSettingsPath)) {
+    message(messageTypes.INFO, `path: ${globalSettingsPath}`);
+    settingsJson = JSON.parse(await readFileFunction(globalSettingsPath));
+  } else if (errorIfNotExist) {
+    error(STRING.HELPER.PATH_NOT_EXIST, false, unixPathSep(globalSettingsPath));
+  }
+  return settingsJson;
+}
+function getLocalSettingsJsonSync(archivName, errorIfNotExist = false) {
+  let settingsJson = {};
+  const path = `./.elo-repository/${archivName}.json`;
+  message(messageTypes.INFO, `helpers.getArchiveJson:${archivName}`);
+  if (!existsSync(path)) {
+    if (errorIfNotExist) {
+      message(messageTypes.ERROR, STRING.HELPER.PATH_NOT_EXIST, unixPathSep(globalSettingsPath));
+    }
+  } else {
+    settingsJson = existsSync(path) ? JSON.parse(getFileContentSync(path)) : void 0;
+  }
+  return settingsJson;
+}
+async function getLocalSettingsJson(archivName, errorIfNotExist = false) {
+  let settingsJson = {};
+  const path = `./.elo-repository/${archivName}.json`;
+  message(messageTypes.INFO, `helpers.getArchiveJson:${archivName}`);
+  if (!await exists(path)) {
+    if (errorIfNotExist) {
+      message(messageTypes.ERROR, STRING.HELPER.PATH_NOT_EXIST, unixPathSep(globalSettingsPath));
+    }
+  } else {
+    settingsJson = await exists(path) ? JSON.parse(await getFileContent(path)) : void 0;
+  }
+  return settingsJson;
+}
+function getParameterInObject(object, key) {
+  return object[key];
+}
+function setParameterInObject(object, key, val) {
+  const obj = object;
+  obj[key] = val;
+  return obj;
+}
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      return false;
+    } else {
+      error(e, true);
+    }
+  }
+  return false;
+}
+function existsSync(path) {
+  try {
+    accessSync(path);
+    return true;
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      return false;
+    } else {
+      error(e, true);
+    }
+  }
+  return false;
+}
+async function readFileFunction(path) {
+  const resolvedPath = pathLib.resolve(path);
+  return await readFile$1(resolvedPath, "utf8");
+}
+function readFileSyncFunction(path) {
+  return readFileSync(path);
+}
+function readFileBase64(path) {
+  return readFileSync(path, { encoding: "base64" });
+}
+async function writeFile(path, input) {
+  return await writeFile$1(path, input);
+}
+function readFileCB(path, callback) {
+  return readFile(path, callback);
+}
+function writeFileCB(path, manifest, callback) {
+  return writeFile$2(path, manifest, callback);
+}
+function createReadStreamSync(src) {
+  return createReadStream(src);
+}
+function createWriteStreamSync(file) {
+  return createWriteStream(file);
+}
+function mkdir(path, recursive) {
+  if (recursive) {
+    return mkdirSync(path, { recursive: true });
+  }
+  return mkdirSync(path);
+}
+async function readDir(path) {
+  return await readdir(path, { recursive: true });
+}
+function readDirSync(path) {
+  return readdirSync(path, { recursive: true });
+}
+async function removeFile(filePath) {
+  try {
+    if (await exists(filePath)) {
+      await rm(filePath, { recursive: true });
+      message(messageTypes.INFO, `File deleted: ${filePath}`);
+    }
+  } catch (err) {
+    throw new Error(err);
+  }
+}
+async function isFolderEmpty(folderPath) {
+  try {
+    const files = await readdir(folderPath);
+    return files.length === 0;
+  } catch {
+    return true;
+  }
+}
+const commands = {
+  init: {},
+  setup: {},
+  newrepo: {},
+  deploy: {},
+  import: {},
+  export: {},
+  localize: {}
+};
+commands.init = {
+  description: STRING.INIT.DESCRIPTION,
+  path: CONSTANTS.PLACEHOLDER.PATH,
+  noManifest: ["repository"],
+  options: {
+    repository: {
+      ignore: true,
+      value: "repository",
+      placeHolder: CONSTANTS.PLACEHOLDER.NAME,
+      description: STRING.INIT.DEPLOY.OPTIONS.REPOSYTORY.DESC,
+      eg: "myArchive"
+    },
+    indexHtml: {
+      value: "index_Html",
+      placeHolder: CONSTANTS.PLACEHOLDER.NAME,
+      description: STRING.INIT.OPTIONS.INDEXHTML.DESC,
+      defaultValue: "index.html",
+      eg: "index.html"
+    },
+    sordTypeIcons: {
+      value: "use_sordType_icons",
+      placeHolder: CONSTANTS.PLACEHOLDER.YESNO,
+      description: STRING.INIT.OPTIONS.SORDTYPEICONS.DESC,
+      eg: "y"
+    },
+    archiveIcons: {
+      value: "use_archive_icons",
+      placeHolder: CONSTANTS.PLACEHOLDER.YESNO,
+      description: STRING.INIT.OPTIONS.ARCHIVEICON.DESC,
+      eg: "y"
+    },
+    src: {
+      value: "src",
+      placeHolder: CONSTANTS.PLACEHOLDER.PATH,
+      description: STRING.INIT.OPTIONS.SRC.DESC,
+      defaultValue: "src/",
+      eg: "src/"
+    },
+    dist: {
+      value: "dist",
+      placeHolder: CONSTANTS.PLACEHOLDER.PATH,
+      description: STRING.INIT.OPTIONS.DIST.DESC,
+      defaultValue: "dist/",
+      eg: "dist/"
+    },
+    indexHtmlPath: {
+      value: "indexHtmlPath",
+      placeHolder: CONSTANTS.PLACEHOLDER.PATH,
+      description: STRING.INIT.OPTIONS.INDEXHTMLPATH.DESC,
+      defaultValue: ".",
+      eg: "public/"
+    },
+    namespace: {
+      value: "namespace",
+      placeHolder: CONSTANTS.PLACEHOLDER.NAME,
+      description: STRING.INIT.OPTIONS.NAMESPACE.DESC,
+      eg: "my.example.namespace"
+    },
+    id: {
+      value: "id",
+      placeHolder: CONSTANTS.PLACEHOLDER.NAME,
+      description: STRING.INIT.OPTIONS.ID.DESC,
+      eg: "exampleId"
+    },
+    defaultLanguage: {
+      value: "default_lang",
+      placeHolder: CONSTANTS.PLACEHOLDER.LANG,
+      description: STRING.INIT.OPTIONS.DEFAULTLANGUAGE.DESC,
+      eg: "de"
+    },
+    build: {
+      value: "build_number",
+      placeHolder: CONSTANTS.PLACEHOLDER.NUMBER,
+      description: STRING.INIT.OPTIONS.BUILD.DESC,
+      defaultValue: "0",
+      eg: "0"
+    },
+    useEloSession: {
+      value: "useEloSession",
+      placeHolder: CONSTANTS.PLACEHOLDER.YESNO,
+      description: STRING.INIT.OPTIONS.USEELOSESSION.DESC,
+      eg: "y"
+    },
+    devRedirect: {
+      value: "dev_redirect",
+      placeHolder: CONSTANTS.PLACEHOLDER.URL,
+      description: STRING.INIT.OPTIONS.DEVREDIRECT.DESC,
+      checkFirst: "useEloSession",
+      eg: "http://localhost:4200/"
+    }
+  }
+};
+commands.setup = {
+  desc: STRING.SETUP.DESC,
+  options: (function() {
+    let obj = {};
+    let copy;
+    const fromInit = ["repository", "indexHtml", "src", "dist", "namespace", "defaultLanguage"];
+    for (const init of fromInit) {
+      copy = Object.assign({}, getParameterInObject(commands.init.options, init));
+      if (copy === commands.init.options.repository) {
+        copy.ignore = true;
+      }
+      delete copy.defaultValue;
+      obj = setParameterInObject(obj, init, copy);
+    }
+    obj.serverUrl = {
+      value: "server_url",
+      placeholder: CONSTANTS.PLACEHOLDER.URL,
+      description: STRING.SETUP.OPTIONS.SERVERURL.DESC,
+      intoRoot: true,
+      eg: "http://myServer:9090/ix-Repository/"
+    };
+    obj.adminName = {
+      value: "admin_name",
+      placeholder: CONSTANTS.PLACEHOLDER.NAME,
+      description: STRING.SETUP.OPTIONS.ADMINNAME.DESC,
+      intoObj: "ixLogin"
+    };
+    obj.adminPw = {
+      value: "admin_pw",
+      placeholder: CONSTANTS.PLACEHOLDER.PW,
+      description: STRING.SETUP.OPTIONS.ADMINPW.DESC,
+      intoObj: "ixLogin",
+      encrypt: true
+    };
+    return obj;
+  })()
+};
+commands.newrepo = {
+  description: STRING.NEWREPO.DESC,
+  options: (function() {
+    let obj = {};
+    let copy;
+    const fromInit = ["repository"];
+    const fromSetup = ["serverUrl", "adminName", "adminPw"];
+    for (const init of fromInit) {
+      copy = Object.assign({}, getParameterInObject(commands.init.options, init));
+      if (copy === commands.init.options.repository) {
+        delete copy.ignore;
+      }
+      delete copy.defaultValue;
+      obj = setParameterInObject(obj, init, copy);
+    }
+    for (const setup of fromSetup) {
+      copy = Object.assign({}, getParameterInObject(commands.setup.options, setup));
+      delete copy.defaultValue;
+      obj = setParameterInObject(obj, setup, copy);
+    }
+    return obj;
+  })()
+};
+commands.deploy = {
+  description: STRING.DEPLOY.DESC,
+  placeHolder: CONSTANTS.PLACEHOLDER.PATH,
+  options: {
+    repository: {
+      ignore: true,
+      value: "repository",
+      placeHolder: CONSTANTS.PLACEHOLDER.NAME,
+      description: STRING.DEPLOY.OPTIONS.REPOSITORY.DESC,
+      eg: "myArchive"
+    },
+    key: {
+      value: "key",
+      placeHolder: CONSTANTS.PLACEHOLDER.NAME,
+      description: STRING.BUILD.OPTIONS.KEY.DESC,
+      eg: "any json key name"
+    },
+    value: {
+      value: "value",
+      placeHolder: CONSTANTS.PLACEHOLDER.NAME,
+      description: STRING.BUILD.OPTIONS.VALUE.DESC,
+      eg: "a string or number"
+    },
+    neon: {
+      value: "neon",
+      placeHolder: CONSTANTS.PLACEHOLDER.YESNO,
+      description: STRING.DEPLOY.OPTIONS.NEON.DESC
+    }
+  }
+};
+commands.import = {
+  description: STRING.IMPORT.DESC,
+  placeHolder: CONSTANTS.PLACEHOLDER.PATH,
+  options: {
+    repository: {
+      ignore: true,
+      value: "repository",
+      placeHolder: CONSTANTS.PLACEHOLDER.NAME,
+      description: STRING.DEPLOY.OPTIONS.REPOSITORY.DESC,
+      eg: "myArchive"
+    },
+    mode: {
+      value: "mode",
+      placeHolder: CONSTANTS.PLACEHOLDER.NAME,
+      description: STRING.IMPORT.OPTIONS.MODE.DESC
+    },
+    src: {
+      value: "src",
+      placeHolder: CONSTANTS.PLACEHOLDER.PATH,
+      description: STRING.IMPORT.OPTIONS.SRC.DESC
+    },
+    guid: {
+      value: "guid",
+      placeHolder: CONSTANTS.PLACEHOLDER.NAME,
+      description: STRING.IMPORT.OPTIONS.GUID.DESC
+    },
+    flowName: {
+      value: "flowName",
+      placeHolder: CONSTANTS.PLACEHOLDER.NAME,
+      description: STRING.IMPORT.OPTIONS.FLOWNAME.DESC
+    },
+    reloadScripts: {
+      value: "reloadScripts",
+      placeHolder: CONSTANTS.PLACEHOLDER.NAME,
+      description: STRING.IMPORT.OPTIONS.RELOADSCRIPTS.DESC
+    }
+  }
+};
+commands.export = {
+  description: STRING.EXPORT.DESC,
+  placeHolder: CONSTANTS.PLACEHOLDER.PATH,
+  options: {
+    repository: {
+      ignore: true,
+      value: "repository",
+      placeHolder: CONSTANTS.PLACEHOLDER.NAME,
+      description: STRING.DEPLOY.OPTIONS.REPOSITORY.DESC,
+      eg: "myArchive"
+    },
+    guid: {
+      value: "guid",
+      placeHolder: CONSTANTS.PLACEHOLDER.NAME,
+      description: STRING.EXPORT.OPTIONS.GUID.DESC
+    },
+    dist: {
+      value: "dist",
+      placeHolder: CONSTANTS.PLACEHOLDER.PATH,
+      description: STRING.EXPORT.OPTIONS.DIST.DESC
+    }
+  }
+};
+commands.localize = {
+  description: "Creates the language files for the web application.",
+  placeHolder: CONSTANTS.PLACEHOLDER.PATH,
+  options: {
+    src: {
+      value: "src",
+      placeHolder: CONSTANTS.PLACEHOLDER.PATH,
+      description: STRING.LOCALIZE.OPTIONS.SRC.DESC
+    },
+    dist: {
+      value: "dist",
+      placeHolder: CONSTANTS.PLACEHOLDER.PATH,
+      description: STRING.LOCALIZE.OPTIONS.DIST.DESC
+    }
+  }
+};
+class ConnectionManager {
+  constructor() {
+    this.initialized = false;
+  }
+  async init(settingsJson) {
+    try {
+      if (!this.initialized) {
+        if (settingsJson && settingsJson.ixUrl !== void 0) {
+          this.ixClient = new Client({
+            IX_URL: settingsJson.ixUrl,
+            WITH_CREDENTIALS: true,
+            USERNAME: settingsJson.ixLogin.adminName,
+            PASSWORD: decrypt(settingsJson.ixLogin.adminPw),
+            USE_SESSION: false,
+            XHR_TIMEOUT: 3e4,
+            CLIENT_INFO: {
+              language: "en",
+              timeZone: "UTC"
+            }
+          });
+        } else {
+          error(STRING.ERROR.IXCONNECTSKIP, false);
+          return;
+        }
+        await this.ixClient.connect();
+        axios.defaults.headers.common["ELO-Approved"] = this.ixClient.session.eloApproved;
+        axios.defaults.headers.common["Authorization"] = "Basic " + Buffer.from(
+          `${settingsJson.ixLogin.adminName}:${decrypt(settingsJson.ixLogin.adminPw)}`,
+          "utf8"
+        ).toString("base64");
+        this.initialized = true;
+      } else {
+        message(messageTypes.INFO, "Ix is already connected");
+      }
+    } catch (err) {
+      handleConnectionError(err, "Can't connect to IX: ");
+    }
+  }
+  async getixClient() {
+    return this.ixClient;
+  }
+}
+const connectionManager = new ConnectionManager();
+const jar = new CookieJar();
+const client = wrapper(axios.create({ jar }));
+const initConfig = commands.init;
+const setupConfig$1 = commands.setup;
+const JSON_SPACES = 4;
+const APPID_MAXLENGTH = 30;
+function isEmpty(value) {
+  if (value === void 0) {
+    return true;
+  } else {
+    return value === null || value === "" || Array.isArray(value) && value.length === 0;
+  }
+}
+async function getManifestData() {
+  const path2 = ensureSlash(process.cwd()) + CONSTANTS.MANIFESTFILE;
+  if (await exists(path2)) {
+    return await getJsonFile(path2, true);
+  } else {
+    error(STRING.ERROR.NOMANIFEST, false, path2);
+  }
+}
+async function getJsonFile(filePath, errorIfNotExist = false) {
+  if (await exists(filePath)) {
+    if (!filePath) return {};
+    try {
+      const filePathSync = await readFileFunction(filePath);
+      const json = JSON.parse(String(filePathSync));
+      return json;
+    } catch {
+      message(messageTypes.WARN, "Path is empty: ", filePath);
+      return {};
+    }
+  } else if (errorIfNotExist) {
+    error(STRING.ERROR.PATHNOTEXIST, false, filePath);
+  }
+}
+async function applyKeyValueOptionsToManifest(path2, options, mData) {
+  if (options.key !== void 0 && options.value === void 0) {
+    message(messageTypes.WARN, STRING.ERROR.NOVALUE);
+    return {};
+  }
+  if (options.value !== void 0 && options.key === void 0) {
+    message(messageTypes.WARN, STRING.ERROR.NOKEY);
+    return {};
+  }
+  if (options.key !== void 0 && options.value !== void 0) {
+    if (typeof options.key === "string" && options.key !== "") {
+      const distManifestPath = pathLib.join(path2, mData.dist, CONSTANTS.MANIFESTFILE);
+      const manifestDist = await exists(distManifestPath) ? await getJsonFile(distManifestPath, true) : {};
+      if (manifestDist.hasOwnProperty(options.key)) {
+        message(messageTypes.INFO, STRING.INFO.SETKEYVALUE, options.key);
+      }
+      manifestDist[options.key] = parseValue(options.value);
+      return manifestDist;
+    } else {
+      message(messageTypes.ERROR, `Key '${options.key}' has to be a string or is empty.`);
+    }
+  }
+  return {};
+}
+function parseValue(value) {
+  if (value === "undefined") return void 0;
+  if (value === "true") return true;
+  if (value === "false") return false;
+  const numberValue = Number(value);
+  if (!Number.isNaN(numberValue)) return numberValue;
+  return value;
+}
+async function validateManifestData(manifestData2, path2) {
+  const m = manifestData2;
+  let packagePath;
+  let packageJson2;
+  if (!m.name || m.version) {
+    packagePath = path2 + CONSTANTS.PACKAGEFILE;
+    packageJson2 = await getJsonFile(packagePath, true);
+    message(messageTypes.INFO, `Using packagePath: ${packagePath}`);
+    if (!m.name) {
+      m.name = packageJson2.name;
+    }
+    if (!m.version) {
+      m.version = packageJson2.version;
+    }
+  }
+  if (m.licenseMap === void 0) {
+    m.licenseMap = /* @__PURE__ */ new Map();
+  }
+  m.status = 101;
+  return m;
+}
+function validateOptionValue(options, optionConfig, optionVal, optionKey, manifestData2, settingsJson) {
+  const m = manifestData2;
+  if (options[optionConfig.value]) {
+    optionVal = options[optionConfig.value];
+  } else {
+    optionVal = isEmpty(getParameterInObject(m, optionKey)) ? getParameterInObject(settingsJson.manifest, optionKey) : getParameterInObject(m, optionKey);
+  }
+  return optionVal;
+}
+function setOptionValueIfEmptyAndPlaceholder(optionVal, optionConfig) {
+  if (isEmpty(optionVal) && optionConfig.defaultValue) {
+    optionVal = optionConfig.defaultValue;
+  }
+  return optionVal;
+}
+function setPlaceholder(optionConfig, optionVal) {
+  if (optionConfig.placeHolder === CONSTANTS.PLACEHOLDER.YESNO) {
+    optionVal = optionVal === true || optionVal === "y" || optionVal === "1" || optionVal === "true";
+  } else if (optionConfig.placeHolder === CONSTANTS.PLACEHOLDER.PATH && typeof optionVal === "string") {
+    optionVal = unixPathSep(optionVal);
+  }
+  return optionVal;
+}
+function replaceIdChars(id) {
+  try {
+    const length = id.length;
+    if (!length) {
+      message(messageTypes.WARN, STRING.WARN.NOID);
+    } else if (length > APPID_MAXLENGTH) {
+      message(messageTypes.WARN, STRING.WARN.IDLENMSG, length);
+    } else {
+      id = id.replace(/[^a-zA-Z0-9_]/g, "_");
+      message(messageTypes.INFO, STRING.INFO.CHARSREPLACED);
+      return id;
+    }
+  } catch {
+    message(messageTypes.WARN, '"id" is empty or undefined: ', id);
+    return;
+  }
+}
+async function pingEloWf(wfUrl) {
+  try {
+    const result = await axios.get(wfUrl, { timeout: 15e3 });
+    message(messageTypes.INFO, `${STRING.INFO.WFREQUESTSUCCESS}: ${wfUrl}`);
+    return result;
+  } catch (err) {
+    throw new Error(err.message);
+  }
+}
+async function createIXConnection(settingsJson) {
+  message(messageTypes.INFO, STRING.INFO.IXCONNECT);
+  await connectionManager.init(settingsJson);
+  return await connectionManager.getixClient();
+}
+async function createIXRestLogin(settingsJson) {
+  if (!validateSettingsObject(settingsJson)) {
+    error(new Error("Wrong Settings "), true, "The settings are not valid.");
+  }
+  try {
+    const result = await client.post(
+      `${settingsJson.ixUrl.substring(0, settingsJson.ixUrl.length - 3)}/rest/IXServicePortIF/login`,
+      {
+        ci: { ticket: "de.elo.ix.client.ticket_from_cookie" },
+        userName: settingsJson.ixLogin.adminName,
+        userPwd: decrypt(settingsJson.ixLogin.adminPw),
+        clientComputer: "elo-cli",
+        runAs: ""
+      },
+      {
+        withCredentials: true,
+        timeout: 1500
+      }
+    );
+    message(messageTypes.INFO, STRING.INFO.IXCONNSUCCESS);
+    return result.headers["elo-approved"];
+  } catch (err) {
+    throw new Error(err.message);
+  }
+}
+function writeCSSDevDataString(jsCode, name, rel, url) {
+  return jsCode += `const ${name} = document.createElement('link')
+        
+      ${name}.rel = '${rel}'
+      ${name}.type = 'text/css'
+      ${name}.href = elo.data.server.relativeAppUrl + '${url}'
+      ${name}.media = 'all'
+      document.getElementsByTagName('head')[0].appendChild(${name})`;
+}
+function insertScriptTag(cfg, window2) {
+  const tag = window2.document.createElement("script");
+  tag.setAttribute("elo", cfg.eloAttr);
+  tag.type = "text/javascript";
+  if (cfg.src) {
+    tag.src = cfg.src;
+  }
+  if (cfg.content) {
+    tag.innerHTML = cfg.content;
+  }
+  window2.document.body.insertBefore(tag, window2.document.body.firstChild);
+}
+function writeAppData(window2, manifestData2) {
+  insertScriptTag(
+    {
+      eloAttr: "appData",
+      content: `var elo = elo || {}
+        elo.data = elo.data || {}
+        elo.data.server = elo.data.server || {}
+        elo.data.server.appDefaultLanguage = "${manifestData2.defaultLanguage}"
+        elo.data.server.appSupportedLocales = ${JSON.stringify(manifestData2.supportedLocales)}
+        elo.data.server.appId = "${manifestData2.id}"
+        elo.data.server.appNamespace = "${manifestData2.namespace}"
+        elo.data.server.appVersion = "${manifestData2.version || ""}"
+        elo.data.server.appUseEloSession = ${manifestData2.useEloSession}
+        elo.appInfo = {
+            application: {
+                name: "${manifestData2.name}"
+            },
+            page: {
+                name: "${manifestData2.namespace}.${manifestData2.id}"
+        }}`
+    },
+    window2
+  );
+}
+function isVue2App(code) {
+  if (code === "") {
+    message(messageTypes.INFO, STRING.INFO.MAINJSEMPTY);
+    return false;
+  }
+  return code.includes("new Vue(");
+}
+function isVue3App(code) {
+  if (code === "") {
+    message(messageTypes.INFO, STRING.INFO.MAINJSEMPTY);
+    return false;
+  }
+  return code.includes("createApp(");
+}
+async function getMainScriptFile(path2, manifestData2) {
+  const mainPath = ensureSlash(path2) + ensureSlash(manifestData2.src);
+  if (await exists(mainPath + CONSTANTS.MAINJSFILE)) {
+    return mainPath + CONSTANTS.MAINJSFILE;
+  } else if (await exists(mainPath + CONSTANTS.MAINTSFILE)) {
+    return mainPath + CONSTANTS.MAINTSFILE;
+  }
+  return void 0;
+}
+function logConfigurationHints(configCreateInfo, configContentArray, mainScriptCreateInfo, mainScriptContentArray) {
+  message(messageTypes.INFO, configCreateInfo);
+  message(messageTypes.INFO, "---------------------------------------------------------");
+  configContentArray.forEach((str) => {
+    message(messageTypes.DEFAULT, str);
+  });
+  message(messageTypes.INFO, "---------------------------------------------------------");
+  message(messageTypes.INFO, mainScriptCreateInfo);
+  message(messageTypes.INFO, "---------------------------------------------------------");
+  mainScriptContentArray.forEach((str) => {
+    message(messageTypes.DEFAULT, str);
+  });
+  message(messageTypes.INFO, "---------------------------------------------------------");
+}
+async function outputHelpAndWriteFiles(indexHtmlPath, path2, manifestData2, window2) {
+  writeFileCB(
+    indexHtmlPath,
+    `<!DOCTYPE html>${window2.document.documentElement.outerHTML}`,
+    async (err) => {
+      if (err) {
+        error(err);
+      }
+      message(messageTypes.INFO, STRING.INFO.INITCOMPLETE);
+      const mainScriptPath = await getMainScriptFile(path2, manifestData2);
+      if (!mainScriptPath) {
+        error(STRING.ERROR.MAINJSNOTFOUND);
+        process.exit(0);
+      }
+      const mainScriptContent = await getFileContent(mainScriptPath);
+      const isVue2AppVar = isVue2App(mainScriptContent);
+      const isVue3AppVar = isVue3App(mainScriptContent);
+      if (isVue2AppVar) {
+        logConfigurationHints(
+          STRING.INFO.VUECONFJS,
+          STRING.CODE.VUECONFJSCODE,
+          STRING.INFO.MAINJS,
+          STRING.CODE.MAINJSCODE
+        );
+        process.exit(0);
+      } else if (isVue3AppVar) {
+        logConfigurationHints(
+          STRING.INFO.VITECONFTS,
+          STRING.CODE.VITECONFTSCODE,
+          STRING.INFO.MAINTS,
+          STRING.CODE.MAINTSCODE
+        );
+        process.exit(0);
+      } else {
+        message(messageTypes.INFO, STRING.INFO.NOVUEAPP);
+        process.exit(0);
+      }
+    }
+  );
+}
+async function ixRestLogout(settingsJson, approvedToken) {
+  if (!validateSettingsObject(settingsJson)) {
+    error(new Error("Wrong Settings"), true, "The settings are not valid.");
+  }
+  try {
+    const result = await client.post(
+      `${settingsJson.ixUrl.substring(0, settingsJson.ixUrl.length - 3)}/rest/IXServicePortIF/logout`,
+      { ci: { ticket: "de.elo.ix.client.ticket_from_cookie" } },
+      {
+        withCredentials: true,
+        timeout: 15e3,
+        headers: {
+          "ELO-Approved": approvedToken,
+          Authorization: "Basic " + Buffer.from(
+            `${settingsJson.ixLogin.adminName}:${decrypt(settingsJson.ixLogin.adminPw)}`,
+            "utf8"
+          ).toString("base64")
+        }
+      }
+    );
+    message(messageTypes.INFO, "Logging out has been successful");
+    return result;
+  } catch (err) {
+    throw new Error(err.message);
+  }
+}
+function validateSettingsObject(settingsJson) {
+  if (!settingsJson.ixUrl) {
+    error(STRING.ERROR.WFREFRESHSKIP, true, "ixUrl");
+    return false;
+  } else if (!settingsJson.ixLogin.adminName) {
+    error(STRING.ERROR.WFREFRESHSKIP, true, setupConfig$1.options.adminName.value);
+    return false;
+  } else if (!settingsJson.ixLogin.adminPw) {
+    error(STRING.ERROR.WFREFRESHSKIP, true, setupConfig$1.options.adminPw.value);
+    return false;
+  } else {
+    message(messageTypes.INFO, STRING.INFO.IXCONNECT);
+    message(messageTypes.INFO, settingsJson.ixUrl);
+    return true;
+  }
+}
+async function initNodeJsOnEloWf(settingsJson, manifest) {
+  const wfUrl = settingsJson.manifest.wfUrl || manifest.wfUrl;
+  const approvedToken = await createIXRestLogin(settingsJson);
+  const url = `${ensureSlash(wfUrl)}apps/rest/cmd/app/initnodejs/`;
+  message(messageTypes.INFO, STRING.INFO.WFREFRESH, url);
+  try {
+    const res = await client.post(url, manifest, {
+      withCredentials: true,
+      timeout: 15e3,
+      headers: {
+        "ELO-Approved": approvedToken
+      }
+    });
+    message(messageTypes.INFO, STRING.INFO.WFREFRESHCOMPLETED);
+    await ixRestLogout(settingsJson, approvedToken);
+    return res.data;
+  } catch (err) {
+    throw new Error(err.message);
+  }
+}
+async function propertiesToObject(src) {
+  let res = {};
+  try {
+    const rl = readline.createInterface({
+      input: createReadStreamSync(src),
+      crlfDelay: Infinity
+    });
+    for await (const line of rl) {
+      if (line && line.indexOf("#") !== 0) {
+        const lineSplit = line.split("=");
+        const key = lineSplit[0].trim();
+        const value = lineSplit[1].trim();
+        if (key && value) {
+          res = setParameterInObject(res, key, value);
+        }
+      }
+    }
+    return res;
+  } catch (err) {
+    throw new Error(err.message);
+  }
+}
+async function writeSettingsJson(archiveName, path2, settings2) {
+  if (archiveName !== void 0) {
+    const repoFolder = "/.elo-repository";
+    const confPath = `${path2}${ensureSlash(repoFolder)}`;
+    if (!await exists(confPath)) {
+      mkdir(confPath, true);
+      message(messageTypes.INFO, STRING.INFO.PATHCREATED, `.${ensureSlash(repoFolder)}`);
+    }
+    const archivePath = `${confPath}${archiveName}.json`;
+    await writeFile(archivePath, JSON.stringify(settings2, null, JSON_SPACES));
+    message(messageTypes.INFO, STRING.INFO.REPOCONFSAVE, `in .${repoFolder}/${archiveName}.json.`);
+  } else {
+    await writeFile(globalSettingsPath, JSON.stringify(settings2, null, JSON_SPACES));
+  }
+}
+async function build(path2, manifestData2, manifestPath, distManifestData) {
+  try {
+    if (!manifestData2.dist || !await exists(pathLib.join(path2, manifestData2.dist))) {
+      error(STRING.ERROR.OPTIONNOTVALID, false, initConfig.options.dist.value);
+    }
+    if (!manifestData2.defaultLanguage) {
+      error(STRING.ERROR.OPTIONNOTVALID, false, initConfig.options.defaultLanguage.value);
+    }
+    manifestData2.supportedLocales = manifestData2.supportedLocales || [
+      manifestData2.defaultLanguage
+    ];
+    manifestData2.build++;
+    message(messageTypes.INFO, STRING.INFO.SETTINGSBUILD, manifestData2.build);
+    await writeFile(manifestPath, JSON.stringify(manifestData2, null, JSON_SPACES));
+    message(messageTypes.INFO, STRING.INFO.COPYFILES);
+    const indexHtmlPath = pathLib.join(
+      ensureSlash(path2),
+      ensureSlash(manifestData2.dist),
+      manifestData2.indexHtml
+    );
+    message(messageTypes.INFO, `Check dist index file: ${indexHtmlPath}`);
+    const distManifestPath = pathLib.join(
+      ensureSlash(path2),
+      ensureSlash(manifestData2.dist),
+      CONSTANTS.MANIFESTFILE
+    );
+    message(messageTypes.INFO, `Write updated manifest to: ${distManifestPath}`);
+    delete manifestData2.devRedirect;
+    const manifestDataCopy = Object.assign(
+      {},
+      manifestData2,
+      typeof distManifestData === "string" ? JSON.parse(distManifestData) : distManifestData
+    );
+    await writeFile(distManifestPath, JSON.stringify(manifestDataCopy, null, JSON_SPACES));
+    message(messageTypes.INFO, `Manifest copied to dist file: ${distManifestPath}`);
+    const distDevData = `${ensureSlash(path2) + ensureSlash(manifestData2.dist)}devData.js`;
+    message(messageTypes.INFO, `Delete devData.js in dist: ${distDevData}`);
+    await removeFile(distDevData);
+    if (!await exists(indexHtmlPath)) {
+      error(STRING.ERROR.NOSETTINGSPATH, false, indexHtmlPath);
+    }
+    readFileCB(indexHtmlPath, (err, data) => {
+      if (err) {
+        error(err);
+      }
+      const { window: window2 } = new JSDOM(data, {});
+      const baseTagList = window2.document.head.getElementsByTagName("base");
+      let baseTag;
+      const scriptServerData = window2.document.body.querySelector("script[elo=serverData]");
+      const scriptConfigData = window2.document.body.querySelector("script[elo=configData]");
+      const scriptDevData = window2.document.body.querySelector("script[elo=devData]");
+      const scriptAppData = window2.document.body.querySelector("script[elo=appData]");
+      if (baseTagList.length) {
+        baseTag = baseTagList[0];
+        baseTag.href = "${baseHref}";
+      }
+      if (scriptServerData) {
+        scriptServerData.remove();
+      }
+      if (scriptConfigData) {
+        scriptConfigData.remove();
+      }
+      if (scriptDevData) {
+        scriptDevData.remove();
+      }
+      if (scriptAppData) {
+        scriptAppData.remove();
+      }
+      overwriteCssTag(window2, "favIcon", "icon", true, "../../resources/images/elo-favicon.ico");
+      overwriteCssTag(
+        window2,
+        "fontCss",
+        "stylesheet",
+        true,
+        "../../mapping/modules/elo.module.font.01/resources/css/elo-sans-pro.css"
+      );
+      overwriteCssTag(
+        window2,
+        "levelIconsCss",
+        "stylesheet",
+        manifestData2.sordTypeIcons,
+        "../../mapping/modules/elo.module.icons/resources/levels/levels-200.css"
+      );
+      overwriteCssTag(
+        window2,
+        "archiveIconsCss",
+        "stylesheet",
+        manifestData2.archiveIcons,
+        "../../mapping/modules/elo.module.icons/resources/archiveicons/archiveicons-200.css"
+      );
+      insertScriptTag(
+        {
+          eloAttr: "configData",
+          src: `../../pages/appConfig.jsp?id=${manifestData2.id}&namespace=${manifestData2.namespace}`
+        },
+        window2
+      );
+      insertScriptTag(
+        {
+          eloAttr: "serverData",
+          src: "../../pages/serverData.jsp"
+        },
+        window2
+      );
+      writeAppData(window2, manifestData2);
+      writeFileCB(
+        indexHtmlPath,
+        `<!DOCTYPE html>${window2.document.documentElement.outerHTML}`,
+        (err2) => {
+          if (err2) {
+            error(err2);
+          }
+          message(messageTypes.INFO, STRING.INFO.BUILDCOMPLETED);
+        }
+      );
+    });
+  } catch (err) {
+    throw new Error(err.message);
+  }
+}
+function overwriteCssTag(window2, name, rel, overwrite, url) {
+  const cssEl = window2.document.head.querySelector(`link[elo=${name}]`);
+  if (cssEl) {
+    cssEl.remove();
+  }
+  if (overwrite) {
+    insertLinkTag(
+      {
+        relAttr: rel,
+        eloAttr: name,
+        href: url
+      },
+      window2
+    );
+  }
+}
+function insertLinkTag(cfg, window2) {
+  const tag = window2.document.createElement("link");
+  tag.setAttribute("rel", cfg.relAttr);
+  tag.setAttribute("elo", cfg.eloAttr);
+  tag.type = "text/css";
+  if (cfg.href) {
+    tag.href = cfg.href;
+  }
+  window2.document.head.insertBefore(tag, window2.document.head.firstChild);
+}
+async function zipFilesInFolder(srcFolder, targetFolder, targetFile) {
+  message(messageTypes.INFO, `Start zip folder ${srcFolder} to ${targetFile} as ${targetFile}`);
+  await removeFile(ensureSlash(targetFolder));
+  mkdir(ensureSlash(targetFolder), false);
+  const output = createWriteStreamSync(ensureSlash(targetFolder) + targetFile);
+  const archive = archiver("zip", { zlib: { level: 9 } });
+  output.on("close", () => {
+    message(messageTypes.INFO, `${archive.pointer()} total bytes`);
+    message(
+      messageTypes.INFO,
+      "archiver has been finalized and the output file descriptor has closed."
+    );
+  });
+  archive.on("warning", (err) => {
+    if (err.code === "ENOENT") {
+      error(err);
+    } else {
+      throw err;
+    }
+  });
+  archive.on("error", (err) => {
+    throw err;
+  });
+  archive.pipe(output);
+  archive.directory(srcFolder, false);
+  await archive.finalize();
+}
+async function deployNodeJsOnEloWf(settingsJson, manifest, projectPath) {
+  if (!manifest.wfUrl && !settingsJson.manifest?.wfUrl) {
+    error("No wfUrl defined in manifest", false);
+  }
+  const wfUrl = manifest.wfUrl || settingsJson.manifest.wfUrl;
+  const zipPath = `${ensureSlash(projectPath)}zip/`;
+  const distPath = ensureSlash(projectPath) + manifest.dist;
+  try {
+    await zipFilesInFolder(distPath, zipPath, "app.zip");
+    await pingEloWf(wfUrl);
+    const approvedToken = await createIXRestLogin(settingsJson);
+    const url = `${ensureSlash(wfUrl)}apps/rest/cmd/app/deploynodejs/`;
+    message(messageTypes.INFO, STRING.INFO.WFREFRESH, url);
+    const stream = createReadStreamSync(`${ensureSlash(zipPath)}app.zip`);
+    const res = await client.post(url, stream, {
+      withCredentials: true,
+      timeout: 6e4,
+      params: {
+        namespace: manifest.namespace,
+        id: manifest.id,
+        ticket: "de.elo.ix.client.ticket_from_cookie"
+      },
+      headers: {
+        "Content-Type": "application/zip",
+        "ELO-Approved": approvedToken
+      }
+    });
+    message(messageTypes.INFO, STRING.INFO.WFREFRESHCOMPLETED);
+    await removeFile(zipPath);
+    await ixRestLogout(settingsJson, approvedToken);
+    return res;
+  } catch (err) {
+    await removeFile(zipPath);
+    throw new Error(err);
+  }
+}
+async function deployNodeJsOnNeon(settingsJson, manifest, projectPath) {
+  const ixUrl = settingsJson.ixUrl.endsWith("/ix") ? settingsJson.ixUrl.substring(0, settingsJson.ixUrl.length - 3) : settingsJson.ixUrl;
+  const zipPath = `${ensureSlash(projectPath)}zip/`;
+  const distPath = ensureSlash(projectPath) + manifest.dist;
+  const approvedToken = await createIXRestLogin(settingsJson);
+  try {
+    await zipFilesInFolder(`${ensureSlash(distPath)}assets/`, zipPath, "app.zip");
+    await pingEloWf(settingsJson.manifest.wfUrl);
+    const url = `${ensureSlash(ixUrl)}plugin/de.elo.ix.plugin.rest/neon/extensions/`;
+    message(messageTypes.INFO, STRING.INFO.NEONDEPLOY, url);
+    const stream = createReadStreamSync(`${zipPath}app.zip`);
+    const res = await client.post(url, stream, {
+      timeout: 6e4,
+      params: { ticket: "de.elo.ix.client.ticket_from_cookie" },
+      headers: {
+        "Content-Type": "application/octet-stream",
+        "ELO-Approved": approvedToken
+      }
+    });
+    await removeFile(ensureSlash(zipPath));
+    await ixRestLogout(settingsJson, approvedToken);
+    return res;
+  } catch (err) {
+    await removeFile(ensureSlash(zipPath));
+    await ixRestLogout(settingsJson, approvedToken);
+    throw new Error(err.message);
+  }
+}
+async function updateManifestData(manifestData2) {
+  const manifestPath = pathLib.resolve(ensureSlash(process.cwd()) + CONSTANTS.MANIFESTFILE);
+  await removeFile(manifestPath);
+  await writeFile(manifestPath, JSON.stringify(manifestData2, null, JSON_SPACES));
+}
+function mapToObj(map) {
+  if (map instanceof Map) {
+    const obj = {};
+    for (const [key, value] of map) {
+      obj[key] = mapToObj(value);
+    }
+    return obj;
+  }
+  return map;
+}
+async function delay(seconds) {
+  if (Number.isFinite(seconds) && seconds > 0) {
+    message(messageTypes.INFO, `Waiting for ${seconds} seconds before continue...`);
+    await new Promise((resolve) => setTimeout(resolve, seconds * 1e3));
+  } else {
+    message(messageTypes.WARN, `Invalid delay value: ${seconds}. Skipping delay.`);
+  }
+}
+const buildCommand = new Command("build").description("Build a App").option(
+  "--k, --key <string>",
+  "Sets the value of the key value pair, defined by --key, for example: a string or number"
+).option(
+  "--v, --value <string>",
+  "Sets the value for the arbitrary json key, for example: any json value"
+).action(async (options, path) => {
+  path = ensureSlash(pathLib.resolve(unixPathSep(process.cwd())));
+  const manifesData = await getManifestData();
+  const mDist = await applyKeyValueOptionsToManifest(path, options, manifesData);
+  await build(path, manifesData, path + CONSTANTS.MANIFESTFILE, mDist);
+});
+let settings;
+class TestHelpers {
+  constructor(options) {
+    this.initialized = options?.initialized ?? false;
+    this.user = options?.user ?? "";
+    this.pw = options?.pw ? { content: options.pw.content, iv: options.pw.iv } : { content: "", iv: "" };
+    this.eloWfUrl = options?.eloWfUrl ?? "";
+    this.ixUrl = options?.ixUrl ?? "";
+    this.ixContext = options?.ixContext ?? "";
+    this.ixServer = options?.ixServer ?? "";
+    if (typeof window !== "undefined") {
+      window.elo = Object.assign({}, window.elo, { data: { server: {} } });
+    }
+  }
+  /**
+   * Initializes the test helper by reading the settings.json file.
+   * This method used synchronous file reading.
+   * @param repoName Optional repository name to read settings from.
+   * @returns The settings data.
+   */
+  init(repoName) {
+    settings = getSettingsJsonSync(repoName);
+    return this.innerInit(settings);
+  }
+  /**
+   * Initializes the test helper by reading the settings.json file.
+   * This method uses asynchronous file reading.
+   * @param repoName Optional repository name to read settings from.
+   * @returns A promise that resolves to the settings data.
+   */
+  async asyncInit(repoName) {
+    settings = await getSettingsJson(repoName);
+    return this.innerInit(settings);
+  }
+  /**
+   * Extract the settings data and compute the urls.
+   * @param settings The settings data.
+   * @private
+   * @returns The settings data.
+   */
+  innerInit(settings2) {
+    if (!settings2) error("No settings available", false);
+    try {
+      this.eloWfUrl = settings2.manifest.wfUrl;
+      this.ixUrl = settings2.ixUrl;
+      this.user = settings2.ixLogin.adminName;
+      this.pw = {
+        content: settings2.ixLogin.adminPw.content,
+        iv: settings2.ixLogin.adminPw.iv,
+        // NEON-388: Be compatible for old settings.json structure
+        alg: settings2.ixLogin.adminPw.alg,
+        value: settings2.ixLogin.adminPw.value
+      };
+      const url = new URL(this.ixUrl);
+      const parts = url.pathname.split("/").filter(Boolean);
+      this.ixContext = `/${parts[0]}`;
+      this.ixServer = `${url.protocol}//${url.hostname}${url.port ? ":" + url.port : ""}`;
+      this.initialized = true;
+      message(messageTypes.INFO, "TestHelper initialized");
+      return settings2;
+    } catch (e) {
+      message(messageTypes.ERROR, "Error reading settings");
+      error(e, true);
+    }
+  }
+  /**
+   * Sets the default language.
+   *
+   * @param language default language
+   */
+  initLang(language) {
+    if (typeof window !== "undefined") {
+      window.elo = Object.assign({}, window.elo, { data: { server: {} } });
+      window.elo.data.server.language = language || settings.manifest.defaultLanguage || "de";
+    }
+  }
+  /**
+   * EVLIB-1138: returns the user after class variables are initialized
+   * with "init()" or "asyncInit()"
+   * @returns user
+   */
+  getUser() {
+    if (!this.initialized) {
+      message(messageTypes.ERROR, "testHelper not initialized!");
+      return "";
+    }
+    return this.user;
+  }
+  /**
+   * EVLIB-1138: returns the pw after class variables are initialized
+   * with "init()" or "asyncInit()"
+   * @returns password
+   */
+  getPw() {
+    if (!this.initialized) {
+      message(messageTypes.ERROR, "testHelper not initialized!");
+      return "";
+    }
+    return decrypt(this.pw);
+  }
+  /**
+   * Returns the indexserver url (ixUrl) after class variables are initialized
+   * with "init()" or "asyncInit()"
+   * @returns url
+   */
+  getIxUrl() {
+    if (!this.initialized) {
+      message(messageTypes.ERROR, "testHelper not initialized!");
+      return "";
+    }
+    return this.ixUrl;
+  }
+  /**
+   * Returns the ixContext after class variables are initialized
+   * with "init()" or "asyncInit()"
+   * @returns ixContext
+   */
+  getIxContext() {
+    if (!this.initialized) {
+      message(messageTypes.ERROR, "testHelper not initialized!");
+      return "";
+    }
+    return this.ixContext;
+  }
+  /**
+   * Returns the ixServer after class variables are initialized
+   * with "init()" or "asyncInit()"
+   * @returns ixServer
+   */
+  getIxServer() {
+    if (!this.initialized) {
+      message(messageTypes.ERROR, "testHelper not initialized!");
+      return "";
+    }
+    return this.ixServer;
+  }
+  /**
+   * Returns the eloWfUrl after class variables are initialized
+   * with "init()" or "asyncInit()"
+   * @returns url
+   */
+  getWfUrl() {
+    if (!this.initialized) {
+      message(messageTypes.ERROR, "testHelper not initialized!");
+      return "";
+    }
+    return this.eloWfUrl;
+  }
+}
+const testHelper = new TestHelpers();
+const deployCommand = new Command("deploy").description("Deploy a App into wf").option("--r, --repository <string>", "Use a specific local repository (for projects)").option(
+  "--n, --neon",
+  "To deploy a Neon extension the client plugin, instead of an ELO App to the ELOwf."
+).option(
+  "--k, --key <string>",
+  "Sets the value of the key value pair, defined by --key, for example: a string or number"
+).option(
+  "--v, --value <string>",
+  "Sets the value for the arbitrary json key, for example: any json value"
+).action(async (options, path) => {
+  path = ensureSlash(pathLib.resolve(unixPathSep(process.cwd())));
+  let archiveName;
+  if (options.repository) {
+    archiveName = options.repository;
+    message(messageTypes.INFO, `Using archive parameter ${archiveName}`);
+  }
+  const settingsJson = await testHelper.asyncInit(archiveName);
+  const manifest = await getManifestData();
+  const isNeonDeploy = options.neon;
+  try {
+    if (!isNeonDeploy) {
+      const wfUrl = settingsJson.manifest.wfUrl;
+      if (!wfUrl) {
+        error(STRING.ERROR.OPTIONNOTVALID, false, "wfUrl");
+      }
+      const mDist = await applyKeyValueOptionsToManifest(path, options, manifest);
+      await build(path, manifest, path + CONSTANTS.MANIFESTFILE, mDist);
+      await deployNodeJsOnEloWf(settingsJson, manifest, path);
+      message(messageTypes.INFO, STRING.INFO.DEPLOYCOMPLETED);
+    } else {
+      await deployNodeJsOnNeon(settingsJson, manifest, path);
+      message(messageTypes.INFO, STRING.INFO.DEPLOYCOMPLETED);
+    }
+  } catch (err) {
+    handleConnectionError(err, STRING.ERROR.WFREQUEST);
+  }
+});
+const exportConfig = commands.export;
+const exportCommand = new Command("export").description("Export a package or archive area from the ELO repository").option(
+  "--r, --repository <string>",
+  "Repository containing json config file, for example: myArchive"
+).option(
+  "--g, --guid <string>",
+  "The guid of the entry or the name/guid of the package to export."
+).option("--d, --dist <string>", "The file of the export data.").action(async (options, path) => {
+  path = ensureSlash(pathLib.resolve(unixPathSep(process.cwd())));
+  const guid = getParameterInObject(options, exportConfig.options.guid.value);
+  const distOption = getParameterInObject(options, exportConfig.options.dist.value);
+  const dist = ensureSlash(path) + distOption;
+  let archiveName = "";
+  if (options.repository) {
+    archiveName = options.repository;
+    message(messageTypes.INFO, `Using archive parameter ${archiveName}`);
+  }
+  try {
+    const settingsJson = await testHelper.asyncInit(archiveName);
+    message(messageTypes.INFO, `export package from ${guid} to file ${dist}.`);
+    const ixConnection = await createIXConnection(settingsJson);
+    const packageInfo = (await ixConnection.packageService.eServiceCheckoutPackages({
+      checkoutInfo: {
+        nameOrGuids: [guid]
+      },
+      packageZ: PackageC.mbAll,
+      lockZ: LockC.NO
+    })).result;
+    if (packageInfo.packageDataList === void 0) {
+      error(STRING.ERROR.PACKAGENOTFOUND, false, guid);
+    }
+    const startExportResult = (await ixConnection.fioService.serviceStartExport({
+      options: {
+        compressionLevel: 1,
+        packageGuids: [packageInfo.packageDataList[0].guid]
+      }
+    })).result;
+    const downloadUrl = new URL(
+      ensureSlash(settingsJson.ixUrl.replace(/\/ix$/, "")) + "byps?" + String(startExportResult.downloadStream.url).replace("getstream?", "") + "&a=a"
+    );
+    const response = await axios.get(downloadUrl.toString(), { responseType: "stream" });
+    await pipeline(response.data, createWriteStreamSync(dist));
+    message(messageTypes.INFO, `Exported package to file ${dist}.`);
+    await ixConnection.fioService.serviceFinishExport({
+      options: {
+        jobState: startExportResult.jobState
+      }
+    });
+    message(messageTypes.INFO, STRING.INFO.EXPORTCOMPLETE);
+  } catch (err) {
+    handleConnectionError(err, STRING.ERROR.EXPORT);
+  }
+});
+const importConfig = commands.import;
+const importArchiveZip = async (con, src, guid, guidFlag = 1) => {
+  message(messageTypes.INFO, `importArchiveZip:${guid}`);
+  try {
+    const importId = (await con.ix.startImport({
+      filingPath: guid,
+      guidMethod: guidFlag
+    })).result;
+    message(messageTypes.INFO, `importId:${importId}`);
+    const uploadUrl = (await con.ix.getImportZipUrl({
+      importId
+    })).result;
+    message(messageTypes.INFO, `uploadUrl:${uploadUrl}`);
+    const stream = createReadStreamSync(src);
+    await axios.post(uploadUrl, stream, { timeout: 6e4 });
+    message(messageTypes.INFO, STRING.INFO.IMPORTCOMPLETE);
+  } catch (err) {
+    handleConnectionError(err, STRING.ERROR.IMPORT);
+  }
+};
+const importWorkflow = async (con, src, flowName, guid) => {
+  try {
+    const data = readFileBase64(src);
+    await con.ix.importWorkFlow2({
+      flowName,
+      fileData: data,
+      importOptions: {
+        replaceMissingUserByUserId: guid
+      }
+    });
+    message(messageTypes.INFO, STRING.INFO.IMPORTCOMPLETE);
+  } catch (err) {
+    handleConnectionError(err, STRING.ERROR.IXCONN);
+  }
+};
+const importEntry = async (con, src, guid) => {
+  try {
+    const constants = (await con.ix.getConstants()).result;
+    const editInfo = (await con.ix.createDoc({
+      parentId: guid,
+      maskId: constants.DOC_MASK.GUID_BASIC,
+      editInfoZ: { sordZ: constants.EDIT_INFO.mbAll }
+    })).result;
+    const name = pathLib.basename(src);
+    const ext = name.substring(name.lastIndexOf(".") + 1);
+    const data = createReadStreamSync(src);
+    const doc = {
+      docs: [
+        {
+          ext,
+          version: "1",
+          comment: "neon-cli import"
+        }
+      ]
+    };
+    const beginDoc = (await con.ix.checkinDocBegin({
+      document: doc
+    })).result;
+    const uploadUrl = beginDoc.docs[0].url;
+    const uploadResult = await axios.post(uploadUrl, data, {
+      headers: {
+        "content-type": "application/elodm-" + ext
+      }
+    });
+    doc.docs = beginDoc.docs;
+    doc.docs[0].uploadResult = uploadResult.data;
+    editInfo.sord.name = pathLib.basename(src, pathLib.extname(src));
+    editInfo.sord.docVersion = doc.docs[0];
+    await con.ix.checkinDocEnd({
+      document: doc,
+      sord: editInfo.sord,
+      sordZ: constants.SORD.mbAll
+    });
+    message(messageTypes.INFO, STRING.INFO.IMPORTCOMPLETE);
+  } catch (err) {
+    handleConnectionError(err, STRING.ERROR.IMPORT);
+  }
+};
+const importPackage = async (con, src) => {
+  try {
+    const data = readFileSyncFunction(src);
+    const name = pathLib.basename(src);
+    const file = new File([data], name);
+    const uploadResponse = await axios.post(
+      `${con.session.config.IX_URL}/rest/BUtility/upload`,
+      file
+    );
+    const uploadResult = uploadResponse.data.result;
+    const importOptions = {
+      conflictHandling: ConflictHandlingE.TSTAMP,
+      uploadStream: {
+        streamId: uploadResult.streamId,
+        url: uploadResult.url
+      },
+      packagesImported: true
+    };
+    await con.fioService.serviceStartImport({
+      options: importOptions
+    });
+    message(messageTypes.INFO, STRING.INFO.IMPORTCOMPLETE);
+  } catch (err) {
+    handleConnectionError(err, STRING.ERROR.IMPORT);
+  }
+};
+const importCommand = new Command("import").description("Import some data").option("--r, --repository <string>", "Read the local repository (for projects)").option("--m, --mode <string>", "The selected import mode: archiv, workflow or entry").option("--s, --src <string>", "The path to the file to be exported").option("--f, --flowName <string>", "Name of the workflow template").option("--guid <string>", "Guid of the entry").option("--guidMode <number>", "Selects the guide mode (Default: 1)", parseInt, 1).option("--reloadScripts <string>", "Reloads the scripts after the import.").action(async (options, path) => {
+  path = ensureSlash(pathLib.resolve(unixPathSep(process.cwd())));
+  const guid = getParameterInObject(options, importConfig.options.guid.value) ?? "0";
+  const src = path + options[importConfig.options.src.value];
+  let archiveName = await getRepositoryName(options.repository);
+  let con;
+  const settingsJson = archiveName !== "ELO_GLOBAL" ? await getLocalSettingsJson(archiveName, true) : await getGlobalSettingsJson();
+  try {
+    const connection = await createIXConnection(settingsJson);
+    if (!connection) {
+      throw new Error("Failed to create IX connection.");
+    }
+    con = connection;
+  } catch (err) {
+    handleConnectionError(err, STRING.ERROR.IXCONN);
+  }
+  let mode = options.mode;
+  let flowName = options.flowName;
+  if (mode !== "archive" && mode !== "workflow" && mode !== "entry") {
+    mode = "package";
+  }
+  if (!flowName && mode === "workflow") {
+    flowName = pathLib.basename(src, pathLib.extname(src));
+  }
+  if (options.repository) {
+    archiveName = options.repository;
+    message(messageTypes.INFO, `Using archive parameter ${archiveName}`);
+  }
+  if (options.reloadScripts) {
+    message(messageTypes.INFO, "import trigger reloadScripts");
+    const reloadScriptsResult = await con.ix.reloadScripts();
+    if (!reloadScriptsResult.exception) {
+      message(messageTypes.INFO, STRING.INFO.RELOADCOMPLETE);
+    }
+  } else if (mode === "archive") {
+    message(messageTypes.INFO, `import archive from file ${src} to ${guid}.`);
+    await importArchiveZip(con, src, guid, options.guidMode ?? 1);
+  } else if (mode === "workflow") {
+    message(
+      messageTypes.INFO,
+      `import workflow from file ${src} to ${flowName}, replace unknown user with ${guid}.`
+    );
+    await importWorkflow(con, src, flowName, guid);
+  } else if (mode === "entry") {
+    message(messageTypes.INFO, `import entry from file ${src} to ${guid}.`);
+    await importEntry(con, src, guid);
+  } else {
+    message(messageTypes.INFO, `import package from file ${src}.`);
+    await importPackage(con, src);
+  }
+});
+const initCommand = new Command("init").description("Init the project").option("--r, --repository <string>", "Read the local repository (for projects)").option(
+  "--index_html <string>",
+  "The name of the index.html, for example: index.html (default: index.html)"
+).option(
+  "--use_SordType_Icons <y/n>",
+  'Are "ELO Sordtype Icons" required for this project? For example: y'
+).option(
+  "--use_Archive_Icons <y/n>",
+  'Are "Archive Icons" required for this project? For example: y'
+).option(
+  "--src <string>",
+  "The relative path where the source files, like the index.html, are, for example: src/"
+).option(
+  "--dist <string>",
+  "The relative path where the output files, like the index.html, will be, for example: dist/"
+).option(
+  "--indexHtmlPath <string>",
+  "The relative path where the index.html file is located, for example in Vue2: public/ for Vue3 it is ."
+).option("--namespace <string>", "The app namespace, for example: my.example.namespace").option("--id <string>", "The app id, for example: exampleId").option("--default_lang <string>", "The default language, for example: de").option("--build_number <number>", "The build number of the app, for example: 0").option("--use_elo_session <y/n>", "Enable, to use elo session, for example: y").option(
+  "--dev_redirect <string>",
+  "Dev url of the app, which the login site of the ELOwf will redirect after successfull login. Necessary if elo session is enabled, for example: http://localhost:4200/"
+).action(async (options, path) => {
+  message(messageTypes.INFO, STRING.INIT.START);
+  path = ensureSlash(pathLib.resolve(unixPathSep(process.cwd())));
+  const manifestPath = path + CONSTANTS.MANIFESTFILE;
+  let manifestData2 = await getJsonFile(manifestPath) || {};
+  let optionKey;
+  let optionVal;
+  let optionConfig;
+  let defaultVal;
+  const currentRepoPath = pathLib.resolve(".elo-current-repository");
+  const initConfig2 = commands.init;
+  const archiveName = await getRepositoryName(options.repository);
+  try {
+    await writeFile(currentRepoPath, archiveName.trim());
+  } catch (e) {
+    error(e);
+  }
+  const settingsJson = await testHelper.asyncInit(archiveName) || void 0;
+  if (settingsJson === void 0) error(STRING.ERROR.NOSETTINGSFOUND, false);
+  manifestData2 = await validateManifestData(manifestData2, path);
+  try {
+    for (optionKey in initConfig2.options) {
+      const option = getParameterInObject(initConfig2.options, optionKey);
+      if (initConfig2.options.hasOwnProperty(optionKey)) {
+        if (option.ignore) {
+          continue;
+        }
+        optionConfig = option;
+        optionVal = validateOptionValue(
+          options,
+          optionConfig,
+          optionVal,
+          optionKey,
+          manifestData2,
+          settingsJson
+        );
+        message(messageTypes.INFO, `Using - ${optionConfig.value} = ${optionVal}`);
+        while (isEmpty(optionVal)) {
+          if (optionConfig.checkFirst && manifestData2[optionConfig.checkFirst] !== true) {
+            break;
+          }
+          defaultVal = "";
+          message(messageTypes.DEFAULT, optionConfig.description, optionConfig.eg);
+          if (optionConfig.defaultValue) {
+            defaultVal = `(${optionConfig.defaultValue}) `;
+          }
+          const tmp = await prompts({
+            type: "text",
+            name: "value",
+            message: `${optionConfig.value} ${defaultVal}`
+          });
+          optionVal = tmp.value;
+          optionVal = setOptionValueIfEmptyAndPlaceholder(optionVal, optionConfig);
+        }
+        optionVal = setPlaceholder(optionConfig, optionVal);
+        manifestData2 = setParameterInObject(manifestData2, optionKey, optionVal);
+      }
+    }
+  } catch (err) {
+    error(err, false);
+  }
+  manifestData2.id = replaceIdChars(manifestData2.id);
+  manifestData2.supportedLocales = manifestData2.supportedLocales || [manifestData2.defaultLanguage];
+  manifestData2.build++;
+  message(messageTypes.INFO, `Writing manifest (${unixPathSep(manifestPath)}):`);
+  const manifestToWrite = Object.assign({}, manifestData2);
+  initConfig2.noManifest.forEach((option) => {
+    delete manifestToWrite[option];
+  });
+  message(messageTypes.INFO, JSON.stringify(manifestToWrite, null, JSON_SPACES));
+  try {
+    await writeFile(manifestPath, JSON.stringify(manifestToWrite, null, JSON_SPACES));
+    message(messageTypes.INFO, STRING.INFO.MANIFESTSTORED);
+  } catch (e) {
+    message(messageTypes.ERROR, `Something went wrong storing manifest: ${e}`);
+  }
+  message(messageTypes.INFO, STRING.INFO.COPYMANIFEST);
+  try {
+    await initNodeJsOnEloWf(settingsJson, manifestData2);
+  } catch (err) {
+    handleConnectionError(err, STRING.ERROR.WFREQUEST);
+  }
+  const indexHtmlPath = ensureSlash(path) + ensureSlash(manifestData2.indexHtmlPath) + manifestData2.indexHtml;
+  message(messageTypes.INFO, `Preparing ${initConfig2.options.indexHtml.value}`);
+  if (!await exists(indexHtmlPath)) {
+    error(STRING.ERROR.INDEXHTMLNOTFOUND, false, indexHtmlPath);
+  }
+  readFileCB(indexHtmlPath, async (err, data) => {
+    if (err) {
+      error(err);
+    }
+    const { window: window2 } = new JSDOM(data, {});
+    const scriptTagList = window2.document.body.querySelectorAll("script[elo]");
+    if (scriptTagList !== null) {
+      if (scriptTagList.length) {
+        scriptTagList.forEach((element) => {
+          element.remove();
+        });
+      }
+    }
+    const faviconEl = window2.document.head.querySelector("link[rel=icon]");
+    if (faviconEl) {
+      faviconEl.remove();
+    }
+    try {
+      const idx = indexHtmlPath.lastIndexOf("/");
+      const devDataPath = `${ensureSlash(indexHtmlPath.substring(0, idx))}devData.js`;
+      const context = testHelper.getIxContext();
+      let jsCode = `(function() {
+            const elo = window.elo = window.elo || {};
+
+            window.api = window.api || {};
+
+            const loadAndExecute = function(src) {
+              // get some kind of XMLHttpRequest
+              const xhrObj = new XMLHttpRequest();
+
+              // open and send a synchronous request
+              xhrObj.open('GET', src, false);
+              xhrObj.send('');
+              // eslint-disable-next-line no-magic-numbers
+              if (xhrObj.status === 200) {
+                // add the returned content to a newly created script tag
+                let code = xhrObj.responseText;
+
+                // replace local variable with global one so data is not written to function scope
+                code = code.replace('var elo = elo', 'var elo = window.elo');
+                // create function to execute loaded script code
+                const fct = new Function(code);
+
+                fct();
+              } else {
+                // eslint-disable-next-line no-console
+                console.error('Error loading devData scripts!', xhrObj.responseText);
+              }
+            };
+
+            loadAndExecute('${context}/plugin/de.elo.ix.plugin.proxy/wf/apps/pages/serverData.jsp');
+            loadAndExecute('${context}/plugin/de.elo.ix.plugin.proxy/wf/apps/pages/appConfig.jsp?id=${manifestData2.id}&namespace=${manifestData2.namespace}');
+            elo.data = elo.data || {};
+            elo.data.server = elo.data.server || {};
+            elo.data.server.ixUrlContext = '${context}';
+            elo.data.server.ixUrl = '${context}/ix';
+            elo.data.server.relativeAppUrl = '${context}/plugin/de.elo.ix.plugin.proxy/wf';
+            elo.data.server.isDevEnv = true;`;
+      jsCode = writeCSSDevDataString(
+        jsCode,
+        "favIcon",
+        "icon",
+        "/apps/resources/images/elo-favicon.ico"
+      ) + "\n";
+      jsCode = writeCSSDevDataString(
+        jsCode,
+        "fontCss",
+        "stylesheet",
+        "/apps/mapping/modules/elo.module.icons/resources/levels/levels-200.css"
+      ) + "\n";
+      if (manifestData2.sordTypeIcons === true) {
+        jsCode = writeCSSDevDataString(
+          jsCode,
+          "sordTypeIconsCss",
+          "stylesheet",
+          "/apps/mapping/modules/elo.module.icons/resources/levels/levels-200.css"
+        ) + "\n";
+      }
+      if (manifestData2.archiveIcons === true) {
+        jsCode = writeCSSDevDataString(
+          jsCode,
+          "archiveIconsCss",
+          "stylesheet",
+          "/apps/mapping/modules/elo.module.icons/resources/archiveicons/archiveicons-200.css"
+        ) + "\n";
+      }
+      jsCode = `${jsCode}}());`;
+      await writeFile(devDataPath, jsCode);
+      message(messageTypes.INFO, "successfully created devData File");
+    } catch (err2) {
+      error("Something went wrong: ", false, err2);
+    }
+    insertScriptTag({ eloAttr: "devData", src: "./devData.js" }, window2);
+    writeAppData(window2, manifestData2);
+    await outputHelpAndWriteFiles(indexHtmlPath, path, manifestData2, window2);
+  });
+});
+class LicenseBuilder {
+  constructor(projectName, writeStream) {
+    this.projectName = projectName;
+    this.writeStream = writeStream;
+    this.dependencyArray = [];
+    this.fileObjList = [];
+    this.fundCounter = 0;
+    this.missingLicenses = [];
+    this.missingCounter = 0;
+  }
+  setDependencyArray(dependencyArray) {
+    this.dependencyArray = dependencyArray;
+  }
+  getDependencyArray() {
+    return this.dependencyArray;
+  }
+  setFileObjList(fileObjList) {
+    this.fileObjList = fileObjList;
+  }
+  getFileObjList() {
+    return this.fileObjList;
+  }
+  addMissingLicense(packageName) {
+    this.missingLicenses.push(packageName);
+  }
+  getMissingLicenses() {
+    return this.missingLicenses;
+  }
+  getMissingCounter() {
+    return this.missingCounter;
+  }
+  getFoundCounter() {
+    return this.fundCounter;
+  }
+  createHeader() {
+    this.writeStream.write(CONSTANTS.LICENSEFILEHEADER.replace("%s", this.projectName));
+  }
+  /**
+   * Creates the license file by writing the license and notice texts of the dependencies into the file. If a license is missing, it adds the dependency to the missing licenses list.
+   * If an error occurs during the file generation, it logs the error message.
+   *
+   * @returns void
+   */
+  async createLicenseFile(inputLicensePath2, manifestData2) {
+    try {
+      this.createHeader();
+      await this.searchForLicenses();
+      if (this.getDependencyArray().length > 0)
+        message(
+          messageTypes.INFO,
+          `Found ${this.getDependencyArray().length} dependencies in 'package.json'.`
+        );
+      else error("No dependencies found in package.json.", false);
+      await this.findModuleLicenses(inputLicensePath2, manifestData2);
+      for (const fileObj of this.getFileObjList()) {
+        this.writeStream.write(
+          `${CONSTANTS.DASHEDLINE + "\n" + CONSTANTS.DASHEDLINE + "\n"}--- ${fileObj.packageObject.fullname}
+${CONSTANTS.DASHEDLINE}
+
+`
+        );
+        if (fileObj.noticeFilePath !== void 0) {
+          const noticeText = await readFileFunction(fileObj.noticeFilePath);
+          this.writeInFile(noticeText);
+        }
+        if (fileObj.found) {
+          const text = await readFileFunction(fileObj.licenseFilePath);
+          this.writeInFile(text);
+          this.fundCounter += 1;
+          continue;
+        } else {
+          this.addMissingLicense(fileObj.packageObject.fullname || fileObj.packageObject.name);
+          this.missingCounter += 1;
+          continue;
+        }
+      }
+    } catch (err) {
+      throw new Error(err.message);
+    }
+  }
+  filterDependencies(dependencieTree) {
+    const dependencieMap = /* @__PURE__ */ new Map();
+    for (const dependencie of dependencieTree) {
+      if (dependencie.extraneous) continue;
+      let path2 = "";
+      let splittetName = "";
+      if (dependencie.name.startsWith("@")) {
+        const splitName = dependencie.name.split("/");
+        path2 = splitName[0];
+        splittetName = splitName[1];
+      }
+      if (dependencie.name === void 0 || dependencie.version === void 0 || dependencie.name.includes(".bin") || dependencie.name.includes("@elo") || dependencie.name.includes(this.projectName))
+        continue;
+      const dependencieObject = {
+        fullname: `${dependencie.name}@${dependencie.version}`,
+        path: path2,
+        name: splittetName !== "" ? splittetName : dependencie.name,
+        version: dependencie.version,
+        resolved: dependencie.resolved,
+        overridden: dependencie.overridden,
+        extraneous: dependencie.extraneous,
+        problems: dependencie.problems || [],
+        hasSubDirectory: splittetName.length > 0,
+        license: dependencie.license ? dependencie.license : "UNKNOWN"
+      };
+      if (dependencieMap.has(dependencieObject.fullname)) {
+        continue;
+      }
+      dependencieMap.set(dependencieObject.fullname, dependencieObject);
+    }
+    removeFile(pathLib.resolve("./dependencies.json"));
+    return Array.from(dependencieMap.values());
+  }
+  /**
+   * Writes the given data into the license file. If the data is not empty, it adds two new lines after the data and increases the found counter by one.
+   *
+   * @param data the data to write into the license file.
+   * @return void
+   */
+  writeInFile(data) {
+    if (data !== "") {
+      this.writeStream.write(`${data}
+
+\r`);
+    }
+  }
+  /**
+   * Builds the path for third-party licenses project.
+   *
+   * @param packageObject the package object.
+   * @param map the manifest license map.
+   * @param inputLicensePath the input license path.
+   * @returns the path for the third-party licenses project.
+   */
+  buildPathForThirdPartyLicensesProject(packageObject, map, inputLicensePath2) {
+    const name = packageObject.hasSubDirectory ? `${packageObject.path} ${packageObject.name}` : packageObject.name;
+    return pathLib.resolve(`${inputLicensePath2}/${map.get(name)}/${packageObject.version}/`);
+  }
+  /**
+   * Searches for license and notice files in the given path.
+   *
+   * @param path the path to search in.
+   * @param packageObject the package object.
+   * @returns a FileObj containing the license and notice file paths.
+   */
+  async getLicenseAndNoticeFile(searchPath, packageObject) {
+    const fileObj = {};
+    const contentFiles = await readdir$1(pathLib.resolve(searchPath));
+    fileObj.packageObject = packageObject;
+    const foundLicense = contentFiles.find((file) => {
+      if (file.toLowerCase().includes("license") || file.toLowerCase().includes("licence"))
+        return file;
+    });
+    const foundNotice = contentFiles.find((file) => {
+      if (file.toLowerCase().includes("notice")) return file;
+    });
+    if (foundLicense) {
+      fileObj.licenseFilePath = pathLib.resolve(searchPath, foundLicense);
+      fileObj.found = true;
+    }
+    if (foundNotice) fileObj.noticeFilePath = pathLib.resolve(searchPath, foundNotice);
+    message(messageTypes.INFO, foundLicense ? "LICENSE found!" : "LICENSE not found!");
+    message(messageTypes.INFO, foundNotice ? "NOTICE found!" : "NOTICE not found!");
+    return fileObj;
+  }
+}
+class NpmLicenseBuilder extends LicenseBuilder {
+  constructor(projectName, writeStream) {
+    super(projectName, writeStream);
+  }
+  async searchForLicenses() {
+    const dependencieTree = await this.getDependencies();
+    const parsedDependencies = this.parseDependencies(dependencieTree);
+    const fullList = this.filterDependencies(parsedDependencies);
+    this.setDependencyArray(fullList);
+  }
+  async findModuleLicenses(inputLicensePath2, manifestData2) {
+    const fileObjList = this.getFileObjList();
+    const manifesrLicenseMap = manifestData2 !== void 0 ? new Map(Object.entries(manifestData2.licenseMap)) : /* @__PURE__ */ new Map();
+    for (const dep of this.getDependencyArray()) {
+      let fileObj = {};
+      if (inputLicensePath2 !== "" && manifesrLicenseMap.has(dep.name)) {
+        const thirdPartyPath = this.buildPathForThirdPartyLicensesProject(
+          dep,
+          manifesrLicenseMap,
+          inputLicensePath2
+        );
+        if (await exists(thirdPartyPath)) {
+          fileObj = await this.getLicenseAndNoticeFile(thirdPartyPath, dep);
+          if (fileObj.found) {
+            fileObjList.push(fileObj);
+            continue;
+          }
+        }
+      }
+      const nodeModulesPath = this.buildContentPath(dep);
+      if (await exists(nodeModulesPath)) {
+        fileObj = await this.getLicenseAndNoticeFile(nodeModulesPath, dep);
+        if (fileObj.found) {
+          fileObjList.push(fileObj);
+          continue;
+        }
+      }
+      message(messageTypes.WARN, STRING.WARN.LICENSENOTFOUND, dep.fullname || dep.name);
+      fileObj.found = false;
+      fileObj.packageObject = dep;
+      fileObjList.push(fileObj);
+    }
+    this.fileObjList = fileObjList;
+  }
+  parseDependencies(dependencies) {
+    const dependencieList = [];
+    const deps = dependencies.dependencies || {};
+    for (const [name, dependencie] of Object.entries(deps)) {
+      const newDependencie = {
+        name,
+        version: dependencie.version,
+        dependencies: dependencie.dependencies,
+        extraneous: dependencie.extraneous,
+        resolved: dependencie.resolved,
+        overridden: dependencie.overridden,
+        license: dependencie.license,
+        hasSubDirectory: false
+      };
+      dependencieList.push(newDependencie);
+      const subDependencies = this.parseDependencies(dependencie);
+      if (subDependencies.length > 0) {
+        dependencieList.push(...subDependencies);
+      }
+    }
+    return dependencieList;
+  }
+  async getDependencies() {
+    let parsedDependencies = {};
+    try {
+      execSync(
+        "npm ls --package-lock-only --depth=Infinity --omit=dev --omit=optional --omit=peer --json > dependencies.json",
+        {
+          encoding: "utf8",
+          stdio: ["pipe", "pipe", "pipe"]
+        }
+      );
+      const dependencieJson = await readFileFunction(pathLib.resolve("./dependencies.json"));
+      parsedDependencies = JSON.parse(dependencieJson);
+    } catch (err) {
+      error(err);
+    }
+    return parsedDependencies;
+  }
+  /**
+   * Builds the content path.
+   *
+   * @param packageObject The package object.
+   * @param fileName The file name to search for.
+   * @returns The constructed content path.
+   */
+  buildContentPath(packageObject) {
+    return packageObject.hasSubDirectory ? `./node_modules/${packageObject.path}/${packageObject.name}/` : `./node_modules/${packageObject.name}/`;
+  }
+}
+class PnpmLicenseBuilder extends LicenseBuilder {
+  constructor(projectName, writeStream, rootPath) {
+    super(projectName, writeStream);
+    this.files = [];
+    this.rootPath = rootPath;
+    this.files = [];
+  }
+  async searchForLicenses() {
+    const dependencieTree = await this.getDependencies();
+    const parsedDependencies = [];
+    for (const dependencie of dependencieTree) {
+      const tempDependencies = this.parseDependencies(dependencie);
+      parsedDependencies.push(...tempDependencies);
+    }
+    const fullList = this.filterDependencies(parsedDependencies);
+    this.setDependencyArray(fullList);
+  }
+  async findModuleLicenses(inputLicensePath2, manifestData2) {
+    const fileObjList = [];
+    const manifesrLicenseMap = manifestData2 !== void 0 ? new Map(Object.entries(manifestData2.licenseMap)) : /* @__PURE__ */ new Map();
+    for (const dep of this.getDependencyArray()) {
+      let fileObj = {};
+      if (inputLicensePath2 !== "" && manifesrLicenseMap.has(dep.name)) {
+        const thirdPartyPath = this.buildPathForThirdPartyLicensesProject(
+          dep,
+          manifesrLicenseMap,
+          inputLicensePath2
+        );
+        if (await exists(thirdPartyPath)) {
+          fileObj = await this.getLicenseAndNoticeFile(thirdPartyPath, dep);
+          if (fileObj.found) {
+            fileObjList.push(fileObj);
+            continue;
+          }
+        }
+      }
+      const pnpmInnerPath = this.buildPnpmLicenseInnerPath(dep);
+      if (await exists(pnpmInnerPath)) {
+        fileObj = await this.getLicenseAndNoticeFile(pnpmInnerPath, dep);
+        if (fileObj.found) {
+          fileObjList.push(fileObj);
+          continue;
+        }
+      }
+      const fallbackPath = await this.buildFallbackPath(dep);
+      if (fallbackPath !== "none") {
+        fileObj = await this.getLicenseAndNoticeFile(fallbackPath, dep);
+        if (fileObj.found) {
+          fileObjList.push(fileObj);
+          continue;
+        }
+      }
+      const pnpmOuterPath = this.buildPnpmLicenseOuterPath(dep);
+      if (await exists(pnpmOuterPath)) {
+        fileObj = await this.getLicenseAndNoticeFile(pnpmOuterPath, dep);
+        if (fileObj.found) {
+          fileObjList.push(fileObj);
+          continue;
+        }
+      }
+      message(messageTypes.WARN, STRING.WARN.LICENSENOTFOUND, dep.fullname || dep.name);
+      fileObj.found = false;
+      fileObj.packageObject = dep;
+      fileObjList.push(fileObj);
+    }
+    this.setFileObjList(fileObjList);
+  }
+  parseDependencies(dependencies) {
+    const dependencieList = [];
+    const deps = dependencies.dependencies || {};
+    for (const [name, dependencie] of Object.entries(deps)) {
+      const newDependencie = {
+        name,
+        version: dependencie.version,
+        dependencies: dependencie.dependencies,
+        extraneous: dependencie.extraneous,
+        resolved: dependencie.resolved,
+        overridden: dependencie.overridden,
+        license: dependencie.license,
+        hasSubDirectory: false
+      };
+      dependencieList.push(newDependencie);
+      const subDependencies = this.parseDependencies(dependencie);
+      if (subDependencies.length > 0) {
+        dependencieList.push(...subDependencies);
+      }
+    }
+    return dependencieList;
+  }
+  async getDependencies() {
+    let parsedDependencies = [];
+    try {
+      execSync("pnpm list --long --json --prod --depth Infinity > dependencies.json", {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const dependencieJson = await readFileFunction(pathLib.resolve("./dependencies.json"));
+      parsedDependencies = JSON.parse(dependencieJson);
+    } catch (err) {
+      error(err);
+    }
+    return parsedDependencies;
+  }
+  /**
+   * Builds the fallback path to locate the package in the pnpm structure.
+   *
+   * @param packageObject the package object.
+   * @returns the fallback path to locate the package, or 'none' if not found.
+   */
+  async buildFallbackPath(packageObject) {
+    if (this.files.length === 0) {
+      this.files = await readdir$1(pathLib.resolve(ensureSlash(this.rootPath), "node_modules/.pnpm/"));
+    }
+    const matchedFolder = this.searchInPnpmModules(this.files, packageObject);
+    if (matchedFolder) {
+      const searchPath = packageObject.hasSubDirectory ? pathLib.resolve(
+        ensureSlash(this.rootPath) + "node_modules/.pnpm/",
+        `${matchedFolder}/node_modules/${packageObject.path}/${packageObject.name}/`
+      ) : pathLib.resolve(
+        ensureSlash(this.rootPath) + "node_modules/.pnpm/",
+        `${matchedFolder}/node_modules/${packageObject.name}/`
+      );
+      if (!await exists(pathLib.resolve(searchPath))) return "none";
+      return searchPath;
+    }
+    return "none";
+  }
+  /**
+   * Searches for a package in the list of pnpm module folders.
+   *
+   * @param fileList list of files in the .pnpm directory.
+   * @param packageObject the package object to search for.
+   * @returns the matched folder name, or an empty string if not found.
+   */
+  searchInPnpmModules(fileList, packageObject) {
+    const findPositions = [];
+    fileList.forEach((file) => {
+      if (file.includes(packageObject.name)) {
+        findPositions.push(file);
+      }
+    });
+    const matchedFile = findPositions.find((position) => {
+      let name = false, path2 = false, version = false;
+      if (position.includes(packageObject.version)) {
+        version = true;
+      }
+      if (packageObject.hasSubDirectory) {
+        if (position.includes(packageObject.path)) {
+          path2 = true;
+        }
+      }
+      if (position.includes(packageObject.name)) {
+        name = true;
+      }
+      if (name && version && (packageObject.hasSubDirectory ? path2 : true)) {
+        return position;
+      }
+    });
+    return matchedFile || "";
+  }
+  /**
+   * Builds the path to the license file inside the .pnpm folder.
+   *
+   * @param packageObject the package object.
+   * @returns the path to the license file.
+   */
+  buildPnpmLicenseInnerPath(packageObject) {
+    return packageObject.hasSubDirectory ? pathLib.resolve(
+      this.rootPath,
+      `node_modules/.pnpm/${packageObject.fullname?.replace("/", "+")}/node_modules/${packageObject.path}/${packageObject.name}/`
+    ) : pathLib.resolve(
+      this.rootPath,
+      `node_modules/.pnpm/${packageObject.fullname}/node_modules/${packageObject.name}/`
+    );
+  }
+  /**
+   * Builds the path to the license file outside the .pnpm folder.
+   *
+   * @param packageObject the package object.
+   * @returns the path to the license file.
+   */
+  buildPnpmLicenseOuterPath(packageObject) {
+    return packageObject.hasSubDirectory ? pathLib.resolve(this.rootPath, `node_modules/${packageObject.path}/${packageObject.name}/`) : pathLib.resolve(this.rootPath, `node_modules/${packageObject.name}/`);
+  }
+}
+class YarnLicenseBuilder extends LicenseBuilder {
+  async searchForLicenses() {
+    const dependencieTree = await this.getDependencies();
+    const { dependencieList, uncompleteDependencies } = this.parseDependencies(
+      dependencieTree[0].data.trees
+    );
+    const completeList = this.completeYarnDependencies(uncompleteDependencies);
+    dependencieList.push(...completeList);
+    const fullList = this.filterDependencies(dependencieList);
+    this.setDependencyArray(fullList);
+  }
+  async findModuleLicenses(inputLicensePath2, manifestData2) {
+    const fileObjList = this.getFileObjList();
+    const manifesrLicenseMap = manifestData2 !== void 0 ? new Map(Object.entries(manifestData2.licenseMap)) : /* @__PURE__ */ new Map();
+    for (const dep of this.getDependencyArray()) {
+      let fileObj = {};
+      if (inputLicensePath2 !== "" && manifesrLicenseMap.has(dep.name)) {
+        const thirdPartyPath = this.buildPathForThirdPartyLicensesProject(
+          dep,
+          manifesrLicenseMap,
+          inputLicensePath2
+        );
+        if (await exists(thirdPartyPath)) {
+          fileObj = await this.getLicenseAndNoticeFile(thirdPartyPath, dep);
+          if (fileObj.found) {
+            fileObjList.push(fileObj);
+            continue;
+          }
+        }
+      }
+      const nodeModulesPath = this.buildContentPath(dep);
+      if (await exists(nodeModulesPath)) {
+        fileObj = await this.getLicenseAndNoticeFile(nodeModulesPath, dep);
+        if (fileObj.found) {
+          fileObjList.push(fileObj);
+          continue;
+        }
+      }
+      message(messageTypes.WARN, STRING.WARN.LICENSENOTFOUND, dep.fullname || dep.name);
+      fileObj.found = false;
+      fileObj.packageObject = dep;
+      fileObjList.push(fileObj);
+    }
+    this.fileObjList = fileObjList;
+  }
+  parseDependencies(dependencies) {
+    const dependencieList = [];
+    const uncompleteDependencies = [];
+    const AMBIGIUOUS_YARN_VERSION_LENGTH = 6;
+    for (const dependencie of dependencies) {
+      if (!dependencie.name) {
+        continue;
+      }
+      const atIndex = dependencie.name.lastIndexOf("@");
+      const newDependencie = {
+        name: atIndex > 0 ? dependencie.name.slice(0, atIndex) : dependencie.name,
+        version: atIndex > 0 ? dependencie.name.slice(atIndex + 1).replace(/^[\^~><=]+/, "") : "UNKNOWN"
+      };
+      if (newDependencie.version.length <= 1 || newDependencie.version.length > AMBIGIUOUS_YARN_VERSION_LENGTH) {
+        uncompleteDependencies.push(newDependencie);
+      } else {
+        dependencieList.push(newDependencie);
+      }
+      if (dependencie.children && dependencie.children.length > 0) {
+        const {
+          dependencieList: subDependencieList,
+          uncompleteDependencies: subUncompleteDependencies
+        } = this.parseDependencies(dependencie.children);
+        dependencieList.push(...subDependencieList);
+        uncompleteDependencies.push(...subUncompleteDependencies);
+      }
+    }
+    return { dependencieList, uncompleteDependencies };
+  }
+  async getDependencies() {
+    let parsedDependencies = [];
+    try {
+      execSync("yarn list --json --production --depth=Infinity > dependencies.json", {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      parsedDependencies = await this.parseNewlineDelimitedJsonToJson(
+        pathLib.resolve("./dependencies.json")
+      );
+    } catch (err) {
+      error(err);
+    }
+    return parsedDependencies;
+  }
+  async parseNewlineDelimitedJsonToJson(filePath) {
+    try {
+      const fileStream = createReadStreamSync(pathLib.resolve(filePath));
+      const readLine = readline$1.createInterface({ input: fileStream });
+      const result = [];
+      for await (const line of readLine) {
+        if (line.trim() === "") continue;
+        result.push(JSON.parse(line));
+      }
+      return result;
+    } catch (err) {
+      error(err);
+    }
+    return [];
+  }
+  /**
+   * Completes the information of uncomplete Yarn dependencies
+   *
+   * @param uncompleteDependencies a list of uncomplete dependencies
+   * @returns a list of completed dependencies
+   */
+  completeYarnDependencies(uncompleteDependencies) {
+    const completedDependencies = [];
+    for (const dep of uncompleteDependencies) {
+      const versions = execSync(`yarn info ${dep.name} --json`, { encoding: "utf8" });
+      const parsedVersions = JSON.parse(versions);
+      const completedDep = {
+        name: dep.name,
+        version: parsedVersions.data.version || "UNKNOWN"
+      };
+      completedDependencies.push(completedDep);
+    }
+    return completedDependencies;
+  }
+  /**
+   * Builds the content path.
+   *
+   * @param packageObject The package object.
+   * @param fileName The file name to search for.
+   * @returns The constructed content path.
+   */
+  buildContentPath(packageObject) {
+    return packageObject.hasSubDirectory ? `./node_modules/${packageObject.path}/${packageObject.name}/` : `./node_modules/${packageObject.name}/`;
+  }
+}
+class LicenseBuilderFactory {
+  async getLicenseBuilder(projectName, writeStream) {
+    const result = await this.searchPackageManager(process.cwd());
+    if (result === void 0)
+      error(
+        `No supported package manager found in the current directory or any parent directories.`
+      );
+    const packageManager = typeof result === "string" ? result : result.packageManager;
+    const rootPath = typeof result === "string" ? process.cwd() : result.rootPath;
+    switch (packageManager) {
+      case "npm":
+        message(messageTypes.INFO, `Using npm as package manager.`);
+        return new NpmLicenseBuilder(projectName, writeStream);
+      case "yarn":
+        message(messageTypes.INFO, `Using yarn as package manager.`);
+        return new YarnLicenseBuilder(projectName, writeStream);
+      case "pnpm":
+        message(messageTypes.INFO, `Using pnpm as package manager.`);
+        return new PnpmLicenseBuilder(projectName, writeStream, rootPath);
+      default:
+        throw new Error(`Unsupported package manager: ${packageManager}`);
+    }
+  }
+  /**
+   * checks which package manager is used in the current project
+   *
+   * @param startDir the directory to start searching from
+   * @returns the package manager used in the project
+   */
+  async searchPackageManager(startDir) {
+    const lockFiles = {
+      npm: "package-lock.json",
+      pnpm: "pnpm-lock.yaml",
+      yarn: "yarn.lock"
+    };
+    for (const [manager, lock] of Object.entries(lockFiles)) {
+      const packagePath = pathLib.join(startDir, lock);
+      if (await exists(packagePath)) {
+        return { packageManager: manager.toString(), rootPath: pathLib.dirname(packagePath) };
+      }
+    }
+    const parentDir = pathLib.dirname(startDir);
+    if (parentDir === startDir) return "unknown";
+    return await this.searchPackageManager(parentDir);
+  }
+}
+const missingLicenses = [];
+let findLicenseCounter = 0;
+let missingLicenseCount = 0;
+let licenseWriteStream;
+let inputLicensePath = "";
+let manifestData$1;
+let packageJsonData;
+const licenseCommand = new Command("license").description(
+  "Create a 3rdpartylicenses.txt file, which contains the licenses of all dependencies."
+).option("--p, --path <string>", "The local 3rd-party-license folder").action(async (options) => {
+  manifestData$1 = await getJsonFile(pathLib.resolve("./manifest.json"), false);
+  packageJsonData = await getJsonFile(
+    pathLib.resolve("./package.json"),
+    false
+  );
+  if (!manifestData$1 && !packageJsonData) error("No manifest or package.json found", false);
+  if (!manifestData$1 && options.path !== void 0)
+    error("The --path parameter can only be used if a manifest.json file exists.", false);
+  licenseWriteStream = createWriteStreamSync("./3rdpartylicenses.txt");
+  const projectName = manifestData$1?.name ?? packageJsonData?.name;
+  if (options.path !== void 0) {
+    if (options.path !== "") {
+      inputLicensePath = `./${options.path}`;
+      message(messageTypes.INFO, `Searching for licenses in '${inputLicensePath}' folder.`);
+      if (!await exists(inputLicensePath))
+        message(
+          messageTypes.WARN,
+          `The specified path '${inputLicensePath}' does not exists. Default paths will be used.`
+        );
+    } else {
+      error(
+        `'--p' <path> parameter has to be of type 'String' and isn't allowed to be empty.`,
+        false
+      );
+    }
+  }
+  try {
+    const licenseBuilderFactory = new LicenseBuilderFactory();
+    const licenseBuilder = await licenseBuilderFactory.getLicenseBuilder(
+      projectName,
+      licenseWriteStream
+    );
+    await licenseBuilder.createLicenseFile(inputLicensePath, manifestData$1 || {});
+    findLicenseCounter = licenseBuilder.getFoundCounter();
+    missingLicenseCount = licenseBuilder.getMissingCounter();
+    missingLicenses.push(...licenseBuilder.getMissingLicenses());
+    if (missingLicenseCount > 0) {
+      if (inputLicensePath !== "" && !await exists(inputLicensePath)) {
+        unlinkSync("./3rdpartylicenses.txt");
+      }
+      const totalModules = findLicenseCounter + missingLicenseCount;
+      message(
+        messageTypes.WARN,
+        `${missingLicenseCount + (missingLicenseCount > 1 ? " licenses " : " license ")}out of ${totalModules}${totalModules > 1 ? " modules " : " module "}not found.`
+      );
+      error(`Not all licenses found.
+${missingLicenses.join("\n")}`, false);
+    } else {
+      message(
+        messageTypes.INFO,
+        `${findLicenseCounter + (findLicenseCounter > 1 ? " licenses" : " license")} ${STRING.INFO.LICENSESAVED}`
+      );
+    }
+  } catch (err) {
+    error(`Error generating license file: ${err}`, false);
+  }
+});
+const linkCommand = new Command("link").description("It links the ELO dependencies").option("--source_path <string>", 'The "elo-vue-libs" project path.').option("--no_source_link", 'No "npm link" execution.').option("--no_build", 'No "npm run build" execution.').action(async (options, path) => {
+  path = ensureSlash(pathLib.resolve(unixPathSep(process.cwd())));
+  const simpleLink = !!options.no_source_link;
+  const shouldBuild = !options.no_build;
+  const packageJson2 = await getJsonFile(
+    pathLib.resolve(path, CONSTANTS.PACKAGEFILE),
+    true
+  );
+  let linkFolder = "";
+  let sourcePath = "";
+  if (options.source_path) {
+    sourcePath = options.source_path;
+    message(messageTypes.INFO, `source path: ${sourcePath}`);
+  }
+  if (!packageJson2.eloDependencies) {
+    error(STRING.ERROR.NOELODEPENDENCIES, false);
+  }
+  if (!simpleLink) {
+    const folderCandidates = [
+      "elo-vue-libs",
+      sourcePath,
+      pathLib.resolve(path, "../elo-vue-libs"),
+      pathLib.resolve(path, "../../elo-vue-libs")
+    ];
+    for (const dependency of packageJson2.eloDependencies) {
+      try {
+        if (dependency.name === "elo-cli") {
+          message(messageTypes.WARN, STRING.WARN.NOCLILINKING);
+          continue;
+        }
+        linkFolder = folderCandidates.find(async (path2) => {
+          if (await exists(pathLib.resolve(path2))) {
+            return path2;
+          }
+        }) || "";
+        if (linkFolder === "") continue;
+        const dependencyFolder = pathLib.resolve(linkFolder, dependency.folder);
+        const command22 = shouldBuild && dependency.buildCommand !== "NONE" && typeof dependency.buildCommand === "string" ? `cd ${dependencyFolder} && npm link && npm run ${dependency.buildCommand}` : `cd ${dependencyFolder} && npm link`;
+        message(messageTypes.DEFAULT, command22);
+        const result = execSync(command22);
+        message(messageTypes.DEFAULT, result.toString());
+      } catch (err) {
+        error(err, false, STRING.ERROR.LINKDEPENDENCY);
+      }
+    }
+  }
+  message(messageTypes.DEFAULT, "link elo dependencies");
+  let command2 = "npm link";
+  packageJson2.eloDependencies.forEach((dependency) => {
+    if (dependency.name === "elo-cli") {
+      message(messageTypes.WARN, STRING.WARN.NOCLILINKING);
+      return;
+    }
+    command2 = `${command2} @elo/${dependency.name}`;
+  });
+  try {
+    message(messageTypes.DEFAULT, command2);
+    const result = execSync(command2);
+    message(messageTypes.DEFAULT, result.toString());
+    message(messageTypes.INFO, "link complete");
+  } catch (err) {
+    error(err, false, STRING.ERROR.LINKDEPENDENCY);
+  }
+});
+let manifestData;
+let defaultPropertiesFile = "";
+let supportedLocales = [];
+const foundProperties = [];
+async function getPropertyFiles(src) {
+  try {
+    const files = await FastGlob([`${src}/**/*.properties`]);
+    foundProperties.push(...files);
+    if (foundProperties.length === 0) error("No properties found", false);
+    foundProperties.forEach((props) => {
+      if (!props.includes("_")) defaultPropertiesFile = props;
+    });
+  } catch (err) {
+    error(STRING.ERROR.GETPROPERTYFILES, false, err);
+  }
+}
+async function createNewLocalizationFiles(manifestData2, path2) {
+  try {
+    message(messageTypes.INFO, STRING.INFO.CREATELOCALESDIR, path2);
+    const name = manifestData2.name?.includes("/") ? manifestData2.name.split("/")[1] : manifestData2.name;
+    mkdir(path2, false);
+    await writeFile(ensureSlash(path2) + `${name}-app.properties`, `APP.NAME=${name}`);
+  } catch (err) {
+    error(STRING.ERROR.CREATENEWLOCALES, false, err);
+  }
+}
+function checkConditions(src, dist, manifestData2) {
+  const foundErrors = [];
+  const tab = "      ";
+  if (!src) foundErrors.push(tab + STRING.ERROR.SRCPATHREQIRED);
+  if (!dist) foundErrors.push(tab + STRING.ERROR.DISTPATHREQIRED);
+  if (!manifestData2.defaultLanguage || manifestData2.defaultLanguage === "")
+    foundErrors.push(tab + STRING.ERROR.NODEFAULTLANG);
+  if (!supportedLocales || supportedLocales.length === 0)
+    foundErrors.push(tab + STRING.ERROR.NOSUPPORTEDLOCALES);
+  if (foundErrors.length > 0)
+    error("Cannot localize, found errors:\n" + foundErrors.join("\n"), false);
+}
+async function getKeysAndCheckKeyDuplicates() {
+  const keyMap = /* @__PURE__ */ new Map();
+  const doubleKeys = /* @__PURE__ */ new Map();
+  console.log("Default properties file: " + defaultPropertiesFile);
+  try {
+    const readProperties = (await readFileFunction(defaultPropertiesFile)).trim();
+    const splittetLines = readProperties.split(os.EOL);
+    splittetLines.forEach((line) => {
+      const splittKeyValue = line.split("=");
+      if (splittKeyValue.length !== 2) {
+        message(messageTypes.WARN, `Invalid line in default properties file: ` + line);
+        return;
+      }
+      if (keyMap.has(splittKeyValue[0])) {
+        doubleKeys.set(splittKeyValue[0], splittKeyValue[1]);
+        return;
+      }
+      keyMap.set(splittKeyValue[0], splittKeyValue[1]);
+    });
+    if (doubleKeys.size > 0)
+      message(
+        messageTypes.WARN,
+        "Duplicate keys found: " + Array.from(doubleKeys.keys()).join(", ")
+      );
+    else message(messageTypes.INFO, STRING.INFO.NOKEYDUPLICATESFOUND);
+  } catch (err) {
+    error(STRING.ERROR.GETKEYSCHECKDUPLICATES, false, err);
+  }
+  return { keyMap, doubleKeys };
+}
+async function checkUnusedKeys(keyMap) {
+  const unusedKeys = new Map(keyMap);
+  try {
+    const files = await FastGlob.async(CONSTANTS.GLOBBYPATTERN, {
+      ignore: CONSTANTS.GLOBBYOPTIONS.ignore
+    });
+    for (const file of files) {
+      if (file.endsWith("properties") || file.includes("all_locales.js")) continue;
+      const fileContent = await readFileFunction(file);
+      for (const [key] of unusedKeys) {
+        if (fileContent.includes(key)) unusedKeys.delete(key);
+      }
+    }
+    if (unusedKeys.size > 0)
+      message(
+        messageTypes.WARN,
+        `Unused ${unusedKeys.size > 1 ? "keys" : "key"} found: ` + Array.from(unusedKeys.keys()).join(", ")
+      );
+    else message(messageTypes.INFO, STRING.INFO.NOUNUSEDKEYS);
+  } catch (err) {
+    error(STRING.ERROR.CHECKUNUSEDKEYS, false, err);
+  }
+  return unusedKeys;
+}
+async function createLocalesMap(keyMap, manifestData2, propertiesFiles) {
+  const localesMap = /* @__PURE__ */ new Map();
+  const issueReport = /* @__PURE__ */ new Map();
+  issueReport.set("unusedKeys", /* @__PURE__ */ new Map());
+  issueReport.set("duplicateKeys", /* @__PURE__ */ new Map());
+  issueReport.set("unnecessaryKeys", /* @__PURE__ */ new Map());
+  try {
+    for (const propertiesFile of propertiesFiles) {
+      const lang = getLangFromFilename(propertiesFile);
+      const duplicateKeysMap = /* @__PURE__ */ new Map();
+      const unnecessaryKeysMap = /* @__PURE__ */ new Map();
+      const unusedKeysMap = new Map(keyMap);
+      if (localesMap.has(lang)) continue;
+      if (lang && !supportedLocales.includes(lang)) {
+        message(messageTypes.WARN, STRING.INFO.NEWLANGUAGEFOUND, lang);
+        manifestData2.supportedLocales.push(lang);
+        await updateManifestData(manifestData2);
+      }
+      if (lang === "") {
+        if (localesMap.has(manifestData2.defaultLanguage))
+          error(STRING.ERROR.DUPDEFAULTLANGFILE, false);
+        localesMap.set(manifestData2.defaultLanguage, /* @__PURE__ */ new Map());
+        keyMap.forEach((value, key) => {
+          localesMap.get(manifestData2.defaultLanguage)?.set(key, value);
+        });
+      } else {
+        const readProperties = await readFileFunction(propertiesFile);
+        const splittetLines = readProperties.split(os.EOL);
+        localesMap.set(lang, /* @__PURE__ */ new Map());
+        for (const line of splittetLines) {
+          if (!line.trim() || line.trim().startsWith("#") || line.trim().startsWith("!")) continue;
+          if (!line.includes("=")) {
+            message(messageTypes.WARN, `Invalid line in '${lang}' properties file: ` + line);
+            continue;
+          }
+          const splittKeyValue = line.split("=");
+          if (!keyMap.has(splittKeyValue[0])) {
+            unnecessaryKeysMap.set(splittKeyValue[0], splittKeyValue[1]);
+            continue;
+          }
+          if (splittKeyValue.length > 2) {
+            message(messageTypes.WARN, `Invalid line in '${lang}' properties file: ` + line);
+            continue;
+          }
+          if (localesMap.get(lang)?.has(splittKeyValue[0]))
+            duplicateKeysMap.set(splittKeyValue[0], splittKeyValue[1]);
+          if (unusedKeysMap.has(splittKeyValue[0])) unusedKeysMap.delete(splittKeyValue[0]);
+          localesMap.get(lang)?.set(splittKeyValue[0], splittKeyValue[1]);
+        }
+        if (duplicateKeysMap.size > 0) {
+          issueReport.get("duplicateKeys").set(lang, duplicateKeysMap);
+          message(
+            messageTypes.WARN,
+            `Duplicate ${duplicateKeysMap.size > 1 ? "keys" : "key"} found: ` + Array.from(duplicateKeysMap.keys()).join(", ")
+          );
+        }
+        if (unnecessaryKeysMap.size > 0) {
+          issueReport.get("unnecessaryKeys").set(lang, unnecessaryKeysMap);
+          message(
+            messageTypes.WARN,
+            `Unnecessary ${unnecessaryKeysMap.size > 1 ? "keys" : "key"} found: ` + Array.from(unnecessaryKeysMap.keys()).join(", ")
+          );
+        }
+        if (unusedKeysMap.size > 0) {
+          issueReport.get("unusedKeys").set(lang, unusedKeysMap);
+          message(
+            messageTypes.WARN,
+            `Unused ${unusedKeysMap.size > 1 ? "keys" : "key"} found: ` + Array.from(unusedKeysMap.keys()).join(", ")
+          );
+        }
+        message(messageTypes.INFO, STRING.INFO.PROPERTIESPROCESSED, propertiesFile);
+      }
+    }
+  } catch (err) {
+    error(STRING.ERROR.CREATELOCALESMAP, false, err);
+  }
+  return { localesMap, issueReport };
+}
+function checkLanguageIntegrity(localesMap, manifestData2) {
+  const completeMap = localesMap;
+  message(messageTypes.INFO, STRING.INFO.STARTINTIGRITYCHECK);
+  for (const [lang, langMap] of completeMap) {
+    if (lang === manifestData2.defaultLanguage) continue;
+    const checkKeysMap = completeMap.get(manifestData2.defaultLanguage);
+    const fallBackLang = getFallbackLanguage(lang);
+    for (const [key, value] of checkKeysMap) {
+      if (!langMap.has(key)) {
+        if (fallBackLang && completeMap.get(fallBackLang).has(key)) {
+          message(messageTypes.WARN, STRING.WARN.CHANGELANGUAGEVALUE, key, lang, fallBackLang);
+          completeMap.get(lang).set(key, completeMap.get(fallBackLang).get(key));
+        } else {
+          message(
+            messageTypes.WARN,
+            STRING.WARN.CHANGELANGUAGEVALUE,
+            key,
+            lang,
+            manifestData2.defaultLanguage
+          );
+          completeMap.get(lang).set(key, value);
+        }
+      }
+    }
+    message(messageTypes.INFO, STRING.INFO.LANGUAGEINTEGRITYCHECK, lang);
+  }
+  return completeMap;
+}
+async function writeAllLocalesFile(completeLocalesMap, distPath) {
+  try {
+    let localesString = "";
+    localesString += `(function (factory) {${os.EOL}var elo = factory(window);${os.EOL}if (typeof exports === 'object') {${os.EOL}exports = elo;${os.EOL}}${os.EOL}}(function (win) {${os.EOL}var elo = (win ? win.elo : false) || elo || {};${os.EOL}elo.locale = elo.locale || {};${os.EOL}elo.locale.localeMap = elo.locale.localeMap || {};${os.EOL}`;
+    for (const [lang, langMap] of completeLocalesMap) {
+      localesString += `elo.locale.localeMap["${lang}"] = elo.locale.localeMap["${lang}"] || {};${os.EOL}`;
+      for (const [key, value] of langMap) {
+        localesString += `elo.locale.localeMap["${lang}"]["${key}"] = ${JSON.stringify(value)};${os.EOL}`;
+      }
+    }
+    localesString += `if (elo.data && elo.data.server && elo.data.server.language) {${os.EOL}elo.locale.language = elo.data.server.language;${os.EOL}elo.locale.store = elo.locale.localeMap[elo.locale.language];${os.EOL}}${os.EOL}return elo;${os.EOL}}));`;
+    message(
+      messageTypes.INFO,
+      STRING.INFO.WRITELOCALESFILE,
+      pathLib.resolve(ensureSlash(distPath), "all_locales.js")
+    );
+    await writeFile(ensureSlash(distPath) + "all_locales.js", localesString);
+  } catch (err) {
+    error(STRING.ERROR.WRITELOCALESFILE, false, err);
+  }
+}
+async function writeReportFile(issueReport) {
+  message(
+    messageTypes.INFO,
+    STRING.INFO.WRITEREPORTFILE,
+    pathLib.resolve(ensureSlash(process.cwd()), "localization_report.json")
+  );
+  await writeFile("./localization_report.json", JSON.stringify(mapToObj(issueReport), void 0, 4));
+  message(messageTypes.INFO, STRING.INFO.REPORTCOMPOLETED);
+}
+function getLangFromFilename(filename) {
+  const file = filename.split("/").pop();
+  const fileNameOnly = file.split(".")[0];
+  const split = fileNameOnly.split("_");
+  const langCode = split.length > 2 ? split.slice(1).join("_") : split[1] || "";
+  return langCode;
+}
+function getFallbackLanguage(lang) {
+  let langParts;
+  if (lang.includes("_")) langParts = lang.split("_")[0];
+  else langParts = lang;
+  const foundLang = manifestData.supportedLocales.find((language) => {
+    if (lang === language) return;
+    if (language.includes(langParts)) return language;
+  });
+  return foundLang ?? "";
+}
+const localizeCommand = new Command("localize").description("Localize language files and parse them to JSON format.").option(
+  "--s, --src <string>",
+  "The path where the properties files are. If no folder is given, new localization files will be created based on the manifest data."
+).option(
+  "--d, --dist <string>",
+  "The path where the js files will be. The directory will be cleared."
+).option(
+  "--r, --report",
+  "Generate a report.json of unused and duplicate keys in the localization files."
+).action(async (options) => {
+  manifestData = await getManifestData();
+  supportedLocales = manifestData.supportedLocales;
+  checkConditions(options.src, options.dist, manifestData);
+  if (!await exists(pathLib.resolve(options.src))) {
+    await createNewLocalizationFiles(manifestData, options.src);
+  } else {
+    if (await isFolderEmpty(pathLib.resolve(options.src)))
+      error(STRING.ERROR.PROPERTIESNOTFOUND, false);
+  }
+  if (!await exists(pathLib.resolve(options.dist))) {
+    message(messageTypes.INFO, STRING.INFO.CREATEDISTDIR, pathLib.resolve(options.dist));
+    mkdir(pathLib.resolve(options.dist), false);
+  }
+  await getPropertyFiles(options.src);
+  const { keyMap, doubleKeys } = await getKeysAndCheckKeyDuplicates();
+  const unusedKeys = await checkUnusedKeys(keyMap);
+  const { localesMap, issueReport } = await createLocalesMap(
+    keyMap,
+    manifestData,
+    foundProperties
+  );
+  const completeLocalesMap = checkLanguageIntegrity(localesMap, manifestData);
+  await writeAllLocalesFile(completeLocalesMap, options.dist);
+  message(messageTypes.INFO, STRING.INFO.LOCALIZATIONCOMPLETE);
+  if (options.report) {
+    if (doubleKeys.size > 0)
+      issueReport.get("duplicateKeys").set(manifestData.defaultLanguage, doubleKeys);
+    if (unusedKeys.size > 0)
+      issueReport.get("unusedKeys").set(manifestData.defaultLanguage, unusedKeys);
+    await writeReportFile(issueReport);
+  }
+});
+const command = process.platform === "win32" ? "npm.cmd" : "npm";
+async function getVersionFromRegistry(rootPath, repoInfo, tag, server) {
+  return new Promise((resolve) => {
+    const nameAndTag = `${repoInfo.packageJson.name}@${tag}`;
+    const args = ["view", nameAndTag, "--registry", server, "--json"];
+    exec(command + ` ${args.join(" ")}`, { cwd: rootPath }, (err, stdout) => {
+      if (err) return resolve("none");
+      const json = JSON.parse(stdout);
+      return resolve(json.version);
+    });
+  });
+}
+async function increaseRegistryVersion(rootPath, version) {
+  return new Promise((resolve, reject) => {
+    const args = ["version", version];
+    exec(command + ` ${args.join(" ")}`, { cwd: rootPath }, async (err, stdout, stderr) => {
+      if (err) {
+        if (err.message.includes("Version not changed")) {
+          if (await checkNewVersionInPackageJson(rootPath, version)) return resolve(stdout.trim());
+        }
+        return reject(new Error(stderr || err.message));
+      }
+      return resolve(stdout.trim());
+    });
+  });
+}
+async function publishPackage(rootPath, tag, server) {
+  return new Promise((resolve, reject) => {
+    const args = ["publish", "--tag", tag, "--registry", server];
+    exec(command + ` ${args.join(" ")}`, { cwd: rootPath }, (err, stdout, stderr) => {
+      if (err) reject(new Error(stderr || err.message));
+      return resolve(stdout.trim());
+    });
+  });
+}
+async function addTag(rootPath, repoInfo, tag, server) {
+  return new Promise((resolve, reject) => {
+    const args = [
+      "dist-tag",
+      "add",
+      repoInfo.packageJson.name + "@" + repoInfo.newVersion,
+      tag,
+      "--registry",
+      server
+    ];
+    exec(command + ` ${args.join(" ")}`, { cwd: rootPath }, (err, stdout, stderr) => {
+      if (err) reject(new Error(stderr || err.message));
+      return resolve(stdout.trim());
+    });
+  });
+}
+async function checkNewVersionInPackageJson(rootPath, version) {
+  const packageJson2 = await getJsonFile(
+    pathLib.resolve(rootPath, "package.json")
+  );
+  return packageJson2.version === version;
+}
+const npmComManager = {
+  async getVersionFromRegistry(repoInfo, server, tag) {
+    const rootPath = pathLib.resolve(ensureSlash(repoInfo.repository.path));
+    try {
+      return await getVersionFromRegistry(rootPath, repoInfo, tag, server);
+    } catch (err) {
+      throw Error(`Get version from registry failed: ${err}`);
+    }
+  },
+  async increaseRegistryVersion(repoInfo, version) {
+    const rootPath = pathLib.resolve(ensureSlash(repoInfo.repository.path));
+    try {
+      await increaseRegistryVersion(rootPath, version);
+    } catch (err) {
+      throw Error(`Set higher version failed: ${err}`);
+    }
+  },
+  async publishPackage(repoInfo, tag, server) {
+    const rootPath = pathLib.resolve(ensureSlash(repoInfo.repository.path));
+    try {
+      await publishPackage(rootPath, tag, server);
+    } catch (err) {
+      throw Error(`Publish package failed: ${err}`);
+    }
+  },
+  async addTag(repoInfo, tag, server) {
+    const rootPath = pathLib.resolve(ensureSlash(repoInfo.repository.path));
+    try {
+      await addTag(rootPath, repoInfo, tag, server);
+    } catch (err) {
+      throw Error(`Add tag failed: ${err}`);
+    }
+  }
+};
+const multiRepoInfos = [];
+async function validateMultiRepoConfig(config) {
+  for (const repoConfig2 of config) {
+    const packageJsonPath2 = pathLib.resolve(ensureSlash(repoConfig2.path), "package.json");
+    if (!repoConfig2.path || !repoConfig2.name) error(STRING.ERROR.MULTIREPOCONFIGEMPTYPART, false);
+    if (!await exists(packageJsonPath2))
+      error(STRING.ERROR.PACKAGEJSONNOTFOUND, false, packageJsonPath2);
+    const packageJson2 = await getJsonFile(packageJsonPath2);
+    if (packageJson2.private === true)
+      error(STRING.ERROR.PUBLISHPRIVATEPACKAGE, false, packageJson2.name);
+    multiRepoInfos.push({
+      repository: repoConfig2,
+      packageJson: packageJson2
+    });
+  }
+  message(messageTypes.INFO, STRING.INFO.CONFIGVALIDATED);
+}
+function increasePatchVersion(version) {
+  const versionParts = version.split(".").map((num) => parseInt(num, 10));
+  versionParts[2] += 1;
+  return versionParts.join(".");
+}
+function handleMultiRepoVersions(packageJson2, field) {
+  const deps = packageJson2[field];
+  if (!deps) return;
+  for (const [depName, depVersion] of Object.entries(deps)) {
+    const matchedRepo = multiRepoInfos.find((repoInfo) => repoInfo.packageJson.name === depName);
+    if (matchedRepo && matchedRepo.newVersion) {
+      deps[depName] = matchedRepo.newVersion;
+      message(
+        messageTypes.INFO,
+        `Updated ${field} "${depName}" = "${depVersion}" >> "${matchedRepo.newVersion}" in package "${packageJson2.name}".`
+      );
+    }
+  }
+}
+async function mutateVersionFiles(info) {
+  const packageJsonPath2 = pathLib.resolve(ensureSlash(info.repository.path), "package.json");
+  const manifestPath = pathLib.resolve(ensureSlash(info.repository.path), "dist/manifest.json");
+  const manifestDistPath = pathLib.resolve(ensureSlash(info.repository.path), "dist/manifest.json");
+  const packageJson2 = info.packageJson;
+  CONSTANTS.DEPENDENCIETYPES.forEach((type) => {
+    handleMultiRepoVersions(packageJson2, type);
+  });
+  await writeFile(packageJsonPath2, JSON.stringify(packageJson2, null, 2) + "\n");
+  message(messageTypes.INFO, STRING.INFO.MUTATEPACKAGEJSON, info.packageJson.name);
+  if (await exists(manifestPath)) await mutateManifestVersion(manifestDistPath, info.newVersion);
+  if (await exists(manifestDistPath))
+    await mutateManifestVersion(manifestDistPath, info.newVersion);
+}
+async function mutateManifestVersion(manifestPath, newVersion) {
+  const manifest = await getJsonFile(manifestPath);
+  manifest.version = newVersion;
+  await writeFile(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+  message(messageTypes.INFO, STRING.INFO.MUTATEMANIFEST, manifest.name);
+}
+async function checkVersion(tag, server, packageInfo) {
+  const npmVersion = await npmComManager.getVersionFromRegistry(multiRepoInfos[0], server, tag) || "none";
+  message(
+    messageTypes.INFO,
+    npmVersion != "none" ? `Latest version in registry for tag "${tag}": ${npmVersion}` : `No Version found for tag ${tag}, taking current package version: ${packageInfo.packageJson.version}`
+  );
+  return increasePatchVersion(npmVersion === "none" ? packageInfo.packageJson.version : npmVersion);
+}
+async function checkReleaseVersion(tag, server, packageInfo) {
+  try {
+    const npmVersion = await npmComManager.getVersionFromRegistry(multiRepoInfos[0], server, tag) || "none";
+    const splitNpmVersion = npmVersion !== "none" ? npmVersion.split(".") : [];
+    const [_, majorVersion, minorVersion] = tag.split("-");
+    if (splitNpmVersion.length > 0 && splitNpmVersion[0] !== majorVersion)
+      return increasePatchVersion(npmVersion);
+    const patchVersion = splitNpmVersion.length > 0 ? parseInt(splitNpmVersion[2], 10) + 1 : 0;
+    const releaseVersion = `${majorVersion}.${minorVersion ?? "0"}.${patchVersion}`;
+    message(
+      messageTypes.INFO,
+      npmVersion !== "none" ? `Latest version in registry for tag "${tag}": ${npmVersion}` : `No Version found for tag ${tag}, taking current tag release version ${releaseVersion}.`
+    );
+    return releaseVersion;
+  } catch (error2) {
+    message(
+      messageTypes.INFO,
+      `Error fetching version from registry: ${error2.message}. Taking current package version: ${packageInfo.packageJson.version}`
+    );
+    return increasePatchVersion(packageInfo.packageJson.version);
+  }
+}
+const publishCommand = new Command("publish").description("Set a new version for a package and publish it.").option("--t, --tag <string>", 'The tag under which the package is published. Example: "master"').option(
+  "--s, --server <string>",
+  'Repository manager URL. Example: "http://nexus.example.com/repository/npm-registry/"'
+).option(
+  "--m, --multirepoconfig <string>",
+  'Path to the multi-repo configuration file. Example: "./elo-cli-multirepo.json"'
+).option(
+  "--d, --delay <number>",
+  "Delay in seconds before checking if the package is published successfully."
+).option("--l, --latest", "Set also the latest tag to the published package.").action(async (options) => {
+  message(messageTypes.INFO, STRING.INFO.STARTPUBLISHCOMMAND);
+  const multiRepoMode = options.multirepoconfig !== void 0;
+  let multiRepoConfigPath = "";
+  let multiRepoConfig = [];
+  if (multiRepoMode) {
+    multiRepoConfigPath = pathLib.resolve(options.multirepoconfig);
+    if (!await exists(multiRepoConfigPath))
+      error(STRING.ERROR.CONFIGFILENOTFOUND, false, multiRepoConfigPath);
+    message(messageTypes.INFO, STRING.INFO.MULTIREPOMODE);
+    multiRepoConfig = await getJsonFile(multiRepoConfigPath);
+    await validateMultiRepoConfig(multiRepoConfig);
+  } else {
+    const packageJsonPath2 = pathLib.resolve("package.json");
+    if (!await exists(packageJsonPath2))
+      error(STRING.ERROR.PACKAGEJSONNOTFOUND, false, packageJsonPath2);
+    const packageJson2 = await getJsonFile(packageJsonPath2);
+    if (packageJson2.private === true)
+      error(STRING.ERROR.PUBLISHPRIVATEPACKAGE, false, packageJson2.name);
+    multiRepoInfos.push({
+      repository: { name: "", path: "./" },
+      packageJson: packageJson2
+    });
+  }
+  try {
+    const repoInfo = multiRepoInfos[0];
+    const version = options.tag.startsWith("release") ? await checkReleaseVersion(options.tag, options.server, repoInfo) : await checkVersion(options.tag, options.server, repoInfo);
+    for (const info of multiRepoInfos) {
+      message(
+        messageTypes.INFO,
+        `Setting new version for package "${info.packageJson.name}": ${version}`
+      );
+      info.newVersion = version;
+      info.packageJson.version = version;
+      await npmComManager.increaseRegistryVersion(info, version);
+    }
+    for (const repoInfo2 of multiRepoInfos) {
+      await mutateVersionFiles(repoInfo2);
+      await npmComManager.publishPackage(repoInfo2, options.tag, options.server);
+      message(messageTypes.INFO, STRING.INFO.PUBLISHSUCCESS, repoInfo2.packageJson.name);
+    }
+    await delay(Number(options.delay));
+    if (options.latest) {
+      for (const repoInfo2 of multiRepoInfos) {
+        await npmComManager.addTag(repoInfo2, "latest", options.server);
+        message(messageTypes.INFO, STRING.INFO.PUBLISHLATESTSUCCESS, repoInfo2.packageJson.name);
+      }
+    }
+    for (const repoInfo2 of multiRepoInfos) {
+      const publishedVersion = await npmComManager.getVersionFromRegistry(
+        repoInfo2,
+        options.server,
+        options.tag
+      );
+      if (publishedVersion !== repoInfo2.newVersion)
+        error(
+          `Published version mismatch for package "${repoInfo2.packageJson.name}": expected ${repoInfo2.newVersion}, got ${publishedVersion}`,
+          false
+        );
+      message(
+        messageTypes.INFO,
+        `Verified published version for package "${repoInfo2.packageJson.name}": ${publishedVersion}`
+      );
+    }
+    message(messageTypes.INFO, STRING.INFO.PUBLISHCOMMANDCOMPLETED);
+  } catch (err) {
+    error(`Publish command failed: ${err.message}`, false);
+  }
+});
+const setupConfig = commands.setup;
+const repoConfig = commands.newrepo;
+function setLookUpObj(settings2, optionConfig) {
+  let lookUpObj;
+  if (optionConfig.intoRoot) {
+    lookUpObj = settings2;
+  } else if (optionConfig.intoObj) {
+    lookUpObj = settings2[optionConfig.intoObj];
+  } else {
+    lookUpObj = settings2.manifest;
+  }
+  return lookUpObj;
+}
+function setOptionValue(value, optionConfig) {
+  if (optionConfig.placeholder === CONSTANTS.PLACEHOLDER.PATH) {
+    value = unixPathSep(String(value));
+  }
+  if (optionConfig.encrypt) {
+    value = encrypt(String(value));
+  }
+  return value;
+}
+function configOutput(settings2, archiveName) {
+  if (archiveName === void 0) {
+    message(messageTypes.INFO, STRING.INFO.WRITINGSETUP, unixPathSep(globalSettingsPath));
+    message(messageTypes.INFO, JSON.stringify(settings2, null, JSON_SPACES));
+  }
+}
+function currentSetupConfig(options) {
+  let config;
+  if (options.repository !== void 0) {
+    if (options.repository == "true") {
+      delete options.repository;
+    }
+    delete repoConfig.options.repository.ignore;
+    config = repoConfig;
+  } else {
+    config = setupConfig;
+  }
+  return config;
+}
+function checkCurrentValue(currentValue, lookUpObj, optionConfig, optionKey) {
+  if (getParameterInObject(lookUpObj, optionKey) && !optionConfig.encrypt) {
+    currentValue = `(${getParameterInObject(lookUpObj, optionKey)}) `;
+  }
+  return currentValue;
+}
+async function processConfigParameter(options, path) {
+  if (options.config && options.repository) {
+    message(messageTypes.INFO, `Read Configuration: ${options.config}`);
+    message(messageTypes.INFO, `Repository: ${options.repository}`);
+    try {
+      const props = await propertiesToObject(options.config);
+      const settings2 = {
+        manifest: {
+          wfUrl: `${props.baseUrl}${props.port ? `:${props.port}` : ""}${props.ixContextPath}/plugin/de.elo.ix.plugin.proxy/wf/`,
+          indexHtml: "index.html",
+          src: "src",
+          dist: "dist",
+          namespace: "",
+          id: "",
+          defaultLanguage: "de"
+        },
+        ixLogin: {
+          adminName: props.username,
+          adminPw: encrypt(props.password)
+        },
+        ixUrl: `${props.baseUrl}${props.port ? `:${props.port}` : ""}${props.ixContextPath}/ix`
+      };
+      await writeSettingsJson(options.repository, path, settings2);
+      await writeFile(".elo-current-repository", options.repository);
+      message(messageTypes.INFO, STRING.INFO.SETUPCOMPLETE);
+      process.exit(0);
+    } catch (err) {
+      error(`Could not read file ${options.config}`, false, err);
+    }
+  }
+}
+const setupCommand = new Command("setup").description("Setup the project").option("--r, --repository <string>", "Create a local repository (for projects)").option("--c, --config <string>", 'Create settings from a ".properties" file').option(
+  "--index_html <string>",
+  "The name of the index.html, for example: index.html (default: index.html)"
+).option(
+  "--src <string>",
+  "The relative path where the source files, like the index.html, are, for example: src/"
+).option(
+  "--dist <string>",
+  "The relative path where the output files, like the index.html, will be, for example: dist/"
+).option("--namespace <string>", "The app namespace, for example: my.example.namespace").option("--default_lang <string>", "The default language, for example: de").option(
+  "--server_url <string>",
+  "Url of the server, for example: http://myServer:9090/ix-Repository/"
+).option("--admin_name <string>", "Name of the ix admin user, for example: Administrator").option(
+  "--admin_pw <string>",
+  "According administrator password. This password will be stored encrypted but the key is not secure and can be read from the current machines hard drive. Only use test installations."
+).action(async (options) => {
+  message(messageTypes.INFO, "Setup CLI");
+  const settings2 = await getGlobalSettingsJson();
+  const path = process.cwd();
+  let optionKey;
+  let optionConfig;
+  let promptValue;
+  let value;
+  let lookUpObj;
+  let currentValue;
+  let archiveName = void 0;
+  if (options.config && options.repository) {
+    await processConfigParameter(options, path);
+  } else {
+    message(messageTypes.INFO, STRING.INFO.SKIP);
+    const config = currentSetupConfig(options);
+    for (optionKey in config.options) {
+      const option = getParameterInObject(config.options, optionKey);
+      if (config.options.hasOwnProperty(optionKey)) {
+        if (option.ignore) {
+          continue;
+        }
+        currentValue = "";
+        if (config.options.hasOwnProperty(optionKey)) {
+          optionConfig = option;
+          lookUpObj = setLookUpObj(settings2, optionConfig);
+          if (options[optionConfig.value]) {
+            value = options[optionConfig.value];
+          } else {
+            currentValue = checkCurrentValue(currentValue, lookUpObj, optionConfig, optionKey);
+            message(messageTypes.INFO, optionConfig.description, optionConfig.eg || "");
+            try {
+              promptValue = await prompts({
+                type: optionConfig.encrypt ? "password" : "text",
+                name: "value",
+                message: optionConfig.value,
+                initial: getParameterInObject(lookUpObj, optionKey) || "",
+                hint: optionConfig.eg || ""
+              });
+              value = promptValue.value;
+            } catch {
+              error(STRING.ERROR.PROMPT, true);
+              message(messageTypes.DEFAULT);
+              message(
+                messageTypes.DEFAULT,
+                "--------------------------------------------------------------"
+              );
+              message(
+                messageTypes.WARN,
+                "Retrying without pw security. Password will be visible here! Abort if you are not alone."
+              );
+              message(
+                messageTypes.DEFAULT,
+                "--------------------------------------------------------------"
+              );
+              message(messageTypes.DEFAULT, optionConfig.description, optionConfig.eg || "");
+              promptValue = await prompts({
+                type: "text",
+                name: "value",
+                message: optionConfig.value
+              });
+              value = promptValue.value;
+            }
+          }
+          if (!isEmpty(value)) {
+            value = setOptionValue(value, optionConfig);
+            if (optionConfig.value === "server_url") {
+              let name = String(value);
+              if (name.endsWith("/ix")) name = name.substring(0, name.length - 3);
+              settings2.ixUrl = `${ensureSlash(name)}ix`;
+              settings2.manifest.wfUrl = `${ensureSlash(name)}plugin/de.elo.ix.plugin.proxy/wf/`;
+            } else if (optionConfig.value === repoConfig.options.repository.value && typeof value === "string") {
+              archiveName = value;
+            } else {
+              lookUpObj = setParameterInObject(lookUpObj, optionKey, value);
+            }
+          }
+        }
+      }
+    }
+    configOutput(settings2, archiveName);
+    await writeSettingsJson(archiveName, path, settings2);
+    message(messageTypes.INFO, STRING.INFO.SETUPCOMPLETE);
+    process.exit(0);
+  }
+});
+const metaFileName = fileURLToPath(import.meta.url);
+const metaDirName = dirname(metaFileName);
+const packageJsonPath = join(metaDirName, "../package.json");
+const packageJson = JSON.parse(readFileSync$1(packageJsonPath, "utf-8"));
+const program = new Command();
+program.name("elo").description(STRING.INIT.INFO).version(packageJson.version);
+program.hook("preAction", (thisCommand, actionCommand) => {
+  message(
+    messageTypes.INFO,
+    `${thisCommand.name()}-cli ${actionCommand.name() || actionCommand.parent?.name()} ${packageJson.version}`
+  );
+});
+program.addCommand(initCommand);
+program.addCommand(setupCommand);
+program.addCommand(buildCommand);
+program.addCommand(deployCommand);
+program.addCommand(importCommand);
+program.addCommand(exportCommand);
+program.addCommand(linkCommand);
+program.addCommand(licenseCommand);
+program.addCommand(localizeCommand);
+program.addCommand(publishCommand);
+program.parse(process.argv);