42 changed files with 2758 additions and 12504 deletions
--- a/.gitea/workflows/default_nottags.yaml
+++ b/.gitea/workflows/default_nottags.yaml
@ -1,66 +0,0 @@
 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
--- a/.gitea/workflows/default_tags.yaml
+++ b/.gitea/workflows/default_tags.yaml
@ -1,124 +0,0 @@
 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
--- a/.gitignore
+++ b/.gitignore
@ -15,6 +15,8 @@ node_modules/
 # builds
 dist/
-dist_*/
+dist_web/
 dist_serve/
 dist_ts_web/
 # custom
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -0,0 +1,105 @@
 # gitzone ci_default
 image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
 cache:
  paths:
  - .npmci_cache/
  key: "$CI_BUILD_STAGE"
 stages:
 - security
 - test
 - release
 - metadata
 # ====================
 # security stage
 # ====================
 mirror:
  stage: security
  script:
  - npmci git mirror
  tags:
  - docker
  - notpriv
 snyk:
  stage: security
  script:
    - npmci npm prepare
    - npmci command npm install -g snyk
    - npmci command npm install --ignore-scripts
    - npmci command snyk test
  tags:
  - docker
  - notpriv
 # ====================
 # test stage
 # ====================
 testLTS:
  stage: test
  script:
  - npmci npm prepare
  - npmci node install lts
  - npmci npm install
  - npmci npm test
  coverage: /\d+.?\d+?\%\s*coverage/
  tags:
  - docker
  - notpriv
 release:
  stage: release
  script:
  - npmci node install lts
  - npmci npm publish
  only:
  - tags
  tags:
  - docker
  - notpriv
 # ====================
 # metadata stage
 # ====================
 codequality:
  stage: metadata
  allow_failure: true
  script:
    - npmci command npm install -g tslint typescript
    - npmci npm install
    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
  tags:
  - docker
  - priv
 trigger:
  stage: metadata
  script:
  - npmci trigger
  only:
  - tags
  tags:
  - docker
  - notpriv
 pages:
  image: hosttoday/ht-docker-node:npmci
  stage: metadata
  script:
    - npmci command npm install -g @gitzone/tsdoc
    - npmci npm prepare
    - npmci npm install
    - npmci command tsdoc
  tags:
    - docker
    - notpriv
  only:
    - tags
  artifacts:
    expire_in: 1 week
    paths:
    - public
  allow_failure: true
--- a/.snyk
+++ b/.snyk
@ -0,0 +1,4 @@
 # Snyk (https://snyk.io) policy file, patches or ignores known vulnerabilities.
 version: v1.13.1
 ignore: {}
 patch: {}
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@ -1,11 +0,0 @@
 {
  "version": "0.2.0",
  "configurations": [
    {
      "command": "npm test",
      "name": "Run npm test",
      "request": "launch",
      "type": "node-terminal"
    }
  ]
 }
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@ -1,26 +0,0 @@
 {
  "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"]
              }
            }
          }
        }
      }
    }
  ]
 }
