update description

.gitea/workflows/default_nottags.yaml

@@ -0,0 +1,66 @@
+name: Default (not tags)
+
+on:
+  push:
+    tags-ignore:
+      - '**'
+
+env:
+  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install pnpm and npmci
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+
+      - name: Run npm prepare
+        run: npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build

.gitea/workflows/default_tags.yaml

@@ -0,0 +1,124 @@
+name: Default (tags)
+
+on:
+  push:
+    tags:
+      - '*'
+
+env:
+  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build
+
+  release:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Release
+        run: |
+          npmci node install stable
+          npmci npm publish
+
+  metadata:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Code quality
+        run: |
+          npmci command npm install -g typescript
+          npmci npm install
+
+      - name: Trigger
+        run: npmci trigger
+
+      - name: Build docs and upload artifacts
+        run: |
+          npmci node install stable
+          npmci npm install
+          pnpm install -g @git.zone/tsdoc
+          npmci command tsdoc
+        continue-on-error: true

.gitignore

@@ -1,7 +1,20 @@
-.idea/
+.nogit/
+
+# artifacts
 coverage/
-docs/
-node_modules
-ts/**/*.js
-ts/**/*.js.map
-ts/typings/
+public/
+pages/
+
+# installs
+node_modules/
+
+# caches
+.yarn/
+.cache/
+.rpt2_cache
+
+# builds
+dist/
+dist_*/
+
+# custom

.travis.yml

@@ -1,12 +0,0 @@
-language: node_js
-node_js:
-- '4.3.0'
-- 'stable'
-deploy:
-  provider: npm
-  email: npm@lossless.digital
-  api_key:
-    secure: oKx1gdYYBnaoUcpxn3WM4SdZdInIYaa3ZgbXLSh88K+PjbcSw3NNbYEnAtWFV1eAQQchDjOHId4D1Ne68DtJb5umahvhYoejtZzawjPaa6Uyi46VPk31wXYzZJyadiyefuwOhLLMM4i3yzYwEC2BeTpbU8Tvaj6B42DoySKNGUnSF9+K2wsFNp13mRje6PLe+fjo+9H4CEKLwf74alwvAWd/PLzv47KKdCZ4/9zX7TxevrIBNie+n6VxjqXm/dTv9k7J3dCunojehBr9X9sn1sd8mR+FexjcgfCA2dz8ViP8qZCslzZixGVuasmjpQH9OabrlOfQ6e+Hs4puv+U7s53SVa9nWntiYHloT29UKCPG6ofuDFq5Nd+1PCNvPfrh99F87IKTOw9DQ9Lx7Q//To4LrbnsC85/uHgkWHhbr/ZGax7wuX9og1rem1MSjYr7gQ1sx9edtDSQe3Yjhi22xDREL5/uCbnThmrd1P44CtAU7UG4TQvnHADFqi4Oogf/VBQvsC+aUJPSfZuoxX31yCYuNToH65j1Vblj9tYuPdHSriPj2OdxbuWh68lpgsh7K64Imb++3oKjh3fKZEzeJsByI+QytyUwO/Qu1c6whlkyv8yMyoaD0WARufU+zcG4P7j4rFlAO/CoezSd6l5HBUiXJNe7XniIi6KZjA1zkZc=
-  on:
-    tags: true
-    repo: pushrocks/smartstring

.vscode/launch.json

@@ -0,0 +1,11 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "command": "npm test",
+      "name": "Run npm test",
+      "request": "launch",
+      "type": "node-terminal"
+    }
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,26 @@
+{
+  "json.schemas": [
+    {
+      "fileMatch": ["/npmextra.json"],
+      "schema": {
+        "type": "object",
+        "properties": {
+          "npmci": {
+            "type": "object",
+            "description": "settings for npmci"
+          },
+          "gitzone": {
+            "type": "object",
+            "description": "settings for gitzone",
+            "properties": {
+              "projectType": {
+                "type": "string",
+                "enum": ["website", "element", "service", "npm", "wcc"]
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}

README.md

@@ -1,2 +0,0 @@
-# smartstring
-handle strings in smart ways.

dist/index.d.ts

@@ -1,9 +0,0 @@
-import SmartstringGit = require("./smartstring.git");
-import SmartstringDocker = require("./smartstring.docker");
-import SmartstringTypescript = require("./smartstring.typescript");
-declare let smartstring: {
-    git: (stringArg: string, tokenArg?: string) => SmartstringGit.gitRepo;
-    docker: typeof SmartstringDocker;
-    typescript: typeof SmartstringTypescript;
-};
-export = smartstring;

dist/index.js

@@ -1,13 +0,0 @@
-"use strict";
-/// <reference path="./typings/main.d.ts" />
-var SmartstringGit = require("./smartstring.git");
-var SmartstringDocker = require("./smartstring.docker");
-var SmartstringTypescript = require("./smartstring.typescript");
-var smartstring = {
-    git: SmartstringGit.git,
-    docker: SmartstringDocker,
-    typescript: SmartstringTypescript
-};
-module.exports = smartstring;
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSw0Q0FBNEM7QUFDNUMsSUFBTyxjQUFjLFdBQVcsbUJBQW1CLENBQUMsQ0FBQztBQUNyRCxJQUFPLGlCQUFpQixXQUFXLHNCQUFzQixDQUFDLENBQUM7QUFDM0QsSUFBTyxxQkFBcUIsV0FBVywwQkFBMEIsQ0FBQyxDQUFDO0FBRW5FLElBQUksV0FBVyxHQUFHO0lBQ2QsR0FBRyxFQUFHLGNBQWMsQ0FBQyxHQUFHO0lBQ3hCLE1BQU0sRUFBRSxpQkFBaUI7SUFDekIsVUFBVSxFQUFFLHFCQUFxQjtDQUNwQyxDQUFDO0FBRUYsaUJBQVMsV0FBVyxDQUFDIiwiZmlsZSI6ImluZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOlsiLy8vIDxyZWZlcmVuY2UgcGF0aD1cIi4vdHlwaW5ncy9tYWluLmQudHNcIiAvPlxuaW1wb3J0IFNtYXJ0c3RyaW5nR2l0ID0gcmVxdWlyZShcIi4vc21hcnRzdHJpbmcuZ2l0XCIpO1xuaW1wb3J0IFNtYXJ0c3RyaW5nRG9ja2VyID0gcmVxdWlyZShcIi4vc21hcnRzdHJpbmcuZG9ja2VyXCIpO1xuaW1wb3J0IFNtYXJ0c3RyaW5nVHlwZXNjcmlwdCA9IHJlcXVpcmUoXCIuL3NtYXJ0c3RyaW5nLnR5cGVzY3JpcHRcIik7XG5cbmxldCBzbWFydHN0cmluZyA9IHtcbiAgICBnaXQgOiBTbWFydHN0cmluZ0dpdC5naXQsXG4gICAgZG9ja2VyOiBTbWFydHN0cmluZ0RvY2tlcixcbiAgICB0eXBlc2NyaXB0OiBTbWFydHN0cmluZ1R5cGVzY3JpcHRcbn07XG5cbmV4cG9ydCA9IHNtYXJ0c3RyaW5nOyJdfQ==

dist/smartstring.docker.d.ts

@@ -1,6 +0,0 @@
-/**
- * converts an erray of env strings from docker remote api to an usable object.
- * @param envArrayArg
- * @returns {}
- */
-export declare let makeEnvObject: (envArrayArg: string[]) => {};

dist/smartstring.docker.js

@@ -1,18 +0,0 @@
-"use strict";
-/**
- * converts an erray of env strings from docker remote api to an usable object.
- * @param envArrayArg
- * @returns {}
- */
-exports.makeEnvObject = function (envArrayArg) {
-    var returnObject = {};
-    var regexString = /(.*)=(.*)/;
-    for (var envKey in envArrayArg) {
-        var regexMatches = regexString.exec(envArrayArg[envKey]);
-        returnObject[regexMatches[1]] = regexMatches[2];
-    }
-    ;
-    return returnObject;
-};
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNtYXJ0c3RyaW5nLmRvY2tlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBR0E7Ozs7R0FJRztBQUNRLHFCQUFhLEdBQUcsVUFBUyxXQUFvQjtJQUNwRCxJQUFJLFlBQVksR0FBRyxFQUFFLENBQUM7SUFDdEIsSUFBSSxXQUFXLEdBQUcsV0FBVyxDQUFDO0lBQzlCLEdBQUcsQ0FBQSxDQUFDLElBQUksTUFBTSxJQUFJLFdBQVcsQ0FBQyxDQUFBLENBQUM7UUFDM0IsSUFBSSxZQUFZLEdBQUcsV0FBVyxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQztRQUN6RCxZQUFZLENBQUMsWUFBWSxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsWUFBWSxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ3BELENBQUM7SUFBQSxDQUFDO0lBQ0YsTUFBTSxDQUFDLFlBQVksQ0FBQztBQUN4QixDQUFDLENBQUMiLCJmaWxlIjoic21hcnRzdHJpbmcuZG9ja2VyLmpzIiwic291cmNlc0NvbnRlbnQiOlsiLy8vIDxyZWZlcmVuY2UgcGF0aD1cIi4vdHlwaW5ncy9tYWluLmQudHNcIiAvPlxuaW1wb3J0IHBsdWdpbnMgPSByZXF1aXJlKFwiLi9zbWFydHN0cmluZy5wbHVnaW5zXCIpO1xuXG4vKipcbiAqIGNvbnZlcnRzIGFuIGVycmF5IG9mIGVudiBzdHJpbmdzIGZyb20gZG9ja2VyIHJlbW90ZSBhcGkgdG8gYW4gdXNhYmxlIG9iamVjdC5cbiAqIEBwYXJhbSBlbnZBcnJheUFyZ1xuICogQHJldHVybnMge31cbiAqL1xuZXhwb3J0IGxldCBtYWtlRW52T2JqZWN0ID0gZnVuY3Rpb24oZW52QXJyYXlBcmc6c3RyaW5nW10pe1xuICAgIGxldCByZXR1cm5PYmplY3QgPSB7fTtcbiAgICBsZXQgcmVnZXhTdHJpbmcgPSAvKC4qKT0oLiopLztcbiAgICBmb3IobGV0IGVudktleSBpbiBlbnZBcnJheUFyZyl7XG4gICAgICAgIGxldCByZWdleE1hdGNoZXMgPSByZWdleFN0cmluZy5leGVjKGVudkFycmF5QXJnW2VudktleV0pO1xuICAgICAgICByZXR1cm5PYmplY3RbcmVnZXhNYXRjaGVzWzFdXSA9IHJlZ2V4TWF0Y2hlc1syXTtcbiAgICB9O1xuICAgIHJldHVybiByZXR1cm5PYmplY3Q7XG59OyJdfQ==

dist/smartstring.git.d.ts

@@ -1,10 +0,0 @@
-export declare class gitRepo {
-    host: string;
-    user: string;
-    repo: string;
-    accessToken: string;
-    sshUrl: string;
-    httpsUrl: string;
-    constructor(stringArg: string, tokenArg?: string);
-}
-export declare let git: (stringArg: string, tokenArg?: string) => gitRepo;

dist/smartstring.plugins.d.ts

@@ -1,4 +0,0 @@
-declare let plugins: {
-    beautylog: any;
-};
-export = plugins;

dist/smartstring.plugins.js

@@ -1,8 +0,0 @@
-"use strict";
-/// <reference path="./typings/main.d.ts" />
-var plugins = {
-    beautylog: require("beautylog")
-};
-module.exports = plugins;
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNtYXJ0c3RyaW5nLnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLDRDQUE0QztBQUM1QyxJQUFJLE9BQU8sR0FBRztJQUNWLFNBQVMsRUFBRSxPQUFPLENBQUMsV0FBVyxDQUFDO0NBQ2xDLENBQUM7QUFFRixpQkFBUyxPQUFPLENBQUMiLCJmaWxlIjoic21hcnRzdHJpbmcucGx1Z2lucy5qcyIsInNvdXJjZXNDb250ZW50IjpbIi8vLyA8cmVmZXJlbmNlIHBhdGg9XCIuL3R5cGluZ3MvbWFpbi5kLnRzXCIgLz5cbmxldCBwbHVnaW5zID0ge1xuICAgIGJlYXV0eWxvZzogcmVxdWlyZShcImJlYXV0eWxvZ1wiKVxufTtcblxuZXhwb3J0ID0gcGx1Z2luczsiXX0=

dist/smartstring.typescript.d.ts

@@ -1 +0,0 @@
-export declare let regexReferencePath: RegExp;

dist/smartstring.typescript.js

@@ -1,4 +0,0 @@
-"use strict";
-exports.regexReferencePath = /\/\/\/\s*<reference\s+path\s*=\s*["|'].*["|']\s*\/>\s*[\\n]?/;
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNtYXJ0c3RyaW5nLnR5cGVzY3JpcHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUVXLDBCQUFrQixHQUFHLDhEQUE4RCxDQUFBIiwiZmlsZSI6InNtYXJ0c3RyaW5nLnR5cGVzY3JpcHQuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgcGx1Z2lucyA9IHJlcXVpcmUoXCIuL3NtYXJ0c3RyaW5nLnBsdWdpbnNcIik7XG5cbmV4cG9ydCBsZXQgcmVnZXhSZWZlcmVuY2VQYXRoID0gL1xcL1xcL1xcL1xccyo8cmVmZXJlbmNlXFxzK3BhdGhcXHMqPVxccypbXCJ8J10uKltcInwnXVxccypcXC8+XFxzKltcXFxcbl0/LyJdfQ==

license

@@ -1,6 +1,7 @@
 The MIT License (MIT)
 
-Copyright (c) 2016 Push.Rocks
+Copyright (c) 2014 Maurice Butler
+Copyright (c) 2016 Lossless GmbH
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

npmextra.json

@@ -0,0 +1,39 @@
+{
+  "npmci": {
+    "npmGlobalTools": [],
+    "npmAccessLevel": "public"
+  },
+  "npmdocker": {
+    "baseImage": "hosttoday/ht-docker-node:npmci",
+    "command": "npmci node install stable && npmci npm install && npmci npm test",
+    "dockerSock": false
+  },
+  "gitzone": {
+    "projectType": "npm",
+    "module": {
+      "githost": "code.foss.global",
+      "gitscope": "push.rocks",
+      "gitrepo": "smartstring",
+      "description": "A library for handling strings in smart ways, including manipulation and encoding, with TypeScript support.",
+      "npmPackagename": "@push.rocks/smartstring",
+      "license": "MIT",
+      "keywords": [
+        "string manipulation",
+        "encode",
+        "decode",
+        "base64",
+        "indentation",
+        "normalization",
+        "regex",
+        "random string",
+        "cryptographic string",
+        "domain parsing",
+        "git repository parsing",
+        "docker environment parsing"
+      ]
+    }
+  },
+  "tsdoc": {
+    "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
+  }
+}

package.json

@@ -1,31 +1,70 @@
 {
-  "name": "smartstring",
-  "version": "1.0.3",
-  "description": "bundles a bunch of (regex) matching and altering methods.",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "name": "@push.rocks/smartstring",
+  "version": "4.0.15",
+  "private": false,
+  "description": "A library for handling strings in smart ways, including manipulation and encoding, with TypeScript support.",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
+  "type": "module",
   "scripts": {
-    "test": "(npmts)"
+    "test": "(tstest test/)",
+    "build": "(tsbuild --web --allowimplicitany)",
+    "buildDocs": "tsdoc"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/pushrocks/smartstring.git"
+    "url": "https://code.foss.global/push.rocks/smartstring.git"
   },
   "keywords": [
+    "string manipulation",
+    "encode",
+    "decode",
+    "base64",
+    "indentation",
+    "normalization",
     "regex",
-    "string"
+    "random string",
+    "cryptographic string",
+    "domain parsing",
+    "git repository parsing",
+    "docker environment parsing"
   ],
   "author": "Lossless GmbH",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/pushrocks/smartstring/issues"
+    "url": "https://gitlab.com/push.rocks/smartstring/issues"
   },
-  "homepage": "https://github.com/pushrocks/smartstring#readme",
+  "homepage": "https://code.foss.global/push.rocks/smartstring",
   "devDependencies": {
-    "npmts": "^5.1.4",
-    "should": "^8.3.1"
+    "@git.zone/tsbuild": "^2.1.72",
+    "@git.zone/tsrun": "^1.2.42",
+    "@git.zone/tstest": "^1.0.86",
+    "@push.rocks/tapbundle": "^5.0.15",
+    "@types/node": "^20.11.24"
   },
   "dependencies": {
-    "beautylog": "^4.1.2"
-  }
-}
+    "@push.rocks/isounique": "^1.0.5",
+    "@push.rocks/smartenv": "^5.0.12",
+    "@types/randomatic": "^3.1.5",
+    "crypto-random-string": "^5.0.0",
+    "js-base64": "^3.7.7",
+    "randomatic": "^3.1.1",
+    "strip-indent": "^4.0.0",
+    "url": "^0.11.3"
+  },
+  "files": [
+    "ts/**/*",
+    "ts_web/**/*",
+    "dist/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
+  ]
+}

readme.hints.md

@@ -0,0 +1 @@
+ 

readme.md

@@ -0,0 +1,151 @@
+# @push.rocks/smartstring
+handle strings in smart ways. TypeScript ready.
+
+## Install
+To install `@push.rocks/smartstring`, use the following npm command:
+
+```bash
+npm install @push.rocks/smartstring --save
+```
+
+This will add it to your project's dependencies.
+
+## Usage
+
+The `@push.rocks/smartstring` package provides a powerful set of utilities to handle and manipulate strings in various ways, ready for TypeScript usage. Here's an exhaustive guide to using this package.
+
+### Working with Domain Strings
+
+The `Domain` class helps in parsing and extracting information from domain URLs.
+
+```typescript
+import { Domain } from '@push.rocks/smartstring';
+
+// Parse a domain URL
+const myDomain = new Domain('https://sub.example.com');
+console.log(myDomain.level1); // Output: "com"
+console.log(myDomain.level2); // Output: "example"
+console.log(myDomain.zoneName); // Output: "example.com"
+console.log(myDomain.protocol); // Output: "https"
+```
+
+### Handling Git Repositories
+
+The `GitRepo` class is designed for extracting information from Git repository URLs.
+
+```typescript
+import { GitRepo } from '@push.rocks/smartstring';
+
+// Parse a Git repository URL
+const myGitRepo = new GitRepo('git@github.com:user/repo.git');
+console.log(myGitRepo.host); // Output: "github.com"
+console.log(myGitRepo.user); // Output: "user"
+console.log(myGitRepo.repo); // Output: "repo"
+console.log(myGitRepo.sshUrl); // Output: "git@github.com:user/repo.git"
+console.log(myGitRepo.httpsUrl); // Output: "https://github.com/user/repo.git"
+```
+
+### Encoding and Decoding Base64 Strings
+
+`@push.rocks/smartstring` offers base64 encoding and decoding through the `Base64` class and utility functions.
+
+```typescript
+import { Base64, base64 } from '@push.rocks/smartstring';
+
+// Using the Base64 class
+const myBase64 = new Base64('hello world', 'string');
+console.log(myBase64.base64String); // Encoded string
+console.log(myBase64.base64UriString); // Encoded URI compatible string
+
+// Using utility functions
+const encoded = base64.encode('hello world');
+const decoded = base64.decode(encoded);
+console.log(encoded); // Encoded string
+console.log(decoded); // "hello world"
+```
+
+### Applying Indentation
+
+SmartString allows you to easily indent strings or normalize indentation across a multi-line string.
+
+```typescript
+import { indent } from '@push.rocks/smartstring';
+
+// Indent a string by 4 spaces
+const indentedString = indent.indent('Some text\nAnother line', 4);
+console.log(indentedString);
+
+// Indent using a prefix
+const prefixedString = indent.indentWithPrefix('Line 1\nLine 2', '> ');
+console.log(prefixedString);
+
+// Normalize indentation
+const normalizedString = indent.normalize('    Some indented text\n        Another line');
+console.log(normalizedString);
+```
+
+### Creating Random or Encrypted Strings
+
+Create random strings based on patterns or generate cryptographically strong random strings.
+
+```typescript
+import { create } from '@push.rocks/smartstring';
+
+// Create a random string
+const randomString = create.createRandomString('aA0', 10);
+console.log(randomString); // Example output: "a9mB8v2Dq1"
+
+// Create a crypto-random string
+const cryptoString = create.createCryptoRandomString(10);
+console.log(cryptoString); // Example output: "f28Bb90aCc"
+```
+
+### Normalizing Strings
+
+Normalize strings by removing leading/trailing whitespace, fixing indentation, and more.
+
+```typescript
+import { normalize } from '@push.rocks/smartstring';
+
+// Normalize a multi-line string
+const exampleString = `
+    This is an example.
+        The indentation will be fixed.
+`;
+const normalized = normalize.standard(exampleString);
+console.log(normalized);
+```
+
+### Working with Docker Environment Variables
+
+Transform an array of Docker environment variables into an object for easy access.
+
+```typescript
+import { docker } from '@push.rocks/smartstring';
+
+const envVars = ['NODE_ENV=production', 'PORT=3000'];
+const envObject = docker.makeEnvObject(envVars);
+console.log(envObject.NODE_ENV); // Output: "production"
+console.log(envObject.PORT); // Output: "3000"
+```
+
+This guide covers the primary features of `@push.rocks/smartstring`, making string manipulation and information extraction simple and efficient in your TypeScript projects.
+
+## License and Legal Information
+
+This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. 
+
+**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
+
+### Trademarks
+
+This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.
+
+### Company Information
+
+Task Venture Capital GmbH  
+Registered at District court Bremen HRB 35230 HB, Germany
+
+For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
+
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

test/test.base64.both.ts

@@ -0,0 +1,23 @@
+import * as smartstring from '../ts/index.js';
+import { tap, expect } from '@push.rocks/tapbundle';
+
+// Base64
+let testBase64: smartstring.Base64;
+
+tap.test('expect create a valid instance of Base64', async () => {
+  testBase64 = new smartstring.Base64('somestring', 'string');
+  expect(testBase64).toBeInstanceOf(smartstring.Base64);
+});
+
+tap.test('expect read output a file as base64 and base64uri', async () => {
+  expect(testBase64.base64String).not.toEqual(testBase64.base64UriString);
+  let testBase64_2 = new smartstring.Base64(testBase64.base64UriString, 'base64uri');
+  expect(testBase64_2.simpleString).toEqual(testBase64.simpleString);
+});
+
+tap.test('should test for a valid base64 token', async () => {
+  const result = smartstring.base64.isBase64('dGVzdA==');
+  expect(result).toBeTrue();
+});
+
+tap.start();

test/test.d.ts

@@ -1,2 +0,0 @@
-declare let smartstring: any;
-declare let should: any;

test/test.docker.both.ts

@@ -0,0 +1,12 @@
+import * as smartstring from '../ts/index.js';
+import { tap, expect } from '@push.rocks/tapbundle';
+
+// Docker
+tap.test('expect create a Env Object', async () => {
+  let envStringArray = ['VIRTUAL_HOST=sub.domain.tld', 'DEFAULT_HOST=some.domain.com'];
+  let envObject: any = smartstring.docker.makeEnvObject(envStringArray);
+  expect(envObject.VIRTUAL_HOST).toEqual('sub.domain.tld');
+  expect(envObject.DEFAULT_HOST).toEqual('some.domain.com');
+});
+
+tap.start();

test/test.domain.both.ts

@@ -0,0 +1,37 @@
+import * as smartstring from '../ts/index.js';
+import { tap, expect } from '@push.rocks/tapbundle';
+
+// Domain
+let testDomain: smartstring.Domain;
+let testDomain2: smartstring.Domain;
+tap.test('expect create a new Domain object', async () => {
+  testDomain = new smartstring.Domain('https://level3D.level2D.level1D');
+  expect(testDomain).toBeInstanceOf(smartstring.Domain);
+  console.log(testDomain);
+});
+tap.test('expect have a .topLevel', async () => {
+  expect(testDomain.topLevel).toEqual('level1D');
+});
+tap.test('expect have a .level2', async () => {
+  expect(testDomain.level2).toEqual('level2D');
+});
+tap.test('expect have a .level3', async () => {
+  expect(testDomain.level3).toEqual('level3D');
+});
+tap.test('expect have the correct dns zone name', async () => {
+  expect(testDomain.zoneName).toEqual('level2D.level1D');
+});
+tap.test('expect have the correct protocol', async () => {
+  expect(testDomain.protocol).toEqual('https');
+});
+tap.test('testDomain2 expect be a basic domain', async () => {
+  testDomain2 = new smartstring.Domain('testing.bleu.de');
+  console.log(testDomain2);
+});
+
+tap.test('should parse complex domains', async () => {
+  testDomain2 = new smartstring.Domain('https://sub1.sub2.lossless.com/some/path:5431');
+  console.log(testDomain2);
+});
+
+tap.start();

test/test.git.both.ts

@@ -0,0 +1,26 @@
+import * as smartstring from '../ts/index.js';
+import { tap, expect } from '@push.rocks/tapbundle';
+
+// git
+let testGit: smartstring.GitRepo;
+tap.test('expect create a new Git class GitRepo', async () => {
+  testGit = new smartstring.GitRepo('git+https://github.com/pushrocks/smartstring.git');
+  expect(testGit).toBeInstanceOf(smartstring.GitRepo);
+});
+tap.test('expect return a .host', async () => {
+  expect(testGit.host).toEqual('github.com');
+});
+tap.test('expect return a .user', async () => {
+  expect(testGit.user).toEqual('pushrocks');
+});
+tap.test('expect return a .repo', async () => {
+  expect(testGit.repo).toEqual('smartstring');
+});
+tap.test('expect return a .httpsUrl', async () => {
+  expect(testGit.httpsUrl).toEqual('https://github.com/pushrocks/smartstring.git');
+});
+tap.test('expect return a .sshUrl', async () => {
+  expect(testGit.sshUrl).toEqual('git@github.com:pushrocks/smartstring.git');
+});
+
+tap.start();

test/test.indent.both.ts

@@ -0,0 +1,28 @@
+import * as smartstring from '../ts/index.js';
+import { tap, expect } from '@push.rocks/tapbundle';
+
+// indent
+let testString = `
+base
+    expect be indented
+        some more
+
+base
+    indented
+`;
+
+// normalize
+tap.test('expect normalize a string', async () => {
+  testString = smartstring.indent.normalize(testString);
+  console.log(testString);
+  let zoneNameArg = 'test1';
+  let destinationIpArg = '111';
+});
+
+// indent with prefix
+tap.test('expect indent', async () => {
+  testString = smartstring.indent.indentWithPrefix(testString, '>> ');
+  console.log(testString);
+});
+
+tap.start();

test/test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"test.js","sourceRoot":"","sources":["test.ts"],"names":[],"mappings":"AAAA,gDAAgD;AAChD,IAAI,WAAW,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAC9C,IAAI,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AAE/B,QAAQ,CAAC,aAAa,EAAC;IACnB,QAAQ,CAAC,QAAQ,EAAC;QACd,IAAI,OAAO,GAAG,WAAW,CAAC,GAAG,CAAC,kDAAkD,CAAC,CAAC;QAClF,EAAE,CAAC,uBAAuB,EAAC;YACvB,OAAO,CAAC,IAAI;iBACP,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QACpC,CAAC,CAAC,CAAC;QACH,EAAE,CAAC,uBAAuB,EAAC;YACvB,OAAO,CAAC,IAAI;iBACP,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QACnC,CAAC,CAAC,CAAC;QACH,EAAE,CAAC,uBAAuB,EAAC;YACvB,OAAO,CAAC,IAAI;iBACP,MAAM,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;QACrC,CAAC,CAAC,CAAC;QACH,EAAE,CAAC,2BAA2B,EAAC;YAC3B,OAAO,CAAC,QAAQ;iBACX,MAAM,CAAC,KAAK,CAAC,8CAA8C,CAAC,CAAC;QACtE,CAAC,CAAC,CAAC;QACH,EAAE,CAAC,yBAAyB,EAAC;YACzB,OAAO,CAAC,MAAM;iBACT,MAAM,CAAC,KAAK,CAAC,0CAA0C,CAAC,CAAC;QAClE,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAA;IACF,QAAQ,CAAC,SAAS,EAAC;QACf,QAAQ,CAAC,gBAAgB,EAAC;YACtB,EAAE,CAAC,4BAA4B,EAAC;gBAC5B,IAAI,cAAc,GAAG,CAAC,6BAA6B,EAAC,8BAA8B,CAAC,CAAC;gBACpF,IAAI,SAAS,GAAG,WAAW,CAAC,MAAM,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC;gBACjE,SAAS,CAAC,YAAY,CAAC,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;gBACtD,SAAS,CAAC,YAAY,CAAC,MAAM,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;YAC3D,CAAC,CAAC,CAAA;QACN,CAAC,CAAC,CAAA;IACN,CAAC,CAAC,CAAA;AACN,CAAC,CAAC,CAAC"}

test/test.normalize.both.ts

@@ -0,0 +1,20 @@
+import { tap, expect } from '@push.rocks/tapbundle';
+
+import * as smartstring from '../ts/index.js';
+
+tap.test('should normalize a string', async (toolsArg) => {
+  const testString = `
+    myawesome string;
+      is indented with two spaces
+  `;
+  const normalizedString = smartstring.normalize.standard(testString);
+  console.log(normalizedString);
+  
+  expect(normalizedString).toEqual(
+    `myawesome string;
+  is indented with two spaces
+  `
+  );
+});
+
+tap.start();

test/test.ts

@@ -1,51 +0,0 @@
-/// <reference path="../ts/typings/main.d.ts" />
-let smartstring = require("../dist/index.js");
-let should = require("should");
-
-describe("smartstring",function(){
-    describe(".git()",function(){
-        let testGit = smartstring.git("git+https://github.com/pushrocks/smartstring.git");
-        it("should return a .host",function(){
-            testGit.host
-                .should.equal("github.com");
-        });
-        it("should return a .user",function(){
-            testGit.user
-                .should.equal("pushrocks");
-        });
-        it("should return a .repo",function(){
-            testGit.repo
-                .should.equal("smartstring");
-        });
-        it("should return a .httpsUrl",function(){
-            testGit.httpsUrl
-                .should.equal("https://github.com/pushrocks/smartstring.git");
-        });
-        it("should return a .sshUrl",function(){
-            testGit.sshUrl
-                .should.equal("git@github.com:pushrocks/smartstring.git");
-        });
-    })
-    describe(".docker",function(){
-        describe(".makeEnvObject",function(){
-            it("should create a Env Object",function(){
-                let envStringArray = ["VIRTUAL_HOST=sub.domain.tld","DEFAULT_HOST=some.domain.com"];
-                let envObject = smartstring.docker.makeEnvObject(envStringArray);
-                envObject.VIRTUAL_HOST.should.equal("sub.domain.tld");
-                envObject.DEFAULT_HOST.should.equal("some.domain.com");
-            })
-        })
-    })
-    describe(".typescript",function(){
-        describe(".referenceRegex",function(){
-            it("should match reference paths",function(){
-                smartstring.typescript.regexReferencePath.test("/// <reference path=\"\" />")
-                    .should.be.true();
-                smartstring.typescript.regexReferencePath.test("/// <reference path='' />")
-                    .should.be.true();
-                smartstring.typescript.regexReferencePath.test("/// <referencepath=\"\" />")
-                    .should.be.false();
-            })
-        })
-    })
-});

test/test.type.both.ts

@@ -0,0 +1,14 @@
+import { tap, expect } from '@push.rocks/tapbundle';
+import * as smartstring from '../ts/index.js';
+
+tap.test('should state valuid utf8', async () => {
+  expect(smartstring.type.isUtf8('hithere')).toBeTrue();
+});
+
+tap.test('should state wether base64 string is valid', async () => {
+  const base64String = smartstring.base64.encode('hi there');
+  expect(smartstring.type.isBase64(base64String)).toBeTrue();
+  expect(smartstring.type.isBase64('hi there')).toBeFalse();
+});
+
+tap.start();

ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@push.rocks/smartstring',
+  version: '4.0.15',
+  description: 'handle strings in smart ways. TypeScript ready.'
+}

ts/index.ts

@@ -1,12 +1,11 @@
-/// <reference path="./typings/main.d.ts" />
-import SmartstringGit = require("./smartstring.git");
-import SmartstringDocker = require("./smartstring.docker");
-import SmartstringTypescript = require("./smartstring.typescript");
+import * as create from './smartstring.create.js';
+import * as docker from './smartstring.docker.js';
+import * as indent from './smartstring.indent.js';
+import * as normalize from './smartstring.normalize.js';
+import * as type from './smartstring.type.js';
 
-let smartstring = {
-    git : SmartstringGit.git,
-    docker: SmartstringDocker,
-    typescript: SmartstringTypescript
-};
+export { create, docker, normalize, indent, type };
 
-export = smartstring;
+export { Base64, base64 } from './smartstring.base64.js';
+export { Domain } from './smartstring.domain.js';
+export { GitRepo } from './smartstring.git.js';

ts/smartstring.base64.ts

@@ -0,0 +1,79 @@
+import * as plugins from './smartstring.plugins.js';
+
+/**
+ * the type for base 64
+ */
+export type TStringInputType = 'string' | 'base64' | 'base64uri';
+
+/**
+ * handle base64 strings
+ */
+export class Base64 {
+  private refString: string;
+  constructor(inputStringArg, typeArg: TStringInputType) {
+    switch (typeArg) {
+      case 'string': // easiest case
+        this.refString = inputStringArg;
+        break;
+      case 'base64':
+        this.refString = base64.decode(inputStringArg);
+        break;
+      case 'base64uri':
+        this.refString = base64.decode(inputStringArg);
+    }
+  }
+
+  /**
+   * the simple string (unencoded)
+   */
+  get simpleString() {
+    return this.refString;
+  }
+
+  /**
+   * the base64 encoded version of the original string
+   */
+  get base64String() {
+    return base64.encode(this.refString);
+  }
+
+  /**
+   * the base64uri encoded version of the original string
+   */
+  get base64UriString() {
+    return base64.encodeUri(this.refString);
+  }
+}
+
+export let base64 = {
+  /**
+   * encodes the string
+   */
+  encode: (stringArg: string) => {
+    return plugins.jsBase64.encode(stringArg);
+  },
+
+  /**
+   * encodes a stringArg to base64 uri style
+   */
+  encodeUri: (stringArg: string) => {
+    return plugins.jsBase64.encodeURI(stringArg);
+  },
+
+  /**
+   * decodes a base64 encoded string
+   */
+  decode: (stringArg: string) => {
+    return plugins.jsBase64.decode(stringArg);
+  },
+
+  /**
+   *
+   * @param stringArg
+   * checks wether the string is base64 encoded
+   */
+  isBase64: (stringArg: string) => {
+    const regex = /^([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)?$/;
+    return regex.test(stringArg);
+  },
+};

ts/smartstring.create.ts

@@ -0,0 +1,29 @@
+import * as plugins from './smartstring.plugins.js';
+
+/**
+ * creates a random string
+ *
+ * ```ts
+ * createRandomString('AAAA')
+ * //=> 'AGHR'
+ * ```
+ *
+ * @param patternArg the pattern argument to use, Aa0!* are viable pattern descritors
+ * @param lengthArg  the length of the random string
+ * @param optionsArg options
+ */
+export const createRandomString = (
+  patternArg: string,
+  lengthArg?: number,
+  optionsArg?: any
+): string => {
+  return plugins.randomatic(patternArg, lengthArg, optionsArg);
+};
+
+/**
+ * creates a crytic string in the speicifed length
+ * @param lengthArg the length of the crypto string
+ */
+export const createCryptoRandomString = (): string => {
+  return plugins.isounique.uni();
+};

ts/smartstring.docker.ts

@@ -1,17 +1,18 @@
-/// <reference path="./typings/main.d.ts" />
-import plugins = require("./smartstring.plugins");
+import * as plugins from './smartstring.plugins.js';
 
 /**
  * converts an erray of env strings from docker remote api to an usable object.
  * @param envArrayArg
  * @returns {}
  */
-export let makeEnvObject = function(envArrayArg:string[]){
-    let returnObject = {};
-    let regexString = /(.*)=(.*)/;
-    for(let envKey in envArrayArg){
-        let regexMatches = regexString.exec(envArrayArg[envKey]);
-        returnObject[regexMatches[1]] = regexMatches[2];
-    };
-    return returnObject;
-};
+export const makeEnvObject = function (envArrayArg: string[]) {
+  let returnObject = {};
+  let regexString = /(.*)=(.*)/;
+  if (typeof envArrayArg !== 'undefined') {
+    for (let envKey in envArrayArg) {
+      let regexMatches = regexString.exec(envArrayArg[envKey]);
+      returnObject[regexMatches[1]] = regexMatches[2];
+    }
+  }
+  return returnObject;
+};

ts/smartstring.domain.ts

@@ -0,0 +1,87 @@
+import * as plugins from './smartstring.plugins.js';
+
+export class Domain {
+  public fullName: string;
+  public level1: string;
+  public level2: string;
+  public level3: string;
+  public level4: string;
+  public level5: string;
+  public protocol: string;
+  public zoneName: string;
+  // aliases
+  public topLevel: string;
+  public domainName;
+  public subDomain;
+  public port;
+  public nodeParsedUrl: plugins.url.UrlWithStringQuery;
+  constructor(domainStringArg: string) {
+    // lets do the node standard stuff first
+    this.protocol = this._protocolRegex(domainStringArg);
+    if (!this.protocol) {
+      domainStringArg = `https://${domainStringArg}`;
+    }
+    this.nodeParsedUrl = plugins.url.parse(domainStringArg);
+    this.port = this.nodeParsedUrl.port;
+
+    // lets do the rest after
+    const regexMatches = this._domainRegex(
+      domainStringArg.replace(this.nodeParsedUrl.pathname, '')
+    );
+    this.fullName = '';
+    for (let i = 1; i <= 5; i++) {
+      if (regexMatches[i - 1]) {
+        const localMatch = regexMatches[i - 1];
+        this['level' + i.toString()] = localMatch;
+        if (this.fullName === '') {
+          this.fullName = localMatch;
+        } else {
+          this.fullName = localMatch + '.' + this.fullName;
+        }
+      } else {
+        this['level' + i.toString()] = undefined;
+      }
+    }
+    this.zoneName = this.level2 + '.' + this.level1;
+
+    // aliases
+    this.topLevel = this.level1;
+    this.domainName = this.level2;
+    this.subDomain = this.level3;
+  }
+
+  // helper functions
+
+  /** */
+  private _domainRegex(stringArg: string) {
+    const regexString =
+      /([a-zA-Z0-9\-\_]*)\.{0,1}([a-zA-Z0-9\-\_]*)\.{0,1}([a-zA-Z0-9\-\_]*)\.{0,1}([a-zA-Z0-9\-\_]*)\.{0,1}([a-zA-Z0-9\-\_]*)\.{0,1}$/;
+    const regexMatches = regexString.exec(stringArg);
+    regexMatches.reverse(); //make sure we build the domain from toplevel to subdomain (reversed order)
+    regexMatches.pop(); // pop the last element, which is, since we reversed the Array, the full String of matched elements
+    const regexMatchesFiltered = regexMatches.filter(function (stringArg: string) {
+      return stringArg !== '';
+    });
+    return regexMatchesFiltered;
+  }
+
+  private _protocolRegex(stringArg: string) {
+    const regexString = /^([a-zA-Z0-9]*):\/\//;
+    const regexMatches = regexString.exec(stringArg);
+    if (regexMatches) {
+      return regexMatches[1];
+    } else {
+      return undefined;
+    }
+  }
+
+  private _portRegex(stringArg: string) {
+    const regexString = /^([a-zA-Z0-9]*):\/\//;
+    const regexMatches = regexString.exec(stringArg);
+    if (regexMatches) {
+      return regexMatches[1];
+    } else {
+      return undefined;
+    }
+  }
+}

ts/smartstring.git.ts

@@ -1,61 +1,57 @@
-/// <reference path="./typings/main.d.ts" />
-import plugins = require("./smartstring.plugins");
+import * as plugins from './smartstring.plugins.js';
 
 /* ---------------------------------------------- *
  * ------------------ classes ------------------- *
  * ---------------------------------------------- */
-export class gitRepo {
-    host:string;
-    user:string;
-    repo:string;
-    accessToken:string;
-    sshUrl:string;
-    httpsUrl:string;
-    constructor(stringArg:string,tokenArg?:string){
-        let regexMatches = gitRegex(stringArg);
-        this.host = regexMatches[1];
-        this.user = regexMatches[2];
-        this.repo = regexMatches[3];
-        this.accessToken = tokenArg;
-        this.sshUrl = gitLink(this.host,this.user,this.repo,this.accessToken, "ssh");
-        this.httpsUrl = gitLink(this.host,this.user,this.repo,this.accessToken, "https");
-    };
+export class GitRepo {
+  host: string;
+  user: string;
+  repo: string;
+  accessToken: string;
+  sshUrl: string;
+  httpsUrl: string;
+  constructor(stringArg: string, tokenArg?: string) {
+    let regexMatches = gitRegex(stringArg);
+    this.host = regexMatches[1];
+    this.user = regexMatches[2];
+    this.repo = regexMatches[3];
+    this.accessToken = tokenArg;
+    this.sshUrl = gitLink(this.host, this.user, this.repo, this.accessToken, 'ssh');
+    this.httpsUrl = gitLink(this.host, this.user, this.repo, this.accessToken, 'https');
+  }
 }
 
 /* ---------------------------------------------- *
  * ------------------ helpers ------------------- *
  * ---------------------------------------------- */
-let gitRegex = function(stringArg:string){
-    let regexString = /(?:git\+|git\@|https\:\/\/|)(?:https\:\/\/|)([^\/|\:]*)(?:\/|:)([^\/]+)*(?:\/|:)([^\.]+)/;
-    let regexMatches = regexString.exec(stringArg);
-    return regexMatches;
+const gitRegex = function (stringArg: string) {
+  const regexString =
+    /([a-zA-Z0-9\-_\.]*)(?:\/|\:)([a-zA-Z0-9\-_\.]*)(?:\/)([a-zA-Z0-9\-_\.]*)(?:\.git)/;
+  let regexMatches = regexString.exec(stringArg);
+  return regexMatches;
 };
 
-let gitLink = function(hostArg:string, userArg:string, repoArg:string, tokenArg:string = "", linkTypeArg):string{
-    let returnString;
-    if (tokenArg !== ""){
-        tokenArg = tokenArg + "@"
-    }
-    switch (linkTypeArg) {
-        case "https":
-            returnString =  "https://" +
-                tokenArg + hostArg + "/" + userArg + "/" + repoArg + ".git";
-            break;
-        case "ssh":
-            returnString = "git@" +
-                hostArg + ":" + userArg + "/" + repoArg + ".git";
-            break;
-        default:
-            plugins.beautylog.error("Link Type " + linkTypeArg + " not known");
-            break;
-    }
-    return returnString;
+const gitLink = function (
+  hostArg: string,
+  userArg: string,
+  repoArg: string,
+  tokenArg: string = '',
+  linkTypeArg
+): string {
+  let returnString;
+  if (tokenArg !== '') {
+    tokenArg = tokenArg + '@';
+  }
+  switch (linkTypeArg) {
+    case 'https':
+      returnString = 'https://' + tokenArg + hostArg + '/' + userArg + '/' + repoArg + '.git';
+      break;
+    case 'ssh':
+      returnString = 'git@' + hostArg + ':' + userArg + '/' + repoArg + '.git';
+      break;
+    default:
+      console.error('Link Type ' + linkTypeArg + ' not known');
+      break;
+  }
+  return returnString;
 };
-
-/* ---------------------------------------------- *
- * ------------------ exports ------------------- *
- * ---------------------------------------------- */
-export let git = function(stringArg:string,tokenArg?:string){
-    let localGitRepo = new gitRepo(stringArg,tokenArg);
-    return localGitRepo;
-};

ts/smartstring.indent.ts

@@ -0,0 +1,92 @@
+import * as plugins from './smartstring.plugins.js';
+
+/**
+ * splits a string into an array
+ * @param stringArg
+ */
+const splitStringAtLineBreak = (stringArg: string): string[] => {
+  let resultArray = stringArg.split('\n');
+  return cleanStringArray(resultArray);
+};
+
+/**
+ * joins a string together again
+ * @param stringArrayArg
+ */
+const joinStringWithLineBreaks = (stringArrayArg: string[]): string => {
+  let resultString: string = '';
+  for (let line of stringArrayArg) {
+    resultString = resultString + line + '\n'; // add new line at end
+  }
+  return resultString;
+};
+
+/**
+ * cleans first and last line in case they are empty
+ * @param stringArrayArg
+ */
+const cleanStringArray = (stringArrayArg: string[]): string[] => {
+  let testRegex = /^[\s]*$/;
+  if (testRegex.test(stringArrayArg[0])) {
+    stringArrayArg.shift();
+  }
+  if (testRegex.test(stringArrayArg[stringArrayArg.length - 1])) {
+    stringArrayArg.pop();
+  }
+  return stringArrayArg;
+};
+
+/**
+ * indent an array
+ * @param stringArg
+ * @param spaceAmount
+ */
+export const indent = (stringArg: string, spaceAmount: number): string => {
+  let localStringArray = splitStringAtLineBreak(stringArg);
+  for (let stringArg of localStringArray) {
+    stringArg = ' '.repeat(spaceAmount) + stringArg;
+  }
+  let resultString = joinStringWithLineBreaks(localStringArray);
+  return resultString;
+};
+
+/**
+ * indents a string with prefix
+ * @param stringArg
+ * @param prefixArg
+ */
+export const indentWithPrefix = (stringArg: string, prefixArg: string): string => {
+  let resultString: string;
+  let stringArray = splitStringAtLineBreak(stringArg);
+  let resultArray: string[] = [];
+  for (let stringItem of stringArray) {
+    resultArray.push(prefixArg + stringItem);
+  }
+  resultString = joinStringWithLineBreaks(resultArray);
+  return resultString;
+};
+
+export const normalize = (stringArg: string): string => {
+  let resultString: string;
+  let splitStringArray: string[] = splitStringAtLineBreak(stringArg);
+  let minCommonLeftOffset: number;
+
+  const deIndentRegex = /^(\s*)/;
+  const emptyLineRegex = /^(\s*)$/;
+
+  for (let stringItem of splitStringArray) {
+    let offsetString = deIndentRegex.exec(stringItem)[1];
+    if (
+      (typeof minCommonLeftOffset === 'undefined' || offsetString.length < minCommonLeftOffset) &&
+      !emptyLineRegex.test(stringItem)
+    ) {
+      minCommonLeftOffset = offsetString.length;
+    }
+  }
+  let resultSplitStringArray = [];
+  for (let stringItem of splitStringArray) {
+    resultSplitStringArray.push(stringItem.substr(minCommonLeftOffset));
+  }
+  resultString = joinStringWithLineBreaks(resultSplitStringArray);
+  return resultString;
+};

ts/smartstring.normalize.ts

@@ -0,0 +1,51 @@
+import * as plugins from './smartstring.plugins.js';
+
+/**
+ * replaces all occurences of something in a string
+ * @param stringArg
+ * @param searchPattern
+ * @param replacementString
+ */
+export const replaceAll = (stringArg: string, searchPattern: string, replacementString: string) => {
+  return stringArg.replace(new RegExp(searchPattern, 'g'), replacementString);
+};
+
+export interface INormalizeOptions {
+  stripLeadingTrailingEmptyLines?: boolean;
+  stripAllEmptyLines?: boolean;
+  stripIndent?: boolean;
+  normalizeNewline?: boolean;
+  replaceTabs?: boolean;
+}
+
+/**
+ * Normalizes a string
+ * @param stringArg
+ * @param options
+ */
+export const standard = (stringArg: string, options?: INormalizeOptions): string => {
+  let result = stringArg;
+
+  if (!options || options.stripIndent) {
+    result = plugins.stripIndent(result); // fix indention
+  }
+
+  if (!options || options.normalizeNewline) {
+    result = result.replace(/\r\n/g, '\n'); // fix newlines
+  }
+
+  if (!options || options.replaceTabs) {
+    result = replaceAll(result, '\t/', ' '); // fix tabs
+  }
+
+  if (!options || options.stripLeadingTrailingEmptyLines) {
+    result = result.replace(/^\s*[\r\n]/gm, '').replace(/\s*[\r\n]$/gm, '');
+  }
+
+  if (!options || options.stripAllEmptyLines) {
+    result = result.replace(/^\s*[\r\n]/gm, '');
+  }
+
+  return result;
+};
+

ts/smartstring.plugins.ts

@@ -1,6 +1,17 @@
-/// <reference path="./typings/main.d.ts" />
-let plugins = {
-    beautylog: require("beautylog")
-};
+// node native
+import * as smartenv from '@push.rocks/smartenv';
+const smartenvInstance = new smartenv.Smartenv();
+import * as isounique from '@push.rocks/isounique';
 
-export = plugins;
+export { isounique };
+
+import * as url from 'url';
+export { url };
+
+// third party
+import { Base64 as jsBase64 } from 'js-base64';
+
+import stripIndent from 'strip-indent';
+import randomatic from 'randomatic';
+
+export { jsBase64, stripIndent, randomatic };

ts/smartstring.type.ts

@@ -0,0 +1,108 @@
+import * as plugins from './smartstring.plugins.js';
+import * as base64 from './smartstring.base64.js';
+
+export const isUtf8 = (stringArg: string): boolean => {
+  // Convert string to a Uint8Array. In browsers, this will be a bit more complex
+  // because we need to convert the string to a binary representation first.
+  const encoder = new TextEncoder();
+  const bytes = encoder.encode(stringArg);
+
+  let i = 0;
+  while (i < bytes.length) {
+    if (
+      // ASCII
+      bytes[i] === 0x09 ||
+      bytes[i] === 0x0a ||
+      bytes[i] === 0x0d ||
+      (0x20 <= bytes[i] && bytes[i] <= 0x7e)
+    ) {
+      i += 1;
+      continue;
+    }
+
+    if (
+      // non-overlong 2-byte
+      0xc2 <= bytes[i] &&
+      bytes[i] <= 0xdf &&
+      0x80 <= bytes[i + 1] &&
+      bytes[i + 1] <= 0xbf
+    ) {
+      i += 2;
+      continue;
+    }
+
+    if (
+      // excluding overlongs
+      (bytes[i] === 0xe0 &&
+        0xa0 <= bytes[i + 1] &&
+        bytes[i + 1] <= 0xbf &&
+        0x80 <= bytes[i + 2] &&
+        bytes[i + 2] <= 0xbf) ||
+      // straight 3-byte
+      (((0xe1 <= bytes[i] && bytes[i] <= 0xec) || bytes[i] === 0xee || bytes[i] === 0xef) &&
+        0x80 <= bytes[i + 1] &&
+        bytes[i + 1] <= 0xbf &&
+        0x80 <= bytes[i + 2] &&
+        bytes[i + 2] <= 0xbf) ||
+      // excluding surrogates
+      (bytes[i] === 0xed &&
+        0x80 <= bytes[i + 1] &&
+        bytes[i + 1] <= 0x9f &&
+        0x80 <= bytes[i + 2] &&
+        bytes[i + 2] <= 0xbf)
+    ) {
+      i += 3;
+      continue;
+    }
+
+    if (
+      // planes 1-3
+      (bytes[i] === 0xf0 &&
+        0x90 <= bytes[i + 1] &&
+        bytes[i + 1] <= 0xbf &&
+        0x80 <= bytes[i + 2] &&
+        bytes[i + 2] <= 0xbf &&
+        0x80 <= bytes[i + 3] &&
+        bytes[i + 3] <= 0xbf) ||
+      // planes 4-15
+      (0xf1 <= bytes[i] &&
+        bytes[i] <= 0xf3 &&
+        0x80 <= bytes[i + 1] &&
+        bytes[i + 1] <= 0xbf &&
+        0x80 <= bytes[i + 2] &&
+        bytes[i + 2] <= 0xbf &&
+        0x80 <= bytes[i + 3] &&
+        bytes[i + 3] <= 0xbf) ||
+      // plane 16
+      (bytes[i] === 0xf4 &&
+        0x80 <= bytes[i + 1] &&
+        bytes[i + 1] <= 0x8f &&
+        0x80 <= bytes[i + 2] &&
+        bytes[i + 2] <= 0xbf &&
+        0x80 <= bytes[i + 3] &&
+        bytes[i + 3] <= 0xbf)
+    ) {
+      i += 4;
+      continue;
+    }
+
+    return false;
+  }
+
+  return true;
+};
+
+
+export const isBase64 = (stringArg: string) => {
+  const notBase64 = /[^A-Z0-9+\/=]/i;
+  const len = stringArg.length;
+  if (!len || len % 4 !== 0 || notBase64.test(stringArg)) {
+    return false;
+  }
+  const firstPaddingChar = stringArg.indexOf('=');
+  return (
+    firstPaddingChar === -1 ||
+    firstPaddingChar === len - 1 ||
+    (firstPaddingChar === len - 2 && stringArg[len - 1] === '=')
+  );
+};

ts/smartstring.typescript.ts

@@ -1,3 +0,0 @@
-import plugins = require("./smartstring.plugins");
-
-export let regexReferencePath = /\/\/\/\s*<reference\s+path\s*=\s*["|'].*["|']\s*\/>\s*[\\n]?/

ts/typings.json

@@ -1,7 +0,0 @@
-{
-  "ambientDependencies": {
-    "node": "github:DefinitelyTyped/DefinitelyTyped/node/node.d.ts",
-    "mocha": "github:Bartvds/tsd-deftools/typings/DefinitelyTyped/mocha/mocha.d.ts",
-    "colors": "github:DefinitelyTyped/DefinitelyTyped/colors/colors.d.ts"
-  }
-}

tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "verbatimModuleSyntax": true
+  },
+  "exclude": [
+    "dist_*/**/*.d.ts"
+  ]
+}