--- a/0
+++ b/0
--- a/README.md
+++ b/README.md
@ -0,0 +1,40 @@
 # @pushrocks/smartfile
 smart ways to work with files in nodejs
 ## Availabililty and Links
 * [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/smartfile)
 * [gitlab.com (source)](https://gitlab.com/pushrocks/smartfile)
 * [github.com (source mirror)](https://github.com/pushrocks/smartfile)
 * [docs (typedoc)](https://pushrocks.gitlab.io/smartfile/)
 ## Status for master
 [![build status](https://gitlab.com/pushrocks/smartfile/badges/master/build.svg)](https://gitlab.com/pushrocks/smartfile/commits/master)
 [![coverage report](https://gitlab.com/pushrocks/smartfile/badges/master/coverage.svg)](https://gitlab.com/pushrocks/smartfile/commits/master)
 [![npm downloads per month](https://img.shields.io/npm/dm/@pushrocks/smartfile.svg)](https://www.npmjs.com/package/@pushrocks/smartfile)
 [![Known Vulnerabilities](https://snyk.io/test/npm/@pushrocks/smartfile/badge.svg)](https://snyk.io/test/npm/@pushrocks/smartfile)
 [![TypeScript](https://img.shields.io/badge/TypeScript->=%203.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
 [![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
 [![JavaScript Style Guide](https://img.shields.io/badge/code%20style-prettier-ff69b4.svg)](https://prettier.io/)
 ## Usage
 smartfile is an approach of being one tool to handle files in diverse environments.
 ### Smartfile Sections
 smartfile thinks in sections:
 | section     | description                                                                  |
 | ----------- | ---------------------------------------------------------------------------- |
 | fs          | (object) gets data from fs to somewhere                                      |
 | memory      | gets data from memory to somewhere                                           |
 | remote      | gets data from remote locations to somewhere                                 |
 | interpreter | (object) handles yaml and json                                               |
 | smartfile   | (class) a virtual representation of a file, alternative to vinyl file format |
 For further information read the linked docs at the top of this readme.
 > MIT licensed | **&copy;** [Lossless GmbH](https://lossless.gmbh)
 | By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy.html)
 [![repo-footer](https://pushrocks.gitlab.io/assets/repo-footer.svg)](https://maintainedby.lossless.com)
--- a/changelog.md
+++ b/changelog.md
@ -1,357 +0,0 @@
 # Changelog
 ## 2025-01-29 - 11.2.0 - feat(fs)
 Enhanced copy method with optional replaceTargetDir option for directory replacement
 - Added optional 'replaceTargetDir' option to 'copy' and 'copySync' methods in 'fs.ts'.
 - The 'replaceTargetDir' option allows replacing the target directory if both source and target are directories.
 ## 2025-01-29 - 11.1.9 - fix(fs)
 Fix directory handling in copy and copySync functions
 - Ensured existing directories at destination are removed before copying over them in async copy.
 - Added a similar check and handling for synchronous copySync when destination is a directory.
 ## 2025-01-29 - 11.1.8 - fix(fs)
 Fixed copy and copySync functions to ensure they always overwrite files.
 - Fixed bug in copy function where files were not being overwritten when they already existed at the destination.
 - Fixed bug in copySync function to ensure files are overwritten to match the async function's behavior.
 ## 2025-01-29 - 11.1.7 - fix(fs)
 Refactor copy and copySync functions to simplify return type
 - Changed the return type of fs.copy and fs.copySync from boolean to void.
 - Removed unnecessary promise handling in fs.copy.
 ## 2025-01-29 - 11.1.6 - fix(fs)
 Fix issues with fs file copy functions.
 - Updated dependencies in package.json.
 - Corrected comments for asynchronous and synchronous file copy functions in fs.ts.
 ## 2025-01-07 - 11.1.5 - fix(fs)
 Improve waitForFileToBeReady function to handle directories and file stabilization
 - Enhanced the waitForFileToBeReady to handle directory paths by checking for file existence within directories and waiting for stabilization.
 - Modified the watcher logic to cater to changes when monitoring directories for file appearance.
 - Introduced a helper function to ensure paths exist and another to resolve the first file in directories.
 - Corrected logic for polling and stabilizing files within directories.
 ## 2025-01-07 - 11.1.4 - fix(fs)
 Fix file existence check in waitForFileToBeReady method.
 - Ensured that the directory and file exist before setting up the watcher in waitForFileToBeReady.
 - Changed ensureDirectoryExists to ensureFileExists for correct file path verification.
 - Handled ENOENT errors correctly to retry file existence checks until timeout is reached.
 ## 2025-01-07 - 11.1.3 - fix(fs)
 Fix TypeScript type issue in fs module
 - Corrected a TypeScript type in the fs module's checkFileStability function.
 ## 2025-01-07 - 11.1.2 - fix(fs)
 Fix issues in file stability check and directory existence verification in fs module
 - Removed unused variable 'isFileAvailable' in 'waitForFileToBeReady'.
 - Fixed logic for ensuring the target directory exists before setting up file stability watcher.
 - Refactored directory existence logic into 'ensureDirectoryExists' function.
 ## 2025-01-07 - 11.1.1 - fix(fs)
 Improve waitForFileToBeReady function for file stability detection
 - Enhanced error handling and file stability checks in waitForFileToBeReady function
 - Added timeout feature for file readiness check
 - Improved directory access check before file availability check
 ## 2025-01-07 - 11.1.0 - feat(SmartFile)
 Add rename functionality to SmartFile class
 - Implemented a new method to rename a file within the SmartFile class.
 - The rename method updates the file path and optionally writes the renamed file to the disk.
 ## 2024-12-15 - 11.0.23 - fix(fs)
 Handle errors in toObjectSync method
 - Added error handling in toObjectSync function to capture and provide more informative error messages.
 ## 2024-06-23 - 11.0.22 - fix(core)
 Update dependencies and changelog
 - Updated @push.rocks/smartstream to ^3.0.44
 - Updated glob to ^10.4.2
 - Updated @types/node to ^20.14.8
 ## 2024-06-23 - 11.0.21 - fix(dependencies)
 Update dependencies to latest versions
 - Updated @push.rocks/smartpromise to ^4.0.4
 - Updated @push.rocks/smartstream to ^3.0.44
 - Updated glob to ^10.4.2
 - Updated @types/node to ^20.14.8
 ## 2024-06-07 - 11.0.20 - Changelog
 11.0.20
 ## 2024-06-07 - 11.0.19 - fix(core): update
 11.0.19
 - fix(core): update
 ## 2024-06-07 - 11.0.18 - fix(core): update
 11.0.18
 - fix(core): update
 ## 2024-06-06 - 11.0.17 - fix(core): update
 11.0.17
 - fix(core): update
 ## 2024-06-06 - 11.0.16 - fix(core): update
 11.0.16
 - fix(core): update
 ## 2024-05-29 - 11.0.16 - update description
 11.0.16
 - update description
 ## 2024-05-17 - 11.0.15 - fix(core): update
 11.0.15
 - fix(core): update
 ## 2024-04-14 - 11.0.14 - update tsconfig
 11.0.14
 - update tsconfig
 ## 2024-04-12 - 11.0.13 - fix(core): update
 11.0.13
 - fix(core): update
 ## 2024-04-12 - 11.0.12 - fix(core): update
 11.0.12
 - fix(core): update
 ## 2024-04-12 - 11.0.11 - fix(core): update
 11.0.11
 - fix(core): update
 ## 2024-04-03 - 11.0.10 - fix(core): update
 11.0.10
 - fix(core): update
 ## 2024-04-03 - 11.0.9 - fix(core): update
 11.0.9
 - fix(core): update
 ## 2024-04-02 - 11.0.8 - fix(core): update
 11.0.8
 - fix(core): update
 ## 2024-04-02 - 11.0.7 - fix(core): update
 11.0.7
 - fix(core): update
 ## 2024-04-02 - 11.0.6 - fix(core): update
 11.0.6
 - fix(core): update
 ## 2024-04-01 - 11.0.5 - update npmextra.json
 11.0.5
 - update npmextra.json: githost
 ## 2024-04-01 - 11.0.4 - fix(core): update
 11.0.4
 - fix(core): update
 ## 2023-11-24 - 11.0.3 - fix(core): update
 11.0.3
 - fix(core): update
 ## 2023-11-07 - 11.0.2 - fix(core): update
 11.0.2
 - fix(core): update
 ## 2023-11-07 - 11.0.1 - fix(core): update
 11.0.1
 - fix(core): update
 ## 2023-11-06 - 11.0.0 - fix(core): update
 11.0.0
 - fix(core): update
 ## 2023-11-06 - 10.0.40 - BREAKING CHANGE(core): update
 10.0.40
 - BREAKING CHANGE(core): update
 ## 2023-11-04 - 10.0.39 - fix(core): update
 10.0.39
 - fix(core): update
 ## 2023-11-04 - 10.0.38 - fix(core): update
 10.0.38
 - fix(core): update
 ## 2023-11-04 - 10.0.37 - fix(core): update
 10.0.37
 - fix(core): update
 ## 2023-11-03 - 10.0.36 - fix(core): update
 10.0.36
 - fix(core): update
 ## 2023-11-03 - 10.0.35 - fix(core): update
 10.0.35
 - fix(core): update
 ## 2023-11-03 - 10.0.34 - fix(core): update
 10.0.34
 - fix(core): update
 ## 2023-11-03 - 10.0.33 - fix(core): update
 10.0.33
 - fix(core): update
 ## 2023-10-12 - 10.0.32 - fix(core): update
 10.0.32
 - fix(core): update
 ## 2023-09-22 - 10.0.31 - fix(core): update
 10.0.31
 - fix(core): update
 ## 2023-08-31 - 10.0.30 - fix(core): update
 10.0.30
 - fix(core): update
 ## 2023-08-23 - 10.0.29 - fix(core): update
 10.0.29
 - fix(core): update
 ## 2023-07-12 - 10.0.28 - fix(core): update
 10.0.28
 - fix(core): update
 ## 2023-07-10 - 10.0.27 - fix(core): update
 10.0.27
 - fix(core): update
 ## 2023-07-10 - 10.0.26 - fix(core): update
 10.0.26
 - fix(core): update
 ## 2023-07-08 - 10.0.25 - fix(core): update
 10.0.25
 - fix(core): update
 ## 2023-06-25 - 10.0.24 to 10.0.14 - Series of Fixes
 10.0.24 to 10.0.14
 - Series of fixes in the core module
 ## 2023-01-09 - 10.0.13 to 10.0.6 - Series of Fixes
 10.0.13 to 10.0.6
 - Series of fixes in the core module
 ## 2022-09-05 - 10.0.5 to 10.0.3 - Series of Fixes
 10.0.5 to 10.0.3
 - Series of fixes in the core module
 ## 2022-06-07 - 10.0.2 to 10.0.1 - Series of Fixes
 10.0.2 to 10.0.1
 - Series of fixes in the core module
 ## 2022-06-07 - 9.0.7 - BREAKING CHANGE(core): switch to esm
 9.0.7
 - BREAKING CHANGE(core): switch to esm
 ## 2022-03-11 - 9.0.6 to 9.0.2 - Series of Fixes
 9.0.6 to 9.0.2
 - Series of fixes in the core module
 ## 2021-12-01 - 9.0.1 - fix(core): update
 9.0.1
 - fix(core): update
 ## 2021-12-01 - 9.0.0 - fix(absolute pathing)
 9.0.0
 - add functions for easily getting absolute paths
 ## 2021-11-30 - 8.0.11 - BREAKING CHANGE(relative pathing)
 8.0.11
 - improved relative pathing
 ## 2020-08-10 - 8.0.10 to 7.0.12 - Series of Fixes and Updates
 8.0.10 to 7.0.12
 - Series of fixes in the core module
 - BREAKING CHANGE(Smartfile class): switch to a Buffer-only approach
 ## 2019-02-17 - 7.0.0 - fix(core): update dependencies
 7.0.0
 - fix(core): update dependencies
 ## 2019-01-27 - 6.0.12 - BREAKING CHANGE(smartfile.fs.fileExists)
 6.0.12
 - now returns a Promise<boolean>
 ## 2018-08-19 - 6.0.11 to 6.0.6 - Series of Fixes
 6.0.11 to 6.0.6
 - Series of fixes in core and dependencies
 ## 2018-07-03 - 6.0.5 to 5.0.0 - Series of Fixes
 6.0.5 to 5.0.0
 - Series of fixes in core and dependencies
 ## 2018-02-16 - 4.2.28 - BREAKING CHANGE(scope)
 4.2.28
 - switch to pushrocks scope
--- a/npmextra.json
+++ b/npmextra.json
@ -1,48 +1,21 @@
 {
  "npmts": {
    "mode": "default",
    "coverageTreshold": 70
  },
  "npmdocker": {},
  "npmci": {
    "npmGlobalTools": [],
    "npmAccessLevel": "public"
  },
  "gitzone": {
    "projectType": "npm",
    "module": {
-      "githost": "code.foss.global",
+      "githost": "gitlab.com",
-      "gitscope": "push.rocks",
+      "gitscope": "pushrocks",
      "gitrepo": "smartfile",
-      "description": "Provides comprehensive tools for efficient file management in Node.js using TypeScript, including handling streams, virtual directories, and various file operations.",
+      "shortDescription": "smart ways to work with files in nodejs",
-      "npmPackagename": "@push.rocks/smartfile",
+      "npmPackagename": "@pushrocks/smartfile",
-      "license": "MIT",
+      "license": "MIT"
      "keywords": [
        "file management",
        "TypeScript",
        "Node.js",
        "file operations",
        "file manipulation",
        "file streaming",
        "virtual directory",
        "filesystem utilities",
        "memory-efficient file handling",
        "custom file operations",
        "write files",
        "read files",
        "copy files",
        "delete files",
        "list directories",
        "handle large files",
        "virtual filesystems",
        "buffer operations"
      ]
    }
  },
  "tsdoc": {
    "classes": [
      "SmartFile",
      "StreamFile"
    ],
    "descriptions": [
      "the purpose of the StreamFile class is to provide a hybrid interface between streaming files and simple handling when writing and reading those files multiple times."
    ],
    "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"
  }
 }
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@ -1,84 +1,61 @@
 {
-  "name": "@push.rocks/smartfile",
+  "name": "@pushrocks/smartfile",
  "private": false,
-  "version": "11.2.0",
+  "version": "7.0.4",
-  "description": "Provides comprehensive tools for efficient file management in Node.js using TypeScript, including handling streams, virtual directories, and various file operations.",
+  "description": "offers smart ways to work with files in nodejs",
-  "main": "dist_ts/index.js",
+  "main": "dist/index.js",
-  "typings": "dist_ts/index.d.ts",
+  "typings": "dist/index.d.ts",
  "type": "module",
  "scripts": {
    "test": "(tstest test/)",
-    "build": "(tsbuild --web --allowimplicitany)",
+    "reinstall": "(rm -r node_modules && npm install)",
-    "buildDocs": "tsdoc"
+    "release": "(git pull origin master && npm version patch && git push origin master && git checkout release && git merge master && git push origin release && git checkout master)",
    "update": "(git checkout master && git pull origin master && npm install)",
    "upgrade": "(npm run update) && (ncu upgradeAll && npm install)",
    "build": "(tsbuild)"
  },
  "repository": {
    "type": "git",
-    "url": "https://code.foss.global/push.rocks/smartfile.git"
+    "url": "https://gitlab.com/pushrocks/smartfile.git"
  },
  "keywords": [
-    "file management",
+    "filesystem",
-    "TypeScript",
+    "json"
    "Node.js",
    "file operations",
    "file manipulation",
    "file streaming",
    "virtual directory",
    "filesystem utilities",
    "memory-efficient file handling",
    "custom file operations",
    "write files",
    "read files",
    "copy files",
    "delete files",
    "list directories",
    "handle large files",
    "virtual filesystems",
    "buffer operations"
  ],
-  "author": "Lossless GmbH <hello@lossless.com> (https://lossless.com)",
+  "author": "Smart Coordination GmbH <office@push.rocks> (https://push.rocks)",
  "license": "MIT",
  "bugs": {
-    "url": "https://gitlab.com/push.rocks/smartfile/issues"
+    "url": "https://gitlab.com/pushrocks/smartfile/issues"
  },
-  "homepage": "https://code.foss.global/push.rocks/smartfile",
+  "homepage": "https://gitlab.com/pushrocks/smartfile",
  "dependencies": {
-    "@push.rocks/lik": "^6.1.0",
+    "@pushrocks/smartpath": "^4.0.1",
-    "@push.rocks/smartdelay": "^3.0.5",
+    "@pushrocks/smartpromise": "^3.0.2",
-    "@push.rocks/smartfile-interfaces": "^1.0.7",
+    "@pushrocks/smartrequest": "^1.1.14",
-    "@push.rocks/smarthash": "^3.0.4",
+    "@types/fs-extra": "^5.0.5",
-    "@push.rocks/smartjson": "^5.0.20",
+    "@types/vinyl": "^2.0.2",
-    "@push.rocks/smartmime": "^2.0.4",
+    "fs-extra": "^7.0.1",
-    "@push.rocks/smartpath": "^5.0.18",
+    "glob": "^7.1.3",
-    "@push.rocks/smartpromise": "^4.2.2",
+    "js-yaml": "^3.13.1",
-    "@push.rocks/smartrequest": "^2.0.23",
+    "vinyl-file": "^3.0.0"
    "@push.rocks/smartstream": "^3.2.5",
    "@types/fs-extra": "^11.0.4",
    "@types/glob": "^8.1.0",
    "@types/js-yaml": "^4.0.9",
    "fs-extra": "^11.3.0",
    "glob": "^11.0.1",
    "js-yaml": "^4.1.0"
  },
  "devDependencies": {
-    "@git.zone/tsbuild": "^2.2.1",
+    "@gitzone/tsbuild": "^2.1.8",
-    "@git.zone/tsrun": "^1.3.3",
+    "@gitzone/tsrun": "^1.2.1",
-    "@git.zone/tstest": "^1.0.96",
+    "@gitzone/tstest": "^1.0.18",
-    "@push.rocks/tapbundle": "^5.5.6",
+    "@pushrocks/tapbundle": "^3.0.7",
-    "@types/node": "^22.12.0"
+    "@types/node": "^11.13.0",
    "gulp-function": "^2.2.14",
    "tslint": "^5.15.0",
    "tslint-config-prettier": "^1.18.0"
  },
  "files": [
-    "ts/**/*",
+    "ts/*",
-    "ts_web/**/*",
+    "ts_web/*",
-    "dist/**/*",
+    "dist/*",
-    "dist_*/**/*",
+    "dist_web/*",
-    "dist_ts/**/*",
+    "assets/*",
    "dist_ts_web/**/*",
    "assets/**/*",
    "cli.js",
    "npmextra.json",
    "readme.md"
  ],
  "browserslist": [
    "last 1 chrome versions"
  ]
 }
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/readme.hints.md
+++ b/readme.hints.md
@ -1 +0,0 @@
--- a/readme.md
+++ b/readme.md
@ -1,241 +0,0 @@
 # @push.rocks/smartfile
 > Provides a robust suite of tools for managing files in Node.js using TypeScript.
 ## Install
 To integrate `@push.rocks/smartfile` into your project, run:
 ```bash
 npm install @push.rocks/smartfile
 ```
 ## Usage
 `@push.rocks/smartfile` offers extensive file management utilities, enabling seamless file processing with TypeScript in a Node.js environment. Below are detailed examples showcasing various features of the module.
 ### Quick Start
 First, ensure you're working in an environment that supports ECMAScript modules (ESM) and TypeScript. Here’s how you’d generally import and use `@push.rocks/smartfile`:
 ```typescript
 import { SmartFile, StreamFile, VirtualDirectory, fs, memory, interpreter } from '@push.rocks/smartfile';
 ```
 ### Working with `SmartFile`
 #### Reading Files
 To read from a file and convert it to a `SmartFile` instance:
 ```typescript
 const myJsonSmartFile: SmartFile = await SmartFile.fromFilePath('./somePath/data.json');
 const jsonData = JSON.parse(myJsonSmartFile.contents.toString());
 console.log(jsonData);  // Assuming the file contains JSON content
 ```
 #### Writing Files
 To write data to a file through a `SmartFile`:
 ```typescript
 const filePath: string = './output/outputData.json';
 const content: string = JSON.stringify({ key: 'value' });
 await memory.toFs(content, filePath);
 ```
 ### Streaming Large Files with `StreamFile`
 When dealing with large files, you can use `StreamFile` to handle such files efficiently, minimizing memory usage:
 ```typescript
 const largeFile: StreamFile = await StreamFile.fromPath('./largeInput/largeFile.mp4');
 await largeFile.writeToDisk('./largeOutput/largeFileCopy.mp4');
 ```
 ### Working with Virtual Directories
 Handling multiple files as if they were part of a file system:
 ```typescript
 const virtualDir = await VirtualDirectory.fromFsDirPath('./data/inputDir');
 await virtualDir.saveToDisk('./data/outputDir');
 ```
 ### File System Operations
 `@push.rocks/smartfile` provides a suite of utilities for common file system operations such as copying, deleting, and listing files or directories.
 #### Copying a File
 ```typescript
 await fs.copy('./sourceFile.txt', './destinationFile.txt');
 ```
 #### Deleting a Directory
 ```typescript
 await fs.remove('./directoryToDelete');
 ```
 #### Listing Files in a Directory
 ```typescript
 const fileList: string[] = await fs.listFiles('./someDirectory');
 console.log(fileList);
 ```
 ### Advanced File Management
 For specialized file operations, such as editing the contents of a file or streaming files from URLs, `@push.rocks/smartfile` includes advanced management features.
 #### Editing a File’s Contents
 ```typescript
 const smartFileToEdit: SmartFile = await SmartFile.fromFilePath('./editableFile.txt');
 await smartFileToEdit.editContentAsString(async (content) => content.replace(/originalText/g, 'newText'));
 await smartFileToEdit.write();
 ```
 #### Streaming a File from a URL
 ```typescript
 const streamedFile: StreamFile = await StreamFile.fromUrl('https://example.com/file.pdf');
 await streamedFile.writeToDisk('./downloadedFiles/file.pdf');
 ```
 ### Working with File Buffers and Streams
 `@push.rocks/smartfile` allows you to easily work with files using Buffers and Streams, facilitating operations like file transformations, uploads, and downloads.
 #### Creating a SmartFile from a Buffer
 ```typescript
 const buffer: Buffer = Buffer.from('Sample data');
 const bufferSmartFile: SmartFile = await SmartFile.fromBuffer('./bufferFile.txt', buffer);
 await bufferSmartFile.write();
 ```
 ### Using `VirtualDirectory` for Complex File Management
 `VirtualDirectory` simplifies the management of multiple files that are otherwise scattered across different directories or created at runtime. 
 #### Creating a `VirtualDirectory`
 To create a `VirtualDirectory` from an existing file directory:
 ```typescript
 const virtualDirectory = await VirtualDirectory.fromFsDirPath('./someDirectory');
 ```
 #### Adding More Files
 You can add more `SmartFile` instances to your `VirtualDirectory`:
 ```typescript
 const additionalFiles = [
  await SmartFile.fromFilePath('./anotherDirectory/file1.txt'),
  await SmartFile.fromFilePath('./anotherDirectory/file2.txt')
 ];
 virtualDirectory.addSmartfiles(additionalFiles);
 ```
 #### Saving `VirtualDirectory` to Disk
 Save your entire `VirtualDirectory` to disk:
 ```typescript
 await virtualDirectory.saveToDisk('./outputDirectory');
 ```
 ### Utilizing StreamFile for Efficient File Handling
 Using `StreamFile` can be especially beneficial for large files or when performing streaming operations.
 #### Streaming from a URL
 `StreamFile` provides capabilities to stream files directly from URLs, making it easier to work with remote content.
 ```typescript
 const urlStreamFile: StreamFile = await StreamFile.fromUrl('https://example.com/largefile.zip');
 await urlStreamFile.writeToDisk('./downloadedFiles/largefile.zip');
 ```
 ### Combining Buffer and Stream Approaches
 Create `StreamFile` from a buffer for efficient, multi-use streams.
 ```typescript
 const buffer = Buffer.from('Streaming buffer content');
 const bufferStreamFile = StreamFile.fromBuffer(buffer, 'bufferBasedStream.txt');
 await bufferStreamFile.writeToDisk('./streams/bufferBasedStream.txt');
 ```
 ### Read and Write Operations with StreamFile
 Perform read and write operations efficiently using `StreamFile`.
 ```typescript
 const fileStream = await StreamFile.fromPath('./inputData/largeFile.data');
 await fileStream.writeToDisk('./outputData/largeFileCopy.data');
 ```
 Check for completeness of your read and write operations, ensuring the integrity of file content.
 ```typescript
 const readBuffer = await fileStream.getContentAsBuffer();
 console.log(readBuffer.toString());
 ```
 ### Ensuring File Readiness for Streaming
 Ensure a file is ready for streaming or create a custom readable stream incorporating data transformation.
 ```typescript
 const smartReadStream = new SmartReadStream('./incomingData/sample.data');
 smartReadStream.on('data', (chunk) => {
  console.log('New Data Chunk:', chunk.toString());
 });
 ```
 ### File Transformation with SmartReadStream
 Perform transformations on the stream of data while reading:
 ```typescript
 smartReadStream.on('data', (chunk) => {
  // Perform some transformation
  const transformedChunk = chunk.toString().toUpperCase();
  console.log('Transformed Data Chunk:', transformedChunk);
 });
 ```
 ### Streaming with SmartReadStream
 Stream data from a `SmartReadStream` to a file efficiently managing large datasets.
 ```typescript
 const transformedWriteStream = fs.createWriteStream('./processedData/transformed.data');
 smartReadStream.pipe(transformedWriteStream);
 ```
 `@push.rocks/smartfile` significantly simplifies the handling of complex file operations in Node.js projects, making these tasks straightforward while maintaining efficiency and ease of use. Explore and leverage these features to enhance your project's file management capabilities.
 ## 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.
--- a/test/test.streamfile.ts
+++ b/test/test.streamfile.ts
@ -1,67 +0,0 @@
 import * as path from 'path';
 import { expect, tap } from '@push.rocks/tapbundle';
 import * as smartfile from '../ts/index.js'; // adjust the import path as needed
 // Test assets path
 const testAssetsPath = './test/testassets/';
 // ---------------------------
 // StreamFile tests
 // ---------------------------
 tap.test('StreamFile.fromPath should create a StreamFile from a file path', async () => {
  const streamFile = await smartfile.StreamFile.fromPath(path.join(testAssetsPath, 'mytest.json'));
  expect(streamFile).toBeInstanceOf(smartfile.StreamFile);
  const contentBuffer = await streamFile.getContentAsBuffer();
  expect(contentBuffer).toBeInstanceOf(Buffer);
 });
 tap.test('StreamFile.fromUrl should create a StreamFile from a URL', async () => {
  const streamFile = await smartfile.StreamFile.fromUrl('http://example.com/somefile.json');
  expect(streamFile).toBeInstanceOf(smartfile.StreamFile);
 });
 tap.test('StreamFile.fromBuffer should create a StreamFile from a Buffer', async () => {
  const buffer = Buffer.from('Some content');
  const streamFile = smartfile.StreamFile.fromBuffer(buffer, 'bufferfile.txt');
  expect(streamFile).toBeInstanceOf(smartfile.StreamFile);
 });
 tap.test('StreamFile should write the stream to disk', async () => {
  const streamFile = await smartfile.StreamFile.fromPath(path.join(testAssetsPath, 'mytest.json'));
  await streamFile.writeToDisk(path.join(testAssetsPath, 'temp', 'mytest.json'));
  // Verify the file was written
  expect(
    // We'll use the fileExists method from your smartfile library
    // Replace with the actual method you use to check file existence
    await smartfile.fs.fileExists(path.join(testAssetsPath, 'temp', 'mytest.json'))
  ).toBeTrue();
 });
 tap.test('StreamFile should write to a directory', async () => {
  const streamFile = await smartfile.StreamFile.fromPath(path.join(testAssetsPath, 'mytest.json'));
  await streamFile.writeToDir(path.join(testAssetsPath, 'temp'));
  // Verify the file was written
  expect(
    await smartfile.fs.fileExists(path.join(testAssetsPath, 'temp', 'mytest.json'))
  ).toBeTrue();
 });
 tap.test('StreamFile should return content as a buffer', async () => {
  const streamFile = await smartfile.StreamFile.fromPath(path.join(testAssetsPath, 'mytest.json'));
  const contentBuffer = await streamFile.getContentAsBuffer();
  expect(contentBuffer).toBeInstanceOf(Buffer);
  // Further checks on the content can be added here if necessary
 });
 tap.test('StreamFile should return content as a string', async () => {
  const streamFile = await smartfile.StreamFile.fromPath(path.join(testAssetsPath, 'mytest.json'));
  const contentString = await streamFile.getContentAsString();
  expect(typeof contentString).toBeTypeofString();
  // Verify the content matches what's expected
  // This assumes the file contains a JSON object with a key 'key1' with value 'this works'
  expect(JSON.parse(contentString).key1).toEqual('this works');
 });
 // Start the test sequence
 tap.start();
--- a/test/test.ts
+++ b/test/test.ts
@ -1,71 +1,61 @@
-import * as smartfile from '../ts/index.js';
+import * as smartfile from '../ts/index';
-import * as path from 'path';
+import path = require('path');
-import { expect, tap } from '@push.rocks/tapbundle';
+import { expect, tap } from '@pushrocks/tapbundle';
 // ---------------------------
 // smartfile.fs
 // ---------------------------
 tap.test('.fs.fileExistsSync -> should return an accurate boolean', async () => {
-  // tslint:disable-next-line: no-unused-expression
+  expect(smartfile.fs.fileExistsSync('./test/testassets/mytest.json')).to.be.true;
-  expect(smartfile.fs.fileExistsSync('./test/testassets/mytest.json')).toBeTrue();
+  expect(smartfile.fs.fileExistsSync('./test/testassets/notthere.json')).be.false;
  // tslint:disable-next-line: no-unused-expression
  expect(smartfile.fs.fileExistsSync('./test/testassets/notthere.json')).toBeFalse();
 });
 tap.test('.fs.fileExists -> should resolve or reject a promise', async () => {
-  expect(smartfile.fs.fileExists('./test/testassets/mytest.json')).toBeInstanceOf(Promise);
+  expect(smartfile.fs.fileExists('./test/testassets/mytest.json')).to.be.instanceof(Promise);
  await smartfile.fs.fileExists('./test/testassets/mytest.json');
-  await smartfile.fs.fileExists('./test/testassets/notthere.json').catch((err) => {
+  await smartfile.fs.fileExists('./test/testassets/notthere.json').catch(err => {
-    return expect(err.message).toEqual(
+    return expect(err.message).to.equal(
      "ENOENT: no such file or directory, access './test/testassets/notthere.json'"
    );
  });
 });
 tap.test('.fs.listFoldersSync() -> should get the file type from a string', async () => {
-  expect(smartfile.fs.listFoldersSync('./test/testassets/')).toContain('testfolder');
+  expect(smartfile.fs.listFoldersSync('./test/testassets/')).to.include('testfolder');
-  expect(smartfile.fs.listFoldersSync('./test/testassets/')).not.toContain('notExistentFolder');
+  expect(smartfile.fs.listFoldersSync('./test/testassets/')).to.not.include('notExistentFolder');
 });
 tap.test('.fs.listFolders() -> should get the file type from a string', async () => {
-  const folderArrayArg = await smartfile.fs.listFolders('./test/testassets/');
+  let folderArrayArg = await smartfile.fs.listFolders('./test/testassets/');
-  expect(folderArrayArg).toContain('testfolder');
+  expect(folderArrayArg).to.include('testfolder');
-  expect(folderArrayArg).not.toContain('notExistentFolder');
+  expect(folderArrayArg).to.not.include('notExistentFolder');
 });
 tap.test('.fs.listFilesSync() -> should get the file type from a string', async () => {
-  expect(smartfile.fs.listFilesSync('./test/testassets/')).toContain('mytest.json');
+  expect(smartfile.fs.listFilesSync('./test/testassets/')).to.include('mytest.json');
-  expect(smartfile.fs.listFilesSync('./test/testassets/')).not.toContain('notExistentFile');
+  expect(smartfile.fs.listFilesSync('./test/testassets/')).to.not.include('notExistentFile');
-  expect(smartfile.fs.listFilesSync('./test/testassets/', /mytest\.json/)).toContain('mytest.json');
+  expect(smartfile.fs.listFilesSync('./test/testassets/', /mytest\.json/)).to.include('mytest.json');
-  expect(smartfile.fs.listFilesSync('./test/testassets/', /mytests.json/)).not.toContain(
+  expect(smartfile.fs.listFilesSync('./test/testassets/', /mytests.json/)).to.not.include('mytest.json');
    'mytest.json'
  );
 });
 tap.test('.fs.listFiles() -> should get the file type from a string', async () => {
-  const folderArrayArg = await smartfile.fs.listFiles('./test/testassets/');
+  let folderArrayArg = await smartfile.fs.listFiles('./test/testassets/');
-  expect(folderArrayArg).toContain('mytest.json');
+  expect(folderArrayArg).to.include('mytest.json');
-  expect(folderArrayArg).not.toContain('notExistentFile');
+  expect(folderArrayArg).to.not.include('notExistentFile');
 });
 tap.test('.fs.listFileTree() -> should get a file tree', async () => {
-  const folderArrayArg = await smartfile.fs.listFileTree(
+  let folderArrayArg = await smartfile.fs.listFileTree(path.resolve('./test/testassets/'), '**/*.txt');
-    path.resolve('./test/testassets/'),
+  expect(folderArrayArg).to.include('testfolder/testfile1.txt');
-    '**/*.txt'
+  expect(folderArrayArg).to.not.include('mytest.json');
  );
  expect(folderArrayArg).toContain('testfolder/testfile1.txt');
  expect(folderArrayArg).not.toContain('mytest.json');
 });
 tap.test('.fs.fileTreeToObject -> should read a file tree into an Object', async () => {
-  const fileArrayArg = await smartfile.fs.fileTreeToObject(
+  let fileArrayArg = await smartfile.fs.fileTreeToObject(path.resolve('./test/testassets/'), '**/*.txt');
-    path.resolve('./test/testassets/'),
+  expect(fileArrayArg[0]).to.be.instanceof(smartfile.Smartfile);
-    '**/*.txt'
+  expect(fileArrayArg[0].contents.toString()).to.equal(fileArrayArg[0].contentBuffer.toString());
  );
  expect(fileArrayArg[0]).toBeInstanceOf(smartfile.SmartFile);
  expect(fileArrayArg[0].contents.toString()).toEqual(fileArrayArg[0].contentBuffer.toString());
 });
 tap.test('.fs.copy() -> should copy a directory', async () => {
@ -77,10 +67,7 @@ tap.test('.fs.copy() -> should copy a file', async () => {
 });
 tap.test('.fs.copy() -> should copy a file and rename it', async () => {
-  await smartfile.fs.copy(
+  await smartfile.fs.copy('./test/testassets/mytest.yaml', './test/testassets/temp/mytestRenamed.yaml');
    './test/testassets/mytest.yaml',
    './test/testassets/temp/mytestRenamed.yaml'
  );
 });
 tap.test('.fs.remove() -> should remove an entire directory', async () => {});
@ -91,47 +78,42 @@ tap.test('.fs.remove -> should remove single files', async () => {
 tap.test('.fs.removeSync -> should remove single files synchronouly', async () => {
  smartfile.fs.removeSync('./test/testassets/temp/testfile1.txt');
-  expect(smartfile.fs.fileExistsSync('./test/testassets/temp/testfile1.txt')).toBeFalse();
+  expect(smartfile.fs.fileExistsSync('./test/testassets/temp/testfile1.txt')).to.be.false;
 });
 tap.test('.fs.removeMany -> should remove and array of files', async () => {
-  smartfile.fs
+  smartfile.fs.removeMany(['./test/testassets/temp/testfile1.txt', './test/testassets/temp/testfile2.txt']).then(() => {
-    .removeMany(['./test/testassets/temp/testfile1.txt', './test/testassets/temp/testfile2.txt'])
+    expect(smartfile.fs.fileExistsSync('./test/testassets/temp/testfile1.txt')).to.be.false;
-    .then(() => {
+    expect(smartfile.fs.fileExistsSync('./test/testassets/temp/testfile2.txt')).to.be.false;
-      expect(smartfile.fs.fileExistsSync('./test/testassets/temp/testfile1.txt')).toBeFalse();
+  });
      expect(smartfile.fs.fileExistsSync('./test/testassets/temp/testfile2.txt')).toBeFalse();
    });
 });
 tap.test('.fs.removeManySync -> should remove and array of single files synchronouly', async () => {
-  smartfile.fs.removeManySync([
+  smartfile.fs.removeManySync(['./test/testassets/temp/testfile1.txt', './test/testassets/temp/testfile2.txt']);
-    './test/testassets/temp/testfile1.txt',
+  expect(smartfile.fs.fileExistsSync('./test/testassets/temp/testfile1.txt')).to.be.false;
-    './test/testassets/temp/testfile2.txt',
+  expect(smartfile.fs.fileExistsSync('./test/testassets/temp/testfile2.txt')).to.be.false;
  ]);
  expect(smartfile.fs.fileExistsSync('./test/testassets/temp/testfile1.txt')).toBeFalse();
  expect(smartfile.fs.fileExistsSync('./test/testassets/temp/testfile2.txt')).toBeFalse();
 });
-tap.test('.fs.toObjectSync() -> should read an .yaml file to an object', async () => {
+tap.test('.fs.toObjectSync() -> should read an ' + '.yaml' + ' file to an object', async () => {
-  const testData = smartfile.fs.toObjectSync('./test/testassets/mytest.yaml');
+  let testData = smartfile.fs.toObjectSync('./test/testassets/mytest.yaml');
-  expect(testData.key1).toEqual('this works');
+  expect(testData).to.include({ key1: 'this works' });
-  expect(testData.key2).toEqual('this works too');
+  expect(testData).to.include({ key2: 'this works too' });
 });
 tap.test(
  '.fs.toObjectSync() -> should state unknown file type for unknown file types',
  async () => {
-    const testData = smartfile.fs.toObjectSync('./test/testassets/mytest.txt');
+    let testData = smartfile.fs.toObjectSync('./test/testassets/mytest.txt');
  }
 );
-tap.test('.fs.toObjectSync() -> should read an .json file to an object', async () => {
+tap.test('.fs.toObjectSync() -> should read an ' + '.json' + ' file to an object', async () => {
-  const testData = smartfile.fs.toObjectSync('./test/testassets/mytest.json');
+  let testData = smartfile.fs.toObjectSync('./test/testassets/mytest.json');
-  expect(testData.key1).toEqual('this works');
+  expect(testData).to.include({ key1: 'this works' });
-  expect(testData.key2).toEqual('this works too');
+  expect(testData).to.include({ key2: 'this works too' });
 });
 tap.test('.fs.toStringSync() -> should read a file to a string', async () => {
-  expect(smartfile.fs.toStringSync('./test/testassets/mytest.txt')).toEqual('Some TestString &&%$');
+  expect(smartfile.fs.toStringSync('./test/testassets/mytest.txt')).to.equal('Some TestString &&%$');
 });
 // ---------------------------
@ -139,7 +121,7 @@ tap.test('.fs.toStringSync() -> should read a file to a string', async () => {
 // ---------------------------
 tap.test('.interpreter.filetype() -> should get the file type from a string', async () => {
-  expect(smartfile.interpreter.filetype('./somefolder/data.json')).toEqual('json');
+  expect(smartfile.interpreter.filetype('./somefolder/data.json')).equal('json');
 });
 // ---------------------------
@ -147,17 +129,14 @@ tap.test('.interpreter.filetype() -> should get the file type from a string', as
 // ---------------------------
 tap.test('.memory.toFs() -> should write a file to disk and return a promise', async () => {
-  const localString = 'myString';
+  let localString = 'myString';
-  await smartfile.memory.toFs(
+  await smartfile.memory.toFs(localString, path.join(process.cwd(), './test/testassets/temp/testMemToFs.txt'));
    localString,
    path.join(process.cwd(), './test/testassets/temp/testMemToFs.txt')
  );
 });
 tap.test(
  '.memory.toFsSync() -> should write a file to disk and return true if successfull',
  async () => {
-    const localString = 'myString';
+    let localString = 'myString';
    smartfile.memory.toFsSync(
      localString,
      path.join(process.cwd(), './test/testassets/temp/testMemToFsSync.txt')
@ -165,33 +144,45 @@ tap.test(
  }
 );
 tap.test('.remote.toString() -> should load a remote file to a variable', async () => {
  const responseString = await smartfile.remote.toString(
    'https://raw.githubusercontent.com/pushrocks/smartfile/master/test/testassets/mytest.txt'
  );
  expect(responseString).to.equal('Some TestString &&%$');
 });
 tap.test('.remote.toString() -> should reject a Promise when the link is false', async tools => {
  await smartfile.remote.toString('https://push.rocks/doesnotexist.txt').catch(err => {
    return expect(err.message).to.equal(
      'could not get remote file from https://push.rocks/doesnotexist.txt'
    );
  });
 });
 // ---------------------------
 // smartfile.Smartfile
 // ---------------------------
 tap.test('.Smartfile -> should produce vinyl compatible files', async () => {
-  const smartfileArray = await smartfile.fs.fileTreeToObject(
+  let smartfileArray = await smartfile.fs.fileTreeToObject(process.cwd(), './test/testassets/testfolder/**/*');
-    process.cwd(),
+  let localSmartfile = smartfileArray[0];
-    './test/testassets/testfolder/**/*'
+  expect(localSmartfile).to.be.instanceof(smartfile.Smartfile);
-  );
+  expect(localSmartfile.contents).to.be.instanceof(Buffer);
  const localSmartfile = smartfileArray[0];
  expect(localSmartfile).toBeInstanceOf(smartfile.SmartFile);
  expect(localSmartfile.contents).toBeInstanceOf(Buffer);
  // tslint:disable-next-line:no-unused-expression
-  expect(localSmartfile.isBuffer()).toBeTrue();
+  expect(localSmartfile.isBuffer()).to.be.true;
  // tslint:disable-next-line:no-unused-expression
-  expect(localSmartfile.isDirectory()).toBeFalse();
+  expect(localSmartfile.isDirectory()).to.be.false;
  // tslint:disable-next-line:no-unused-expression
-  expect(localSmartfile.isNull()).toBeFalse();
+  expect(localSmartfile.isNull()).to.be.false;
 });
 tap.test('should output a smartfile array to disk', async () => {
-  const smartfileArray = await smartfile.fs.fileTreeToObject('./test/testassets/testfolder/', '*');
+  let smartfileArray = await smartfile.fs.fileTreeToObject('./test/testassets/testfolder/', '*');
-  for (const smartfileInstance of smartfileArray) {
+  for (let smartfile of smartfileArray) {
-    console.log(smartfileInstance.relative);
+    console.log(smartfile.relative);
-    console.log(smartfileInstance.path);
+    console.log(smartfile.path);
-    console.log(smartfileInstance.base);
+    console.log(smartfile.base);
-    console.log(smartfileInstance.parsedPath);
+    console.log(smartfile.parsedPath);
  }
  await smartfile.memory.smartfileArrayToFs(
    smartfileArray,
@ -199,26 +190,4 @@ tap.test('should output a smartfile array to disk', async () => {
  );
 });
 tap.test('should create, store and retrieve valid smartfiles', async () => {
  const fileString = 'hi there';
  const filePath = './test/testassets/utf8.txt';
  const smartfileInstance = await smartfile.SmartFile.fromString(filePath, fileString, 'utf8');
  smartfileInstance.write();
  const smartfileInstance2 = await smartfile.SmartFile.fromFilePath(filePath);
  const retrievedString = smartfileInstance.contents.toString();
  expect(retrievedString).toEqual(fileString);
 });
 tap.test('should get a hash', async () => {
  const fileString = 'hi there';
  const filePath = './test/testassets/utf8.txt';
  const smartfileInstance = await smartfile.SmartFile.fromString(filePath, fileString, 'utf8');
  const hash = await smartfileInstance.getHash();
  console.log(hash);
 });
 tap.test('should wait for file to be ready', async () => {
  await smartfile.fs.waitForFileToBeReady('./test/testassets/mytest.json');
 });
 tap.start();
--- a/test/test.virtualdirectory.ts
+++ b/test/test.virtualdirectory.ts
@ -1,15 +0,0 @@
 import { tap, expect } from '@push.rocks/tapbundle';
 import * as smartfile from '../ts/index.js';
 tap.test('should create a virtualdirectory', async () => {
  const virtualDir = await smartfile.VirtualDirectory.fromFsDirPath('./test/testassets/testfolder');
  expect(virtualDir.smartfileArray.length).toEqual(4);
 });
 tap.test('should write to a directory', async () => {
  const virtualDir = await smartfile.VirtualDirectory.fromFsDirPath('./test/testassets/testfolder');
  virtualDir.saveToDisk('./test/testassets/test');
 });
 tap.start();
--- a/test/testassets/temp/mytest.json
+++ b/test/testassets/temp/mytest.json
@ -1,8 +0,0 @@
 {
  "key1": "this works",
  "key2": "this works too",
  "key3": {
    "nestedkey1": "hello"
  }
 }
--- a/test/testassets/temp/test/testassets/mytest.json
+++ b/test/testassets/temp/test/testassets/mytest.json
@ -1,8 +0,0 @@
 {
  "key1": "this works",
  "key2": "this works too",
  "key3": {
    "nestedkey1": "hello"
  }
 }
--- a/test/testassets/test/subfolder/deepsubfolder/deepsubtestfile.txt
+++ b/test/testassets/test/subfolder/deepsubfolder/deepsubtestfile.txt
@ -1 +0,0 @@
 okidoks
--- a/test/testassets/test/subfolder/subtestfile.txt
+++ b/test/testassets/test/subfolder/subtestfile.txt
@ -1 +0,0 @@
 hi
--- a/test/testassets/test/testfile1.txt
+++ b/test/testassets/test/testfile1.txt
--- a/test/testassets/test/testfile2.txt
+++ b/test/testassets/test/testfile2.txt
--- a/test/testassets/utf8.txt
+++ b/test/testassets/utf8.txt
@ -1 +0,0 @@
 hi there
--- a/ts/00_commitinfo_data.ts
+++ b/ts/00_commitinfo_data.ts
@ -1,8 +0,0 @@
 /**
 * autocreated commitinfo by @push.rocks/commitinfo
 */
 export const commitinfo = {
  name: '@push.rocks/smartfile',
  version: '11.2.0',
  description: 'Provides comprehensive tools for efficient file management in Node.js using TypeScript, including handling streams, virtual directories, and various file operations.'
 }
--- a/ts/classes.smartfile.ts
+++ b/ts/classes.smartfile.ts
@ -1,353 +0,0 @@
 import * as plugins from './plugins.js';
 import * as fs from './fs.js';
 import * as memory from './memory.js';
 export interface ISmartfileConstructorOptions {
  path: string;
  contentBuffer: Buffer;
  base: string;
 }
 /**
 * an vinyl file compatible in memory file class
 */
 export class SmartFile extends plugins.smartjson.Smartjson {
  // ======
  // STATIC
  // ======
  /**
   * creates a Smartfile from a filePath
   * @param filePath
   */
  public static async fromFilePath(filePath: string, baseArg: string = process.cwd()) {
    filePath = plugins.path.resolve(filePath);
    const fileBuffer = fs.toBufferSync(filePath);
    const smartfile = new SmartFile({
      contentBuffer: fileBuffer,
      base: baseArg,
      path: plugins.path.relative(baseArg, filePath),
    });
    return smartfile;
  }
  public static async fromBuffer(
    filePath: string,
    contentBufferArg: Buffer,
    baseArg: string = process.cwd()
  ) {
    const smartfile = new SmartFile({
      contentBuffer: contentBufferArg,
      base: baseArg,
      path: plugins.path.relative(baseArg, filePath),
    });
    return smartfile;
  }
  public static async fromString(
    filePath: string,
    contentStringArg: string,
    encodingArg: 'utf8' | 'binary',
    baseArg = process.cwd()
  ) {
    const smartfile = new SmartFile({
      contentBuffer: Buffer.from(contentStringArg, encodingArg),
      base: baseArg,
      path: plugins.path.relative(baseArg, filePath),
    });
    return smartfile;
  }
  public static async fromFoldedJson(foldedJsonArg: string) {
    return new SmartFile(plugins.smartjson.parse(foldedJsonArg));
  }
  /**
   * creates a Smartfile from a ReadableStream
   * @param stream a readable stream that provides file content
   * @param filePath the file path to associate with the content
   * @param baseArg the base path to use for the file
   */
  public static async fromStream(
    stream: plugins.stream.Readable,
    filePath: string,
    baseArg: string = process.cwd()
  ): Promise<SmartFile> {
    return new Promise<SmartFile>((resolve, reject) => {
      const chunks: Buffer[] = [];
      stream.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
      stream.on('error', (error) => reject(error));
      stream.on('end', () => {
        const contentBuffer = Buffer.concat(chunks);
        const smartfile = new SmartFile({
          contentBuffer: contentBuffer,
          base: baseArg,
          path: plugins.path.relative(baseArg, filePath),
        });
        resolve(smartfile);
      });
    });
  }
  public static async fromUrl(urlArg: string) {
    const response = await plugins.smartrequest.getBinary(urlArg);
    const smartfile = await SmartFile.fromBuffer(urlArg, response.body);
    return smartfile;
  }
  // ========
  // INSTANCE
  // ========
  /**
   * the relative path of the file
   */
  @plugins.smartjson.foldDec()
  public path: string;
  /**
   * a parsed path
   */
  public get parsedPath(): plugins.path.ParsedPath {
    return plugins.path.parse(this.path);
  }
  public get absolutePath() {
    return plugins.path.join(this.base, this.path);
  }
  public get absoluteParsedPath() {
    return plugins.path.parse(this.absolutePath);
  }
  /**
   * the content of the file as Buffer
   */
  @plugins.smartjson.foldDec()
  public contentBuffer: Buffer;
  /**
   * The current working directory of the file
   * Note:this is similar to gulp and different from native node path base
   */
  @plugins.smartjson.foldDec()
  public base: string;
  /**
   * sync the file with disk
   */
  @plugins.smartjson.foldDec()
  public sync: boolean;
  /**
   * the constructor of Smartfile
   * @param optionsArg
   */
  constructor(optionsArg: ISmartfileConstructorOptions) {
    super();
    if (optionsArg.contentBuffer) {
      this.contentBuffer = optionsArg.contentBuffer;
    } else {
      console.log('created empty Smartfile?');
    }
    this.path = optionsArg.path;
    this.base = optionsArg.base;
  }
  /**
   * set contents from string
   * @param contentString
   */
  public setContentsFromString(contentString: string, encodingArg: 'utf8' | 'binary' = 'utf8') {
    this.contents = Buffer.from(contentString, encodingArg);
  }
  /**
   * write file to disk at its original location
   * Behaviours:
   * - no argument write to exactly where the file was picked up
   */
  public async write() {
    let writePath = plugins.smartpath.transform.makeAbsolute(this.path, this.base);
    console.log(`writing to ${writePath}`);
    await memory.toFs(this.contentBuffer, writePath);
  }
  /**
   * writes the file to path given as argument
   * note: if the path is not absolute, takes process.cwd() as base
   * @param filePathArg
   */
  public async writeToDiskAtPath(filePathArg: string) {
    if (!plugins.path.isAbsolute(filePathArg)) {
      filePathArg = plugins.path.join(process.cwd(), filePathArg);
    }
    await memory.toFs(this.contentBuffer, filePathArg);
  }
  /**
   * writes the file to a directory combined with the relative path portion
   * @param dirPathArg
   * @returns
   */
  public async writeToDir(dirPathArg: string) {
    dirPathArg = plugins.smartpath.transform.toAbsolute(dirPathArg) as string;
    const filePath = plugins.path.join(dirPathArg, this.path);
    await memory.toFs(this.contentBuffer, filePath);
    return filePath;
  }
  /**
   * read file from disk
   */
  public async read() {
    this.contentBuffer = await fs.toBuffer(plugins.path.join(this.base, this.path));
  }
  /**
   * deletes the file from disk at its original location
   */
  public async delete() {
    await fs.remove(plugins.path.join(this.base, this.path));
  }
  /**
   * Renames the file to the specified new name.
   * - Updates the `path` property with the new name.
   * - Writes the file to the new location if it exists on disk.
   * @param newName The new name of the file (including extension if applicable).
   * @param writeToDisk (optional) If true, also renames the file on the disk.
   * @returns The updated file path after renaming.
   */
  public async rename(newName: string, writeToDisk: boolean = false): Promise<string> {
    // Validate the new name
    if (!newName || typeof newName !== 'string') {
      throw new Error('Invalid new name provided.');
    }
    // Extract the directory path
    const oldFilePath = this.path;
    const dirPath = plugins.path.dirname(this.path);
    // Create the new file path
    const newFilePath = plugins.path.join(dirPath, newName);
    // Update the `path` property
    this.path = newFilePath;
    // Optionally write the renamed file to disk
    if (writeToDisk) {
      const oldAbsolutePath = plugins.smartpath.transform.makeAbsolute(oldFilePath, this.base);
      const newAbsolutePath = plugins.smartpath.transform.makeAbsolute(newFilePath, this.base);
      // Rename the file on disk
      await plugins.fsExtra.rename(oldAbsolutePath, newAbsolutePath);
    }
    // Return the new path
    return this.path;
  }
  // -----------------------------------------------
  // vinyl compatibility
  // -----------------------------------------------
  /**
   * vinyl-compatibility: alias of this.contentBuffer
   */
  get contents(): Buffer {
    return this.contentBuffer;
  }
  set contents(contentsArg) {
    this.contentBuffer = contentsArg;
  }
  /**
   * vinyl-compatibility
   */
  public get cwd() {
    return process.cwd();
  }
  /**
   * return relative path of file
   */
  public get relative(): string {
    return this.path;
  }
  /**
   * return truw when the file has content
   */
  public isNull(): boolean {
    if (!this.contentBuffer) {
      return true;
    }
    return false;
  }
  /**
   * return true if contents are Buffer
   */
  public isBuffer(): boolean {
    if (this.contents instanceof Buffer) {
      return true;
    }
    return false;
  }
  public isDirectory() {
    return false;
  }
  public isStream() {
    return false;
  }
  public isSymbolic() {
    return false;
  }
  public async getHash(typeArg: 'path' | 'content' | 'all' = 'all') {
    const pathHash = await plugins.smarthash.sha256FromString(this.path);
    const contentHash = await plugins.smarthash.sha256FromBuffer(this.contentBuffer);
    const combinedHash = await plugins.smarthash.sha256FromString(pathHash + contentHash);
    switch (typeArg) {
      case 'path':
        return pathHash;
      case 'content':
        return contentHash;
      case 'all':
      default:
        return combinedHash;
    }
  }
  // update things
  public updateFileName(fileNameArg: string) {
    const oldFileName = this.parsedPath.base;
    this.path = this.path.replace(new RegExp(oldFileName + '$'), fileNameArg);
  }
  public async editContentAsString(editFuncArg: (fileStringArg: string) => Promise<string>) {
    const newFileString = await editFuncArg(this.contentBuffer.toString());
    this.contentBuffer = Buffer.from(newFileString);
  }
  /**
   * Returns a ReadableStream from the file's content buffer
   */
  public getStream(): plugins.stream.Readable {
    const stream = new plugins.stream.Readable();
    stream.push(this.contentBuffer); // Push the content buffer to the stream
    stream.push(null); // Push null to signify the end of the stream (EOF)
    return stream;
  }
  /**
   * Returns the size of the file in bytes
   */
  public async getSize(): Promise<number> {
    return this.contentBuffer.length;
  }
 }
--- a/ts/classes.streamfile.ts
+++ b/ts/classes.streamfile.ts
@ -1,174 +0,0 @@
 import * as plugins from './plugins.js';
 import * as smartfileFs from './fs.js';
 import * as smartfileFsStream from './fsstream.js';
 import { Readable } from 'stream';
 type TStreamSource = (streamFile: StreamFile) => Promise<Readable>;
 /**
 * The StreamFile class represents a file as a stream.
 * It allows creating streams from a file path, a URL, or a buffer.
 */
 export class StreamFile {
  // STATIC
  public static async fromPath(filePath: string): Promise<StreamFile> {
    const streamSource: TStreamSource = async (streamFileArg) => smartfileFsStream.createReadStream(filePath);
    const streamFile = new StreamFile(streamSource, filePath);
    streamFile.multiUse = true;
    streamFile.byteLengthComputeFunction = async () => {
      const stats = await smartfileFs.stat(filePath);
      return stats.size;
    }
    return streamFile;
  }
  public static async fromUrl(url: string): Promise<StreamFile> {
    const streamSource: TStreamSource = async (streamFileArg) => plugins.smartrequest.getStream(url); // Replace with actual plugin method
    const streamFile = new StreamFile(streamSource);
    streamFile.multiUse = true;
    streamFile.byteLengthComputeFunction = async () => {
      const response = await plugins.smartrequest.getBinary(url); // TODO: switch to future .getBinaryByteLength()
      return response.body.length;
    }
    return streamFile;
  }
  public static fromBuffer(buffer: Buffer, relativeFilePath?: string): StreamFile {
    const streamSource: TStreamSource = async (streamFileArg) => {
      const stream = new Readable();
      stream.push(buffer);
      stream.push(null); // End of stream
      return stream;
    };
    const streamFile = new StreamFile(streamSource, relativeFilePath);
    streamFile.multiUse = true;
    streamFile.byteLengthComputeFunction = async () => buffer.length;
    return streamFile;
  }
  /**
   * Creates a StreamFile from an existing Readable stream with an option for multiple uses.
   * @param stream A Node.js Readable stream.
   * @param relativeFilePath Optional file path for the stream.
   * @param multiUse If true, the stream can be read multiple times, caching its content.
   * @returns A StreamFile instance.
   */
  public static fromStream(stream: Readable, relativeFilePath?: string, multiUse: boolean = false): StreamFile {
    const streamSource: TStreamSource = (streamFileArg) => {
      if (streamFileArg.multiUse) {
        // If multi-use is enabled and we have cached content, create a new readable stream from the buffer
        const bufferedStream = new Readable();
        bufferedStream.push(streamFileArg.cachedStreamBuffer);
        bufferedStream.push(null); // No more data to push
        return Promise.resolve(bufferedStream);
      } else {
        return Promise.resolve(stream);
      }
    };
    const streamFile = new StreamFile(streamSource, relativeFilePath);
    streamFile.multiUse = multiUse;
    // If multi-use is enabled, cache the stream when it's first read
    if (multiUse) {
      const chunks: Buffer[] = [];
      stream.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
      stream.on('end', () => {
        streamFile.cachedStreamBuffer = Buffer.concat(chunks);
      });
      // It's important to handle errors that may occur during streaming
      stream.on('error', (err) => {
        console.error('Error while caching stream:', err);
      });
    }
    return streamFile;
  }
  // INSTANCE
  relativeFilePath?: string;
  private streamSource: TStreamSource;
  // enable stream based multi use
  private cachedStreamBuffer?: Buffer;
  public multiUse: boolean;
  public used: boolean = false;
  public byteLengthComputeFunction: () => Promise<number>;
  private constructor(streamSource: TStreamSource, relativeFilePath?: string) {
    this.streamSource = streamSource;
    this.relativeFilePath = relativeFilePath;
  }
  // METHODS
  private checkMultiUse() {
    if (!this.multiUse && this.used) {
      throw new Error('This stream can only be used once.');
    }
    this.used = true;
  }
  /**
   * Creates a new readable stream from the source.
   */
  public async createReadStream(): Promise<Readable> {
    return this.streamSource(this);
  }
  /**
   * Writes the stream to the disk at the specified path.
   * @param filePathArg The file path where the stream should be written.
   */
  public async writeToDisk(filePathArg: string): Promise<void> {
    this.checkMultiUse();
    const readStream = await this.createReadStream();
    const writeStream = smartfileFsStream.createWriteStream(filePathArg);
    return new Promise((resolve, reject) => {
      readStream.pipe(writeStream);
      readStream.on('error', reject);
      writeStream.on('error', reject);
      writeStream.on('finish', resolve);
    });
  }
  public async writeToDir(dirPathArg: string) {
    this.checkMultiUse();
    const filePath = plugins.path.join(dirPathArg, this.relativeFilePath);
    await smartfileFs.ensureDir(plugins.path.parse(filePath).dir);
    return this.writeToDisk(filePath);
  }
  public async getContentAsBuffer() {
    this.checkMultiUse();
    const done = plugins.smartpromise.defer<Buffer>();
    const readStream = await this.createReadStream();
    const chunks: Buffer[] = [];
    readStream.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
    readStream.on('error', done.reject);
    readStream.on('end', () => {
      const contentBuffer = Buffer.concat(chunks);
      done.resolve(contentBuffer);
    });
    return done.promise;
  }
  public async getContentAsString(formatArg: 'utf8' | 'binary' = 'utf8') {
    const contentBuffer = await this.getContentAsBuffer();
    return contentBuffer.toString(formatArg);
  }
  /**
   * Returns the size of the file content in bytes.
   */
  public async getSize(): Promise<number> {
    if (this.byteLengthComputeFunction) {
      return this.byteLengthComputeFunction();
    } else {
      return null;
    }
  }
 }
--- a/ts/classes.virtualdirectory.ts
+++ b/ts/classes.virtualdirectory.ts
@ -1,87 +0,0 @@
 import { SmartFile } from './classes.smartfile.js';
 import * as plugins from './plugins.js';
 import * as fs from './fs.js';
 export interface IVirtualDirectoryConstructorOptions {
  mode: ''
 }
 /**
 * a virtual directory exposes a fs api
 */
 export class VirtualDirectory {
  consstructor(options = {}) {
  }
  // STATIC
  public static async fromFsDirPath(pathArg: string): Promise<VirtualDirectory> {
    const newVirtualDir = new VirtualDirectory();
    newVirtualDir.addSmartfiles(await fs.fileTreeToObject(pathArg, '**/*'));
    return newVirtualDir;
  }
  public static async fromVirtualDirTransferableObject(
    virtualDirTransferableObjectArg: plugins.smartfileInterfaces.VirtualDirTransferableObject
  ): Promise<VirtualDirectory> {
    const newVirtualDir = new VirtualDirectory();
    for (const fileArg of virtualDirTransferableObjectArg.files) {
      newVirtualDir.addSmartfiles([SmartFile.enfoldFromJson(fileArg) as SmartFile]);
    }
    return newVirtualDir;
  }
  // INSTANCE
  public smartfileArray: SmartFile[] = [];
  constructor() {}
  public addSmartfiles(smartfileArrayArg: SmartFile[]) {
    this.smartfileArray = this.smartfileArray.concat(smartfileArrayArg);
  }
  public async getFileByPath(pathArg: string) {
    for (const smartfile of this.smartfileArray) {
      if (smartfile.path === pathArg) {
        return smartfile;
      }
    }
  }
  public async toVirtualDirTransferableObject(): Promise<plugins.smartfileInterfaces.VirtualDirTransferableObject> {
    return {
      files: this.smartfileArray.map((smartfileArg) => smartfileArg.foldToJson()),
    };
  }
  public async saveToDisk(dirArg: string) {
    console.log(`writing VirtualDirectory with ${this.smartfileArray.length} files to directory:
    --> ${dirArg}`);
    for (const smartfileArg of this.smartfileArray) {
      const filePath = await smartfileArg.writeToDir(dirArg);
      console.log(`wrote ${smartfileArg.relative} to
        --> ${filePath}`);
    }
  }
  public async shiftToSubdirectory(subDir: string): Promise<VirtualDirectory> {
    const newVirtualDir = new VirtualDirectory();
    for (const file of this.smartfileArray) {
      if (file.path.startsWith(subDir)) {
        const adjustedFilePath = plugins.path.relative(subDir, file.path);
        file.path = adjustedFilePath;
        newVirtualDir.addSmartfiles([file]);
      }
    }
    return newVirtualDir;
  }
  public async addVirtualDirectory(virtualDir: VirtualDirectory, newRoot: string): Promise<void> {
    for (const file of virtualDir.smartfileArray) {
      file.path = plugins.path.join(newRoot, file.path);
    }
    this.addSmartfiles(virtualDir.smartfileArray);
  }
 }
--- a/ts/fs.ts
+++ b/ts/fs.ts
@ -1,615 +0,0 @@
 import * as plugins from './plugins.js';
 import * as interpreter from './interpreter.js';
 import { SmartFile } from './classes.smartfile.js';
 import * as memory from './memory.js';
 import type { StreamFile } from './classes.streamfile.js';
 /*===============================================================
 ============================ Checks =============================
 ===============================================================*/
 /**
 *
 * @param filePath
 * @returns {boolean}
 */
 export const fileExistsSync = (filePath): boolean => {
  let fileExistsBool: boolean = false;
  try {
    plugins.fsExtra.readFileSync(filePath);
    fileExistsBool = true;
  } catch (err) {
    fileExistsBool = false;
  }
  return fileExistsBool;
 };
 /**
 *
 * @param filePath
 * @returns {any}
 */
 export const fileExists = async (filePath): Promise<boolean> => {
  const done = plugins.smartpromise.defer<boolean>();
  plugins.fs.access(filePath, 4, (err) => {
    err ? done.resolve(false) : done.resolve(true);
  });
  return done.promise;
 };
 /**
 * Checks if given path points to an existing directory
 */
 export const isDirectory = (pathArg: string): boolean => {
  try {
    return plugins.fsExtra.statSync(pathArg).isDirectory();
  } catch (err) {
    return false;
  }
 };
 /**
 * Checks if given path points to an existing directory
 */
 export const isDirectorySync = (pathArg: string): boolean => {
  try {
    return plugins.fsExtra.statSync(pathArg).isDirectory();
  } catch (err) {
    return false;
  }
 };
 /**
 * Checks if a given path points to an existing file
 */
 export const isFile = (pathArg): boolean => {
  return plugins.fsExtra.statSync(pathArg).isFile();
 };
 /*===============================================================
 ============================ FS ACTIONS =========================
 ===============================================================*/
 /**
 * copies a file or directory from A to B on the local disk
 */
 export const copy = async (fromArg: string, toArg: string, optionsArg?: plugins.fsExtra.CopyOptions & { replaceTargetDir?: boolean }): Promise<void> => {
  if (optionsArg?.replaceTargetDir && isDirectory(fromArg) && isDirectory(toArg)) {
    await remove(toArg);
  }
  return await plugins.fsExtra.copy(fromArg, toArg, optionsArg as plugins.fsExtra.CopyOptions);
 };
 /**
 * copies a file or directory SYNCHRONOUSLY from A to B on the local disk
 */
 export const copySync = (fromArg: string, toArg: string, optionsArg?: plugins.fsExtra.CopyOptionsSync & { replaceTargetDir?: boolean }): void => {
  if (optionsArg?.replaceTargetDir && isDirectory(fromArg) && isDirectory(toArg)) {
    removeSync(toArg);
  }
  return plugins.fsExtra.copySync(fromArg, toArg, optionsArg as plugins.fsExtra.CopyOptionsSync);
 };
 /**
 * ensures that a directory is in place
 */
 export const ensureDir = async (dirPathArg: string) => {
  await plugins.fsExtra.ensureDir(dirPathArg);
 };
 /**
 * ensures that a directory is in place
 */
 export const ensureDirSync = (dirPathArg: string) => {
  plugins.fsExtra.ensureDirSync(dirPathArg);
 };
 /**
 * ensure an empty directory
 * @executes ASYNC
 */
 export const ensureEmptyDir = async (dirPathArg: string) => {
  await plugins.fsExtra.ensureDir(dirPathArg);
  await plugins.fsExtra.emptyDir(dirPathArg);
 };
 /**
 * ensure an empty directory
 * @executes SYNC
 */
 export const ensureEmptyDirSync = (dirPathArg: string) => {
  plugins.fsExtra.ensureDirSync(dirPathArg);
  plugins.fsExtra.emptyDirSync(dirPathArg);
 };
 /**
 * ensures that a file is on disk
 * @param filePath the filePath to ensureDir
 * @param the fileContent to place into a new file in case it doesn't exist yet
 * @returns Promise<void>
 * @exec ASYNC
 */
 export const ensureFile = async (filePathArg, initFileStringArg): Promise<void> => {
  ensureFileSync(filePathArg, initFileStringArg);
 };
 /**
 * ensures that a file is on disk
 * @param filePath the filePath to ensureDir
 * @param the fileContent to place into a new file in case it doesn't exist yet
 * @returns Promise<void>
 * @exec SYNC
 */
 export const ensureFileSync = (filePathArg: string, initFileStringArg: string): void => {
  if (fileExistsSync(filePathArg)) {
    return null;
  } else {
    memory.toFsSync(initFileStringArg, filePathArg);
  }
 };
 /**
 * removes a file or folder from local disk
 */
 export const remove = async (pathArg: string): Promise<void> => {
  await plugins.fsExtra.remove(pathArg);
 };
 /**
 * removes a file SYNCHRONOUSLY from local disk
 */
 export const removeSync = (pathArg: string): void => {
  plugins.fsExtra.removeSync(pathArg);
 };
 /**
 * removes an array of filePaths from disk
 */
 export const removeMany = async (filePathArrayArg: string[]) => {
  const promiseArray: Array<Promise<void>> = [];
  for (const filePath of filePathArrayArg) {
    promiseArray.push(remove(filePath));
  }
  await Promise.all(promiseArray);
 };
 /**
 * like removeFilePathArray but SYNCHRONOUSLY
 */
 export const removeManySync = (filePathArrayArg: string[]): void => {
  for (const filePath of filePathArrayArg) {
    removeSync(filePath);
  }
 };
 /*===============================================================
 ============================ Write/Read =========================
 ===============================================================*/
 /**
 * reads a file content to an object
 * good for JSON, YAML, TOML, etc.
 * @param filePathArg
 * @param fileTypeArg
 * @returns {any}
 */
 export const toObjectSync = (filePathArg, fileTypeArg?) => {
  const fileString = plugins.fsExtra.readFileSync(filePathArg, 'utf8');
  let fileType;
  fileTypeArg ? (fileType = fileTypeArg) : (fileType = interpreter.filetype(filePathArg));
  try {
    return interpreter.objectFile(fileString, fileType);
  } catch (err) {
    err.message = `Failed to read file at ${filePathArg}` + err.message;
    throw err;
  }
 };
 /**
 * reads a file content to a String
 */
 export const toStringSync = (filePath: string): string => {
  const encoding = plugins.smartmime.getEncodingForPathSync(filePath);
  let fileString: string | Buffer = plugins.fsExtra.readFileSync(filePath, encoding);
  if (Buffer.isBuffer(fileString)) {
    fileString = fileString.toString('binary');
  }
  return fileString;
 };
 export const toBuffer = async (filePath: string): Promise<Buffer> => {
  return plugins.fsExtra.readFile(filePath);
 };
 export const toBufferSync = (filePath: string): Buffer => {
  return plugins.fsExtra.readFileSync(filePath);
 };
 /**
 * Creates a Readable Stream from a file path.
 * @param filePath The path to the file.
 * @returns {fs.ReadStream}
 */
 export const toReadStream = (filePath: string): plugins.fs.ReadStream => {
  if (!fileExistsSync(filePath)) {
    throw new Error(`File does not exist at path: ${filePath}`);
  }
  return plugins.fsExtra.createReadStream(filePath);
 };
 export const fileTreeToHash = async (dirPathArg: string, miniMatchFilter: string) => {
  const fileTreeObject = await fileTreeToObject(dirPathArg, miniMatchFilter);
  let combinedString = '';
  for (const smartfile of fileTreeObject) {
    combinedString += await smartfile.getHash();
  }
  const hash = await plugins.smarthash.sha256FromString(combinedString);
  return hash;
 };
 /**
 * creates a smartfile array from a directory
 * @param dirPathArg the directory to start from
 * @param miniMatchFilter a minimatch filter of what files to include
 */
 export const fileTreeToObject = async (dirPathArg: string, miniMatchFilter: string) => {
  // handle absolute miniMatchFilter
  let dirPath: string;
  if (plugins.path.isAbsolute(miniMatchFilter)) {
    dirPath = '/';
  } else {
    dirPath = plugins.smartpath.transform.toAbsolute(dirPathArg) as string;
  }
  const fileTree = await listFileTree(dirPath, miniMatchFilter);
  const smartfileArray: SmartFile[] = [];
  for (const filePath of fileTree) {
    const readPath = ((): string => {
      if (!plugins.path.isAbsolute(filePath)) {
        return plugins.path.join(dirPath, filePath);
      } else {
        return filePath;
      }
    })();
    const fileBuffer = plugins.fs.readFileSync(readPath);
    // push a read file as Smartfile
    smartfileArray.push(
      new SmartFile({
        contentBuffer: fileBuffer,
        base: dirPath,
        path: filePath,
      })
    );
  }
  return smartfileArray;
 };
 /**
 * lists Folders in a directory on local disk
 * @returns Promise with an array that contains the folder names
 */
 export const listFolders = async (pathArg: string, regexFilter?: RegExp): Promise<string[]> => {
  return listFoldersSync(pathArg, regexFilter);
 };
 /**
 * lists Folders SYNCHRONOUSLY in a directory on local disk
 * @returns an array with the folder names as strings
 */
 export const listFoldersSync = (pathArg: string, regexFilter?: RegExp): string[] => {
  let folderArray = plugins.fsExtra.readdirSync(pathArg).filter((file) => {
    return plugins.fsExtra.statSync(plugins.path.join(pathArg, file)).isDirectory();
  });
  if (regexFilter) {
    folderArray = folderArray.filter((fileItem) => {
      return regexFilter.test(fileItem);
    });
  }
  return folderArray;
 };
 /**
 * lists Files in a directory on local disk
 * @returns Promise
 */
 export const listFiles = async (pathArg: string, regexFilter?: RegExp): Promise<string[]> => {
  return listFilesSync(pathArg, regexFilter);
 };
 /**
 * lists Files SYNCHRONOUSLY in a directory on local disk
 * @returns an array with the folder names as strings
 */
 export const listFilesSync = (pathArg: string, regexFilter?: RegExp): string[] => {
  let fileArray = plugins.fsExtra.readdirSync(pathArg).filter((file) => {
    return plugins.fsExtra.statSync(plugins.path.join(pathArg, file)).isFile();
  });
  if (regexFilter) {
    fileArray = fileArray.filter((fileItem) => {
      return regexFilter.test(fileItem);
    });
  }
  return fileArray;
 };
 /**
 * lists all items (folders AND files) in a directory on local disk
 * @returns Promise<string[]>
 */
 export const listAllItems = async (pathArg: string, regexFilter?: RegExp): Promise<string[]> => {
  return listAllItemsSync(pathArg, regexFilter);
 };
 /**
 * lists all items (folders AND files) in a directory on local disk
 * @returns an array with the folder names as strings
 * @executes SYNC
 */
 export const listAllItemsSync = (pathArg: string, regexFilter?: RegExp): string[] => {
  let allItmesArray = plugins.fsExtra.readdirSync(pathArg).filter((file) => {
    return plugins.fsExtra.statSync(plugins.path.join(pathArg, file)).isFile();
  });
  if (regexFilter) {
    allItmesArray = allItmesArray.filter((fileItem) => {
      return regexFilter.test(fileItem);
    });
  }
  return allItmesArray;
 };
 /**
 * lists a file tree using a miniMatch filter
 * note: if the miniMatch Filter is an absolute path, the cwdArg will be omitted
 * @returns Promise<string[]> string array with the absolute paths of all matching files
 */
 export const listFileTree = async (
  dirPathArg: string,
  miniMatchFilter: string,
  absolutePathsBool: boolean = false
 ): Promise<string[]> => {
  // handle absolute miniMatchFilter
  let dirPath: string;
  if (plugins.path.isAbsolute(miniMatchFilter)) {
    dirPath = '/';
  } else {
    dirPath = dirPathArg;
  }
  const options = {
    cwd: dirPath,
    nodir: true,
    dot: true,
  };
  let fileList = await plugins.glob.glob(miniMatchFilter, options);
  if (absolutePathsBool) {
    fileList = fileList.map((filePath) => {
      return plugins.path.resolve(plugins.path.join(dirPath, filePath));
    });
  }
  return fileList;
 };
 /**
 * Watches for file stability before resolving the promise.
 * Ensures that the directory/file exists before setting up the watcher.
 *
 * **New behavior**: If the given path is a directory, this function will:
 *  1. Wait for that directory to exist (creating a timeout if needed).
 *  2. Watch the directory until at least one file appears.
 *  3. Then wait for the first file in the directory to stabilize before resolving.
 *
 * @param fileOrDirPathArg The path of the file or directory to monitor.
 * @param timeoutMs The maximum time to wait for the file to stabilize (in milliseconds). Default is 60 seconds.
 * @returns A promise that resolves when the target is stable or rejects on timeout/error.
 */
 export const waitForFileToBeReady = async (
  fileOrDirPathArg: string,
  timeoutMs: number = 60000
 ): Promise<void> => {
  const startTime = Date.now();
  /**
   * Ensure that a path (file or directory) exists. If it doesn't yet exist,
   * wait until it does (or time out).
   * @param pathToCheck The file or directory path to check.
   */
  const ensurePathExists = async (pathToCheck: string): Promise<void> => {
    while (true) {
      try {
        await plugins.smartpromise.fromCallback((cb) =>
          plugins.fs.access(pathToCheck, plugins.fs.constants.F_OK, cb)
        );
        return;
      } catch (err: any) {
        if (err.code !== 'ENOENT') {
          throw err; // Propagate unexpected errors
        }
        if (Date.now() - startTime > timeoutMs) {
          throw new Error(`Timeout waiting for path to exist: ${pathToCheck}`);
        }
        await plugins.smartdelay.delayFor(500);
      }
    }
  };
  /**
   * Checks if a file (not directory) is stable by comparing sizes
   * across successive checks.
   * @param filePathArg The path of the file to check.
   * @returns A promise that resolves once the file stops changing.
   */
  const waitForSingleFileToBeStable = async (filePathArg: string): Promise<void> => {
    let lastFileSize = -1;
    let fileIsStable = false;
    // We'll create a helper for repeated stats-checking logic
    const checkFileStability = async () => {
      try {
        const stats = await plugins.smartpromise.fromCallback<plugins.fs.Stats>((cb) =>
          plugins.fs.stat(filePathArg, cb)
        );
        if (stats.isDirectory()) {
          // If it unexpectedly turns out to be a directory here, throw
          throw new Error(`Expected a file but found a directory: ${filePathArg}`);
        }
        if (stats.size === lastFileSize) {
          fileIsStable = true;
        } else {
          lastFileSize = stats.size;
          fileIsStable = false;
        }
      } catch (err: any) {
        // Ignore only if file not found
        if (err.code !== 'ENOENT') {
          throw err;
        }
      }
    };
    // Ensure file exists first
    await ensurePathExists(filePathArg);
    // Set up a watcher on the file itself
    const fileWatcher = plugins.fs.watch(filePathArg, { persistent: true }, async () => {
      if (!fileIsStable) {
        await checkFileStability();
      }
    });
    try {
      // Poll until stable or timeout
      while (!fileIsStable) {
        if (Date.now() - startTime > timeoutMs) {
          throw new Error(`Timeout waiting for file to stabilize: ${filePathArg}`);
        }
        await checkFileStability();
        if (!fileIsStable) {
          await plugins.smartdelay.delayFor(1000);
        }
      }
    } finally {
      fileWatcher.close();
    }
  };
  /**
   * Main logic: check if we have a directory or file at fileOrDirPathArg.
   * If directory, wait for first file in the directory to appear and stabilize.
   * If file, do the old single-file wait logic.
   */
  const statsForGivenPath = await (async () => {
    try {
      await ensurePathExists(fileOrDirPathArg);
      return await plugins.smartpromise.fromCallback<plugins.fs.Stats>((cb) =>
        plugins.fs.stat(fileOrDirPathArg, cb)
      );
    } catch (err) {
      // If there's an error (including timeout), just rethrow
      throw err;
    }
  })();
  if (!statsForGivenPath.isDirectory()) {
    // It's a file – just do the single-file stability wait
    await waitForSingleFileToBeStable(fileOrDirPathArg);
    return;
  }
  // Otherwise, it's a directory. Wait for the first file inside to appear and be stable
  const dirPath = fileOrDirPathArg;
  // Helper to find the first file in the directory if it exists
  const getFirstFileInDirectory = async (): Promise<string | null> => {
    const entries = await plugins.smartpromise.fromCallback<string[]>((cb) =>
      plugins.fs.readdir(dirPath, cb)
    );
    // We only want actual files, not subdirectories
    for (const entry of entries) {
      const entryPath = plugins.path.join(dirPath, entry);
      const entryStats = await plugins.smartpromise.fromCallback<plugins.fs.Stats>((cb) =>
        plugins.fs.stat(entryPath, cb)
      );
      if (entryStats.isFile()) {
        return entryPath;
      }
    }
    return null;
  };
  // Wait for a file to appear in this directory
  let firstFilePath = await getFirstFileInDirectory();
  if (!firstFilePath) {
    // Set up a watcher on the directory to see if a file appears
    const directoryWatcher = plugins.fs.watch(dirPath, { persistent: true });
    try {
      // We'll poll for the existence of a file in that directory
      while (!firstFilePath) {
        if (Date.now() - startTime > timeoutMs) {
          throw new Error(`Timeout waiting for a file to appear in directory: ${dirPath}`);
        }
        firstFilePath = await getFirstFileInDirectory();
        if (!firstFilePath) {
          await plugins.smartdelay.delayFor(1000);
        }
      }
    } finally {
      directoryWatcher.close();
    }
  }
  // Now that we have a file path, wait for that file to stabilize
  await waitForSingleFileToBeStable(firstFilePath);
 };
 /**
 * writes string or Smartfile to disk.
 * @param fileArg
 * @param fileNameArg
 * @param fileBaseArg
 */
 export let toFs = async (
  fileContentArg: string | Buffer | SmartFile | StreamFile,
  filePathArg: string,
  optionsArg: {
    respectRelative?: boolean;
  } = {}
 ) => {
  const done = plugins.smartpromise.defer();
  // check args
  if (!fileContentArg || !filePathArg) {
    throw new Error('expected valid arguments');
  }
  // prepare actual write action
  let fileContent: string | Buffer;
  let fileEncoding: 'utf8' | 'binary' = 'utf8';
  let filePath: string = filePathArg;
  // handle Smartfile
  if (fileContentArg instanceof SmartFile) {
    fileContent = fileContentArg.contentBuffer;
    // handle options
    if (optionsArg.respectRelative) {
      filePath = plugins.path.join(filePath, fileContentArg.path);
    }
  } else if (Buffer.isBuffer(fileContentArg)) {
    fileContent = fileContentArg;
    fileEncoding = 'binary';
  } else if (typeof fileContentArg === 'string') {
    fileContent = fileContentArg;
  } else {
    throw new Error('fileContent is neither string nor Smartfile');
  }
  await ensureDir(plugins.path.parse(filePath).dir);
  plugins.fsExtra.writeFile(filePath, fileContent, { encoding: fileEncoding }, done.resolve);
  return await done.promise;
 };
 export const stat = async (filePathArg: string) => {
  return plugins.fsPromises.stat(filePathArg);
 };
--- a/ts/fsstream.ts
+++ b/ts/fsstream.ts
@ -1,195 +0,0 @@
 /*
 This file contains logic for streaming things from and to the filesystem
 */
 import * as plugins from './plugins.js';
 export const createReadStream = (pathArg: string) => {
  return plugins.fs.createReadStream(pathArg);
 };
 export const createWriteStream = (pathArg: string) => {
  return plugins.fs.createWriteStream(pathArg);
 };
 export const processFile = async (
  filePath: string,
  asyncFunc: (fileStream: plugins.stream.Readable) => Promise<void>
 ): Promise<void> => {
  return new Promise((resolve, reject) => {
    const fileStream = createReadStream(filePath);
    asyncFunc(fileStream).then(resolve).catch(reject);
  });
 }
 export const processDirectory = async (
  directoryPath: string,
  asyncFunc: (fileStream: plugins.stream.Readable) => Promise<void>
 ): Promise<void> => {
  const files = plugins.fs.readdirSync(directoryPath, { withFileTypes: true });
  for (const file of files) {
    const fullPath = plugins.path.join(directoryPath, file.name);
    if (file.isDirectory()) {
      await processDirectory(fullPath, asyncFunc); // Recursively call processDirectory for directories
    } else if (file.isFile()) {
      await processFile(fullPath, asyncFunc); // Call async function with the file stream and wait for it
    }
  }
 };
 /**
 * Checks if a file is ready to be streamed (exists and is not empty).
 */
 export const isFileReadyForStreaming = async (filePathArg: string): Promise<boolean> => {
  try {
    const stats = await plugins.fs.promises.stat(filePathArg);
    return stats.size > 0;
  } catch (error) {
    if (error.code === 'ENOENT') { // File does not exist
      return false;
    }
    throw error; // Rethrow other unexpected errors
  }
 };
 /**
 * Waits for a file to be ready for streaming (exists and is not empty).
 */
 export const waitForFileToBeReadyForStreaming = (filePathArg: string): Promise<void> => {
  return new Promise((resolve, reject) => {
    // Normalize and resolve the file path
    const filePath = plugins.path.resolve(filePathArg);
    // Function to check file stats
    const checkFile = (resolve: () => void, reject: (reason: any) => void) => {
      plugins.fs.stat(filePath, (err, stats) => {
        if (err) {
          if (err.code === 'ENOENT') {
            // File not found, wait and try again
            return;
          }
          // Some other error occurred
          return reject(err);
        }
        if (stats.size > 0) {
          // File exists and is not empty, resolve the promise
          resolve();
        }
      });
    };
    // Set up file watcher
    const watcher = plugins.fs.watch(filePath, { persistent: false }, (eventType) => {
      if (eventType === 'change' || eventType === 'rename') {
        checkFile(resolve, reject);
      }
    });
    // Check file immediately in case it's already ready
    checkFile(resolve, reject);
    // Error handling
    watcher.on('error', (error) => {
      watcher.close();
      reject(error);
    });
  });
 };
 export class SmartReadStream extends plugins.stream.Readable {
  private watcher: plugins.fs.FSWatcher | null = null;
  private lastReadSize: number = 0;
  private endTimeout: NodeJS.Timeout | null = null;
  private filePath: string;
  private endDelay: number;
  private reading: boolean = false;
  constructor(filePath: string, endDelay = 60000, opts?: plugins.stream.ReadableOptions) {
    super(opts);
    this.filePath = filePath;
    this.endDelay = endDelay;
  }
  private startWatching(): void {
    this.watcher = plugins.fs.watch(this.filePath, (eventType) => {
      if (eventType === 'change') {
        this.resetEndTimeout();
      }
    });
    this.watcher.on('error', (error) => {
      this.cleanup();
      this.emit('error', error);
    });
  }
  private resetEndTimeout(): void {
    if (this.endTimeout) clearTimeout(this.endTimeout);
    this.endTimeout = setTimeout(() => this.checkForEnd(), this.endDelay);
  }
  private checkForEnd(): void {
    plugins.fs.stat(this.filePath, (err, stats) => {
      if (err) {
        this.emit('error', err);
        return;
      }
      if (this.lastReadSize === stats.size) {
        this.push(null); // Signal the end of the stream
        this.cleanup();
      } else {
        this.lastReadSize = stats.size;
        this.resetEndTimeout();
        if (!this.reading) {
          // We only want to continue reading if we were previously waiting for more data
          this.reading = true;
          this._read(10000); // Try to read more data
        }
      }
    });
  }
  private cleanup(): void {
    if (this.endTimeout) clearTimeout(this.endTimeout);
    if (this.watcher) this.watcher.close();
  }
  _read(size: number): void {
    this.reading = true;
    const chunkSize = Math.min(size, 16384); // Read in chunks of 16KB
    const buffer = Buffer.alloc(chunkSize);
    plugins.fs.open(this.filePath, 'r', (err, fd) => {
      if (err) {
        this.emit('error', err);
        return;
      }
      plugins.fs.read(fd, buffer, 0, chunkSize, this.lastReadSize, (err, bytesRead, buffer) => {
        if (err) {
          this.emit('error', err);
          return;
        }
        if (bytesRead > 0) {
          this.lastReadSize += bytesRead;
          this.push(buffer.slice(0, bytesRead)); // Push the data onto the stream
        } else {
          this.reading = false; // No more data to read for now
          this.resetEndTimeout();
        }
        plugins.fs.close(fd, (err) => {
          if (err) {
            this.emit('error', err);
          }
        });
      });
    });
  }
  _destroy(error: Error | null, callback: (error: Error | null) => void): void {
    this.cleanup();
    callback(error);
  }
 }
--- a/ts/index.ts
+++ b/ts/index.ts
@ -1,14 +1,12 @@
-import * as plugins from './plugins.js';
+import * as plugins from './smartfile.plugins';
-import * as fsMod from './fs.js';
+import * as SmartfileFs from './smartfile.fs';
-import * as fsStreamMod from './fsstream.js';
+import * as SmartfileInterpreter from './smartfile.interpreter';
-import * as interpreterMod from './interpreter.js';
+import * as SmartfileMemory from './smartfile.memory';
-import * as memoryMod from './memory.js';
+import * as SmartfileRemote from './smartfile.remote';
-export * from './classes.smartfile.js';
+export { Smartfile } from './smartfile.classes.smartfile';
 export * from './classes.streamfile.js';
 export * from './classes.virtualdirectory.js';
-export const fs = fsMod;
+export let fs = SmartfileFs;
-export const fsStream = fsStreamMod;
+export let interpreter = SmartfileInterpreter;
-export const interpreter = interpreterMod;
+export let memory = SmartfileMemory;
-export const memory = memoryMod;
+export let remote = SmartfileRemote;
--- a/ts/plugins.ts
+++ b/ts/plugins.ts
@ -1,39 +0,0 @@
 // node native scope
 import * as fs from 'fs';
 import * as fsPromises from 'fs/promises';
 import * as path from 'path';
 import * as stream from 'stream';
 export { fs, fsPromises, path, stream };
 // @pushrocks scope
 import * as lik from '@push.rocks/lik';
 import * as smartfileInterfaces from '@push.rocks/smartfile-interfaces';
 import * as smartdelay from '@push.rocks/smartdelay';
 import * as smarthash from '@push.rocks/smarthash';
 import * as smartjson from '@push.rocks/smartjson';
 import * as smartmime from '@push.rocks/smartmime';
 import * as smartpath from '@push.rocks/smartpath';
 import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartrequest from '@push.rocks/smartrequest';
 import * as smartstream from '@push.rocks/smartstream';
 export {
  lik,
  smartfileInterfaces,
  smartdelay,
  smarthash,
  smartjson,
  smartmime,
  smartpath,
  smartpromise,
  smartrequest,
  smartstream,
 };
 // third party scope
 import fsExtra from 'fs-extra';
 import * as glob from 'glob';
 import yaml from 'js-yaml';
 export { fsExtra, glob, yaml };
--- a/ts/smartfile.classes.smartfile.ts
+++ b/ts/smartfile.classes.smartfile.ts
@ -0,0 +1,169 @@
 import * as plugins from './smartfile.plugins';
 import * as fs from './smartfile.fs';
 import * as memory from './smartfile.memory';
 export interface ISmartfileConstructorOptions {
  path?: string;
  contentString?: string;
  contentBuffer?: Buffer;
  base?: string;
 }
 /**
 * class Smartfile
 * -> is vinyl file compatible
 */
 export class Smartfile {
  // ======
  // STATIC
  // ======
  /**
   * creates a Smartfile from a filePath
   * @param filePath
   */
  public static async fromFilePath(filePath: string) {
    filePath = plugins.path.resolve(filePath);
    const fileString = fs.toStringSync(filePath);
    const smartfile = new Smartfile({
      path: filePath,
      contentString: fileString
    });
    return smartfile;
  }
  // ========
  // INSTANCE
  // ========
  /**
   * the full path of the file on disk
   */
  path: string;
  /**
   *
   */
  parsedPath: plugins.path.ParsedPath;
  /**
   * the content of the file as Buffer
   */
  contentBuffer: Buffer;
  /**
   * The current working directory of the file
   * Note:this is similar to gulp and different from native node path base
   */
  base: string;
  /**
   * sync the file with disk
   */
  sync: boolean;
  /**
   * the constructor of Smartfile
   * @param optionsArg
   */
  constructor(optionsArg: ISmartfileConstructorOptions) {
    if (optionsArg.contentBuffer) {
      this.contentBuffer = optionsArg.contentBuffer;
    } else if (optionsArg.contentString) {
      this.setContentsFromString(optionsArg.contentString);
    } else {
      console.log('created empty Smartfile?');
    }
    this.path = optionsArg.path;
    this.parsedPath = plugins.path.parse(this.path);
    this.base = optionsArg.base;
  }
  /**
   * set contents from string
   * @param contentString
   */
  setContentsFromString(contentString: string) {
    this.contents = new Buffer(contentString);
  }
  /**
   * write file to disk
   * Behaviours:
   * - no argument write to exactly where the file was picked up
   */
  async write(pathArg?: string) {
    const stringToWrite = this.contentBuffer.toString();
    await memory.toFs(stringToWrite, this.path);
  }
  /**
   * read file from disk
   */
  async read() {}
  // -----------------------------------------------
  // vinyl compatibility
  // -----------------------------------------------
  /**
   * vinyl-compatibility: alias of this.contentBuffer
   */
  get contents(): Buffer {
    return this.contentBuffer;
  }
  set contents(contentsArg) {
    this.contentBuffer = contentsArg;
  }
  /**
   * vinyl-compatibility
   */
  get cwd() {
    return process.cwd();
  }
  /**
   * return relative path of file
   */
  get relative(): string {
    return plugins.path.relative(this.base, this.path);
  }
  /**
   * return truw when the file has content
   */
  isNull(): boolean {
    if (!this.contentBuffer) {
      return true;
    }
    return false;
  }
  /**
   * return true if contents are Buffer
   */
  isBuffer(): boolean {
    if (this.contents instanceof Buffer) {
      return true;
    }
    return false;
  }
  isDirectory() {
    return false;
  }
  isStream() {
    return false;
  }
  isSymbolic() {
    return false;
  }
  // update things
  updateFileName(fileNameArg: string) {
    let oldFileName = this.parsedPath.base;
    this.path = this.path.replace(new RegExp(oldFileName + '$'), fileNameArg);
  }
 }
--- a/ts/smartfile.fs.ts
+++ b/ts/smartfile.fs.ts
@ -0,0 +1,369 @@
 import plugins = require('./smartfile.plugins');
 import SmartfileInterpreter = require('./smartfile.interpreter');
 import { Smartfile } from './smartfile.classes.smartfile';
 import * as memory from './smartfile.memory';
 /*===============================================================
 ============================ Checks =============================
 ===============================================================*/
 /**
 *
 * @param filePath
 * @returns {boolean}
 */
 export const fileExistsSync = (filePath): boolean => {
  let fileExistsBool: boolean = false;
  try {
    plugins.fsExtra.readFileSync(filePath);
    fileExistsBool = true;
  } catch (err) {
    fileExistsBool = false;
  }
  return fileExistsBool;
 };
 /**
 *
 * @param filePath
 * @returns {any}
 */
 export let fileExists = async (filePath): Promise<boolean> => {
  const done = plugins.smartpromise.defer<boolean>();
  plugins.fs.access(filePath, 4, err => {
    err ? done.resolve(false) : done.resolve(true);
  });
  return done.promise;
 };
 /**
 * Checks if given path points to an existing directory
 */
 export const isDirectory = (pathArg): boolean => {
  try {
    return plugins.fsExtra.statSync(pathArg).isDirectory();
  } catch (err) {
    return false;
  }
 };
 /**
 * Checks if a given path points to an existing file
 */
 export const isFile = (pathArg): boolean => {
  return plugins.fsExtra.statSync(pathArg).isFile();
 };
 /*===============================================================
 ============================ FS ACTIONS =========================
 ===============================================================*/
 /**
 * copies a file from A to B on the local disk
 */
 export const copy = async (fromArg: string, toArg: string): Promise<boolean> => {
  const done = plugins.smartpromise.defer<boolean>();
  plugins.fsExtra.copy(fromArg, toArg, {}, (err) => {
    if (err) {
      throw new Error(`Could not copy from ${fromArg} to ${toArg}: ${err}`);
    }
    done.resolve(true);
  });
  return done.promise;
 };
 /**
 * copies a file SYNCHRONOUSLY from A to B on the local disk
 */
 export const copySync = (fromArg: string, toArg: string): boolean => {
  plugins.fsExtra.copySync(fromArg, toArg);
  return true;
 };
 /**
 * ensures that a directory is in place
 */
 export let ensureDir = (dirPathArg: string) => {
  let done = plugins.smartpromise.defer();
  plugins.fsExtra.ensureDir(dirPathArg, done.resolve);
  return done.promise;
 };
 /**
 * ensures that a directory is in place
 */
 export let ensureDirSync = (dirPathArg: string) => {
  plugins.fsExtra.ensureDirSync(dirPathArg);
 };
 /**
 * ensure an empty directory
 * @executes ASYNC
 */
 export let ensureEmptyDir = (dirPathArg: string) => {
  let done = plugins.smartpromise.defer();
  plugins.fsExtra.ensureDir(dirPathArg, () => {
    plugins.fsExtra.emptyDir(dirPathArg, done.resolve);
  });
  return done.promise;
 };
 /**
 * ensure an empty directory
 * @executes SYNC
 */
 export let ensureEmptyDirSync = (dirPathArg: string) => {
  plugins.fsExtra.ensureDirSync(dirPathArg);
  plugins.fsExtra.emptyDirSync(dirPathArg);
 };
 /**
 * ensures that a file is on disk
 * @param filePath the filePath to ensureDir
 * @param the fileContent to place into a new file in case it doesn't exist yet
 * @returns Promise<void>
 * @exec ASYNC
 */
 export let ensureFile = (filePathArg, initFileStringArg): Promise<void> => {
  let done = plugins.smartpromise.defer<void>();
  ensureFileSync(filePathArg, initFileStringArg);
  done.resolve();
  return done.promise;
 };
 /**
 * ensures that a file is on disk
 * @param filePath the filePath to ensureDir
 * @param the fileContent to place into a new file in case it doesn't exist yet
 * @returns Promise<void>
 * @exec SYNC
 */
 export let ensureFileSync = (filePathArg: string, initFileStringArg: string): void => {
  if (fileExistsSync(filePathArg)) {
    return null;
  } else {
    memory.toFsSync(initFileStringArg, filePathArg);
  }
 };
 /**
 * removes a file or folder from local disk
 */
 export let remove = function(pathArg: string): Promise<void> {
  let done = plugins.smartpromise.defer<void>();
  plugins.fsExtra.remove(pathArg, function() {
    done.resolve();
  });
  return done.promise;
 };
 /**
 * removes a file SYNCHRONOUSLY from local disk
 */
 export let removeSync = function(pathArg: string): boolean {
  plugins.fsExtra.removeSync(pathArg);
  return true;
 };
 /**
 * removes an array of filePaths from disk
 */
 export let removeMany = function(filePathArrayArg: string[]) {
  let promiseArray: Promise<void>[] = [];
  for (let filePath of filePathArrayArg) {
    promiseArray.push(remove(filePath));
  }
  return Promise.all(promiseArray);
 };
 /**
 * like removeFilePathArray but SYNCHRONOUSLY
 */
 export let removeManySync = function(filePathArrayArg: string[]): void {
  for (let filePath of filePathArrayArg) {
    removeSync(filePath);
  }
 };
 /*===============================================================
 ============================ Write/Read =========================
 ===============================================================*/
 /**
 *
 * @param filePathArg
 * @param fileTypeArg
 * @returns {any}
 */
 export let toObjectSync = function(filePathArg, fileTypeArg?) {
  const fileString = plugins.fsExtra.readFileSync(filePathArg, 'utf8');
  let fileType;
  fileTypeArg ? (fileType = fileTypeArg) : (fileType = SmartfileInterpreter.filetype(filePathArg));
  return SmartfileInterpreter.objectFile(fileString, fileType);
 };
 /**
 * reads a file content to a String
 * @param filePath
 * @returns {string|Buffer|any}
 */
 export const toStringSync = (filePath: string): string => {
  const fileString: string = plugins.fsExtra.readFileSync(filePath, 'utf8');
  return fileString;
 };
 export const fileTreeToObject = async (dirPathArg: string, miniMatchFilter: string) => {
  // handle absolute miniMatchFilter
  let dirPath: string;
  if (plugins.path.isAbsolute(miniMatchFilter)) {
    dirPath = '/';
  } else {
    dirPath = dirPathArg;
  }
  const fileTree = await listFileTree(dirPath, miniMatchFilter);
  const smartfileArray: Smartfile[] = [];
  for (let filePath of fileTree) {
    let readPath = ((): string => {
      if (!plugins.path.isAbsolute(filePath)) {
        return plugins.path.join(dirPath, filePath);
      } else {
        return filePath;
      }
    })();
    let fileContentString = toStringSync(readPath);
    // push a read file as Smartfile
    smartfileArray.push(
      new Smartfile({
        contentBuffer: Buffer.from(fileContentString),
        base: dirPath,
        path: filePath
      })
    );
  }
  return smartfileArray;
 };
 /**
 *
 * @param filePathArg
 * @param options
 * @returns {number}
 */
 export let toVinylSync = function(filePathArg, options = {}) {
  return plugins.vinylFile.readSync(filePathArg, options);
 };
 /**
 * lists Folders in a directory on local disk
 * @returns Promise with an array that contains the folder names
 */
 export let listFolders = async (pathArg: string, regexFilter?: RegExp): Promise<string[]> => {
  return listFoldersSync(pathArg, regexFilter);
 };
 /**
 * lists Folders SYNCHRONOUSLY in a directory on local disk
 * @returns an array with the folder names as strings
 */
 export let listFoldersSync = (pathArg: string, regexFilter?: RegExp): string[] => {
  let folderArray = plugins.fsExtra.readdirSync(pathArg).filter(file => {
    return plugins.fsExtra.statSync(plugins.path.join(pathArg, file)).isDirectory();
  });
  if (regexFilter) {
    folderArray = folderArray.filter(fileItem => {
      return regexFilter.test(fileItem);
    });
  }
  return folderArray;
 };
 /**
 * lists Files in a directory on local disk
 * @returns Promise
 */
 export let listFiles = async (pathArg: string, regexFilter?: RegExp): Promise<string[]> => {
  return listFilesSync(pathArg, regexFilter);
 };
 /**
 * lists Files SYNCHRONOUSLY in a directory on local disk
 * @returns an array with the folder names as strings
 */
 export let listFilesSync = (pathArg: string, regexFilter?: RegExp): string[] => {
  let fileArray = plugins.fsExtra.readdirSync(pathArg).filter(file => {
    return plugins.fsExtra.statSync(plugins.path.join(pathArg, file)).isFile();
  });
  if (regexFilter) {
    fileArray = fileArray.filter(fileItem => {
      return regexFilter.test(fileItem);
    });
  }
  return fileArray;
 };
 /**
 * lists all items (folders AND files) in a directory on local disk
 * @returns Promise<string[]>
 */
 export let listAllItems = async (pathArg: string, regexFilter?: RegExp): Promise<string[]> => {
  return listAllItemsSync(pathArg, regexFilter);
 };
 /**
 * lists all items (folders AND files) in a directory on local disk
 * @returns an array with the folder names as strings
 * @executes SYNC
 */
 export let listAllItemsSync = (pathArg: string, regexFilter?: RegExp): string[] => {
  let allItmesArray = plugins.fsExtra.readdirSync(pathArg).filter(function(file) {
    return plugins.fsExtra.statSync(plugins.path.join(pathArg, file)).isFile();
  });
  if (regexFilter) {
    allItmesArray = allItmesArray.filter(fileItem => {
      return regexFilter.test(fileItem);
    });
  }
  return allItmesArray;
 };
 /**
 * lists a file tree using a miniMatch filter
 * note: if the miniMatch Filter is an absolute path, the cwdArg will be omitted
 * @returns Promise<string[]> string array with the absolute paths of all matching files
 */
 export const listFileTree = async (dirPathArg: string, miniMatchFilter: string, absolutePathsBool: boolean = false): Promise<string[]> => {
  const done = plugins.smartpromise.defer<string[]>();
  // handle absolute miniMatchFilter
  let dirPath: string;
  if (plugins.path.isAbsolute(miniMatchFilter)) {
    dirPath = '/';
  } else {
    dirPath = dirPathArg;
  }
  const options = {
    cwd: dirPath,
    nodir: true,
    dot: true
  };
  plugins.glob(miniMatchFilter, options, (err, files: string[]) => {
    if (err) {
      console.log(err);
      done.reject(err);
    }
    done.resolve(files);
  });
  let fileList = await done.promise;
  if (absolutePathsBool) {
    fileList = fileList.map(filePath => {
      return plugins.path.resolve(plugins.path.join(dirPath, filePath));
    });
  }
  return fileList;
 };
--- a/ts/smartfile.interpreter.ts
+++ b/ts/smartfile.interpreter.ts
@ -1,8 +1,8 @@
-import * as plugins from './plugins.js';
+import plugins = require('./smartfile.plugins');
 export let filetype = (pathArg: string): string => {
-  const extName = plugins.path.extname(pathArg);
+  let extName = plugins.path.extname(pathArg);
-  const fileType = extName.replace(/\.([a-z]*)/, '$1'); // remove . form fileType
+  let fileType = extName.replace(/\.([a-z]*)/, '$1'); // remove . form fileType
  return fileType;
 };
@ -10,7 +10,7 @@ export let objectFile = (fileStringArg: string, fileTypeArg) => {
  switch (fileTypeArg) {
    case 'yml':
    case 'yaml':
-      return plugins.yaml.load(fileStringArg);
+      return plugins.yaml.safeLoad(fileStringArg);
    case 'json':
      return JSON.parse(fileStringArg);
    default:
--- a/ts/smartfile.memory.ts
+++ b/ts/smartfile.memory.ts
@ -1,8 +1,8 @@
-import * as plugins from './plugins.js';
+import plugins = require('./smartfile.plugins');
-import { SmartFile } from './classes.smartfile.js';
+import { Smartfile } from './smartfile.classes.smartfile';
-import * as smartfileFs from './fs.js';
+import * as smartfileFs from './smartfile.fs';
-import * as interpreter from './interpreter.js';
+
-import type { StreamFile } from './classes.streamfile.js';
+import SmartfileInterpreter = require('./smartfile.interpreter');
 /**
 * converts file to Object
@ -10,8 +10,8 @@ import type { StreamFile } from './classes.streamfile.js';
 * @param fileTypeArg
 * @returns {any|any}
 */
-export let toObject = (fileStringArg: string, fileTypeArg: string) => {
+export let toObject = function(fileStringArg: string, fileTypeArg: string) {
-  return interpreter.objectFile(fileStringArg, fileTypeArg);
+  return SmartfileInterpreter.objectFile(fileStringArg, fileTypeArg);
 };
 export interface IToFsOptions {
@ -25,11 +25,11 @@ export interface IToFsOptions {
 * @param fileBaseArg
 */
 export let toFs = async (
-  fileContentArg: string | Buffer | SmartFile | StreamFile,
+  fileContentArg: string | Smartfile,
-  filePathArg: string,
+  filePathArg,
  optionsArg: IToFsOptions = {}
 ) => {
-  const done = plugins.smartpromise.defer();
+  let done = plugins.smartpromise.defer();
  // check args
  if (!fileContentArg || !filePathArg) {
@ -37,27 +37,24 @@ export let toFs = async (
  }
  // prepare actual write action
-  let fileContent: string | Buffer;
+  let fileString: string;
  let fileEncoding: 'utf8' | 'binary' = 'utf8';
  let filePath: string = filePathArg;
  // handle Smartfile
-  if (fileContentArg instanceof SmartFile) {
+  if (fileContentArg instanceof Smartfile) {
-    fileContent = fileContentArg.contentBuffer;
+    let fileContentArg2: any = fileContentArg;
    fileString = fileContentArg.contentBuffer.toString();
    // handle options
    if (optionsArg.respectRelative) {
      filePath = plugins.path.join(filePath, fileContentArg.path);
    }
  } else if (Buffer.isBuffer(fileContentArg)) {
    fileContent = fileContentArg;
    fileEncoding = 'binary';
  } else if (typeof fileContentArg === 'string') {
-    fileContent = fileContentArg;
+    fileString = fileContentArg;
  } else {
    throw new Error('fileContent is neither string nor Smartfile');
  }
  await smartfileFs.ensureDir(plugins.path.parse(filePath).dir);
-  plugins.fsExtra.writeFile(filePath, fileContent, { encoding: fileEncoding }, done.resolve);
+  plugins.fsExtra.writeFile(filePath, fileString, { encoding: 'utf8' }, done.resolve);
  return await done.promise;
 };
@ -66,7 +63,7 @@ export let toFs = async (
 * @param fileArg
 * @param filePathArg
 */
-export const toFsSync = (fileArg: string, filePathArg: string) => {
+export let toFsSync = function(fileArg: string, filePathArg: string) {
  // function checks to abort if needed
  if (!fileArg || !filePathArg) {
    throw new Error('expected a valid arguments');
@ -74,7 +71,7 @@ export const toFsSync = (fileArg: string, filePathArg: string) => {
  // prepare actual write action
  let fileString: string;
-  const filePath: string = filePathArg;
+  let filePath: string = filePathArg;
  if (typeof fileArg !== 'string') {
    throw new Error('fileArg is not of type String.');
@ -84,11 +81,11 @@ export const toFsSync = (fileArg: string, filePathArg: string) => {
  plugins.fsExtra.writeFileSync(filePath, fileString, { encoding: 'utf8' });
 };
-export let smartfileArrayToFs = async (smartfileArrayArg: SmartFile[], dirArg: string) => {
+export let smartfileArrayToFs = async (smartfileArrayArg: Smartfile[], dirArg: string) => {
  await smartfileFs.ensureDir(dirArg);
-  for (const smartfile of smartfileArrayArg) {
+  for (let smartfile of smartfileArrayArg) {
    await toFs(smartfile, dirArg, {
-      respectRelative: true,
+      respectRelative: true
    });
  }
 };
--- a/ts/smartfile.plugins.ts
+++ b/ts/smartfile.plugins.ts
@ -0,0 +1,9 @@
 export import fs = require('fs');
 export import fsExtra = require('fs-extra');
 export let glob = require('glob');
 export import path = require('path');
 export import smartpromise = require('@pushrocks/smartpromise');
 export import smartrequest = require('@pushrocks/smartrequest');
 export import smartpath = require('@pushrocks/smartpath');
 export let vinylFile = require('vinyl-file');
 export let yaml = require('js-yaml');
--- a/ts/smartfile.remote.ts
+++ b/ts/smartfile.remote.ts
@ -0,0 +1,50 @@
 import plugins = require('./smartfile.plugins');
 import SmartfileInterpreter = require('./smartfile.interpreter');
 /* export let toFs = function (from: string, toPath: string) {
  let done = plugins.q.defer()
  let stream = plugins.smartrequest(from).pipe(plugins.fsExtra.createWriteStream(toPath))
  stream.on('finish', function () {
    done.resolve(toPath)
  })
  return done.promise
 } */
 /**
 *
 * @param fromArg
 * @returns {any}
 */
 export let toObject = function(fromArg: string) {
  let done = plugins.smartpromise.defer();
  plugins.smartrequest
    .request(fromArg, {
      method: 'get'
    })
    .then((res: any) => {
      if (res.statusCode === 200) {
        done.resolve(res.body);
      } else {
        console.log('could not get remote file from ' + fromArg);
        done.reject(new Error('could not get remote file from ' + fromArg));
      }
    });
  return done.promise;
 };
 /**
 *
 * @param fromArg
 * @returns {any}
 */
 export let toString = (fromArg: string) => {
  let done = plugins.smartpromise.defer();
  plugins.smartrequest.getBinary(fromArg).then((res: any) => {
    if (res.statusCode === 200) {
      done.resolve(res.body);
    } else {
      done.reject(new Error('could not get remote file from ' + fromArg));
    }
  });
  return done.promise;
 };
--- a/tsconfig.json
+++ b/tsconfig.json
@ -1,14 +0,0 @@
 {
  "compilerOptions": {
    "experimentalDecorators": true,
    "useDefineForClassFields": false,
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "esModuleInterop": true,
    "verbatimModuleSyntax": true
  },
  "exclude": [
    "dist_*/**/*.d.ts"
  ]
 }
--- a/tslint.json
+++ b/tslint.json
@ -0,0 +1,17 @@
 {
  "extends": ["tslint:latest", "tslint-config-prettier"],
  "rules": {
    "semicolon": [true, "always"],
    "no-console": false,
    "ordered-imports": false,
    "object-literal-sort-keys": false,
    "member-ordering": {
      "options":{
        "order": [
          "static-method"
        ]
      }
    }
  },
  "defaultSeverity": "warning"
 }