wip

* [deps]: Update typescript to v5.9.3

* Updated return types.

---------

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

.claude/CLAUDE.md

@@ -0,0 +1,203 @@
+# Bitwarden Directory Connector
+
+## Project Overview
+
+Directory Connector is a TypeScript application that synchronizes users and groups from directory services to Bitwarden organizations. It provides both a desktop GUI (built with Angular and Electron) and a CLI tool (bwdc).
+
+**Supported Directory Services:**
+
+- LDAP (Lightweight Directory Access Protocol) - includes Active Directory and general LDAP servers
+- Microsoft Entra ID (formerly Azure Active Directory)
+- Google Workspace
+- Okta
+- OneLogin
+
+**Technologies:**
+
+- TypeScript
+- Angular (GUI)
+- Electron (Desktop wrapper)
+- Node
+- Jest for testing
+
+## Code Architecture & Structure
+
+### Directory Organization
+
+```
+src/
+├── abstractions/       # Interface definitions (e.g., IDirectoryService)
+├── services/          # Business logic implementations for directory services, sync, auth
+├── models/            # Data models (UserEntry, GroupEntry, etc.)
+├── commands/          # CLI command implementations
+├── app/               # Angular GUI components
+└── utils/             # Test utilities and fixtures
+
+src-cli/               # CLI-specific code (imports common code from src/)
+
+jslib/                 # Legacy folder structure (mix of deprecated/unused and current code - new code should not be added here)
+```
+
+### Key Architectural Patterns
+
+1. **Abstractions = Interfaces**: All interfaces are defined in `/abstractions`
+2. **Services = Business Logic**: Implementations live in `/services`
+3. **Directory Service Pattern**: Each directory provider implements `IDirectoryService` interface
+4. **Separation of Concerns**: GUI (Angular app) and CLI (commands) share the same service layer
+
+## Development Conventions
+
+### Code Organization
+
+**File Naming:**
+
+- kebab-case for files: `ldap-directory.service.ts`
+- Descriptive names that reflect purpose
+
+**Class/Function Naming:**
+
+- PascalCase for classes and interfaces
+- camelCase for functions and variables
+- Descriptive names that indicate purpose
+
+**File Structure:**
+
+- Keep files focused on single responsibility
+- Create new service files for distinct directory integrations
+- Separate models into individual files when complex
+
+### TypeScript Conventions
+
+**Import Patterns:**
+
+- Use path aliases (`@/`) for project imports
+  - `@/` - project root
+  - `@/jslib/` - jslib folder
+- ESLint enforces alphabetized import ordering with newlines between groups
+
+**Type Safety:**
+
+- Avoid `any` types - use proper typing or `unknown` with type guards
+- Prefer interfaces for contracts, types for unions/intersections
+- Use strict null checks - handle `null` and `undefined` explicitly
+- Leverage TypeScript's type inference where appropriate
+
+**Configuration:**
+
+- Use configuration files or environment variables
+- Never hardcode URLs or configuration values
+
+## Security Best Practices
+
+**Credential Handling:**
+
+- Never log directory service credentials, API keys, or tokens
+- Use secure storage mechanisms for sensitive data
+- Credentials should never be hardcoded
+- Store credentials encrypted, never in plain text
+
+**Sensitive Data:**
+
+- User and group data from directories should be handled securely
+- Avoid exposing sensitive information in error messages
+- Sanitize data before logging
+- Be cautious with data persistence
+
+**Input Validation:**
+
+- Validate and sanitize data from external directory services
+- Check for injection vulnerabilities (LDAP injection, etc.)
+- Validate configuration inputs from users
+
+**API Security:**
+
+- Ensure authentication flows are implemented correctly
+- Verify SSL/TLS is used for all external connections
+- Check for secure token storage and refresh mechanisms
+
+## Error Handling
+
+**Best Practices:**
+
+1. **Try-catch for async operations** - Always wrap external API calls
+2. **Meaningful error messages** - Provide context for debugging
+3. **Error propagation** - Don't swallow errors silently
+4. **User-facing errors** - Separate user messages from developer logs
+
+## Performance Best Practices
+
+**Large Dataset Handling:**
+
+- Use pagination for large user/group lists
+- Avoid loading entire datasets into memory at once
+- Consider streaming or batch processing for large operations
+
+**API Rate Limiting:**
+
+- Respect rate limits for Microsoft Graph API, Google Admin SDK, etc.
+- Consider batching large API calls where necessary
+
+**Memory Management:**
+
+- Close connections and clean up resources
+- Remove event listeners when components are destroyed
+- Be cautious with caching large datasets
+
+## Testing
+
+**Framework:**
+
+- Jest with jest-preset-angular
+- jest-mock-extended for type-safe mocks with `mock<Type>()`
+
+**Test Organization:**
+
+- Tests colocated with source files
+- `*.spec.ts` - Unit tests for individual components/services
+- `*.integration.spec.ts` - Integration tests against live directory services
+- Test helpers located in `utils/` directory
+
+**Test Naming:**
+
+- Descriptive, human-readable test names
+- Example: `'should return empty array when no users exist in directory'`
+
+**Test Coverage:**
+
+- New features must include tests
+- Bug fixes should include regression tests
+- Changes to core sync logic or directory specific logic require integration tests
+
+**Testing Approach:**
+
+- **Unit tests**: Mock external API calls using jest-mock-extended
+- **Integration tests**: Use live directory services (Docker containers or configured cloud services)
+- Focus on critical paths (authentication, sync, data transformation)
+- Test error scenarios and edge cases (empty results, malformed data, connection failures), not just happy paths
+
+## Directory Service Patterns
+
+### IDirectoryService Interface
+
+All directory services implement this core interface with methods:
+
+- `getUsers()` - Retrieve users from directory and transform them into standard objects
+- `getGroups()` - Retrieve groups from directory and transform them into standard objects
+- Connection and authentication handling
+
+### Service-Specific Implementations
+
+Each directory service has unique authentication and query patterns:
+
+- **LDAP**: Direct LDAP queries, bind authentication
+- **Microsoft Entra ID**: Microsoft Graph API, OAuth tokens
+- **Google Workspace**: Google Admin SDK, service account credentials
+- **Okta/OneLogin**: REST APIs with API tokens
+
+## References
+
+- [Architectural Decision Records (ADRs)](https://contributing.bitwarden.com/architecture/adr/)
+- [Contributing Guidelines](https://contributing.bitwarden.com/contributing/)
+- [Code Style](https://contributing.bitwarden.com/contributing/code-style/)
+- [Security Whitepaper](https://bitwarden.com/help/bitwarden-security-white-paper/)
+- [Security Definitions](https://contributing.bitwarden.com/architecture/security/definitions)

.depcheckrc

@@ -0,0 +1 @@
+ignores: ["*-loader", "webpack-cli", "@types/jest"]

.eslintignore

@@ -1,10 +0,0 @@
-dist
-build
-build-cli
-webpack.cli.js
-webpack.main.js
-webpack.renderer.js
-
-**/node_modules
-
-**/jest.config.js

.eslintrc.json

@@ -1,32 +0,0 @@
-{
-  "root": true,
-  "env": {
-    "browser": true,
-    "node": true
-  },
-  "extends": ["./jslib/shared/eslintrc.json"],
-  "rules": {
-    "import/order": [
-      "error",
-      {
-        "alphabetize": {
-          "order": "asc"
-        },
-        "newlines-between": "always",
-        "pathGroups": [
-          {
-            "pattern": "jslib-*/**",
-            "group": "external",
-            "position": "after"
-          },
-          {
-            "pattern": "src/**/*",
-            "group": "parent",
-            "position": "before"
-          }
-        ],
-        "pathGroupsExcludedImportTypes": ["builtin"]
-      }
-    ]
-  }
-}

.github/CODEOWNERS

@@ -0,0 +1,19 @@
+# Please sort into logical groups with comment headers. Sort groups in order of specificity.
+# For example, default owners should always be the first group.
+# Sort lines alphabetically within these groups to avoid accidentally adding duplicates.
+#
+# https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners
+
+# Default file owners.
+* @bitwarden/team-admin-console-dev
+
+# Docker-related files
+**/Dockerfile @bitwarden/team-appsec @bitwarden/dept-bre
+**/*.dockerignore @bitwarden/team-appsec @bitwarden/dept-bre
+**/entrypoint.sh @bitwarden/team-appsec @bitwarden/dept-bre
+**/docker-compose.yml @bitwarden/team-appsec @bitwarden/dept-bre
+
+# Claude related files
+.claude/ @bitwarden/team-ai-sme
+.github/workflows/respond.yml @bitwarden/team-ai-sme
+.github/workflows/review-code.yml @bitwarden/team-ai-sme

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,14 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Feature Requests
+    url: https://community.bitwarden.com/c/feature-requests/
+    about: Request new features using the Community Forums. Please search existing feature requests before making a new one.
+  - name: Bitwarden Community Forums
+    url: https://community.bitwarden.com
+    about: Please visit the community forums for general community discussion, support and the development roadmap.
+  - name: Customer Support
+    url: https://bitwarden.com/contact/
+    about: Please contact our customer support for account issues and general customer support.
+  - name: Security Issues
+    url: https://hackerone.com/bitwarden
+    about: We use HackerOne to manage security disclosures.

.github/ISSUE_TEMPLATE/issue.yml

@@ -0,0 +1,111 @@
+name: Directory Connector Bug Report
+description: File a bug report
+title: "[DC] "
+labels: ["bug"]
+type: bug
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this bug report!
+
+        Please do not submit feature requests. The [Community Forums](https://community.bitwarden.com) has a section for submitting, voting for, and discussing product feature requests.
+  - type: textarea
+    id: reproduce
+    attributes:
+      label: Steps To Reproduce
+      description: How can we reproduce the behavior.
+      value: |
+        1. Go to '...'
+        2. Click on '....'
+        3. Scroll down to '....'
+        4. Click on '...'
+    validations:
+      required: true
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected Result
+      description: A clear and concise description of what you expected to happen.
+    validations:
+      required: true
+  - type: textarea
+    id: actual
+    attributes:
+      label: Actual Result
+      description: A clear and concise description of what is happening.
+    validations:
+      required: true
+  - type: textarea
+    id: screenshots
+    attributes:
+      label: Screenshots or Videos
+      description: If applicable, add screenshots and/or a short video to help explain your problem.
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: Additional Context
+      description: Add any other context about the problem here.
+  - type: dropdown
+    id: os
+    attributes:
+      label: Operating System
+      description: What operating system(s) are you seeing the problem on?
+      multiple: true
+      options:
+        - Windows
+        - macOS
+        - Linux
+        - Other operating system (please specify in "Additional Context" section)
+    validations:
+      required: true
+  - type: input
+    id: os-version
+    attributes:
+      label: Operating System Version
+      description: What version of the operating system(s) are you seeing the problem on?
+    validations:
+      required: true
+  - type: dropdown
+    id: directories
+    attributes:
+      label: Directory Service
+      description: What directory service(s) are you seeing the problem on?
+      multiple: true
+      options:
+        - LDAP - Active Directory
+        - Another LDAP implementation (please specify in "Additional Context" section)
+        - Microsoft Entra ID
+        - Google Workspace
+        - Okta Universal Directory
+        - OneLogin
+        - Other directory service (please specify in "Additional Context" section)
+    validations:
+      required: true
+  - type: dropdown
+    id: application-type
+    attributes:
+      label: Application Type
+      description: Which Directory Connector application(s) are you seeing the problem on?
+      multiple: true
+      options:
+        - GUI (the desktop application)
+        - CLI (the bwdc command line application)
+    validations:
+      required: true
+  - type: input
+    id: version
+    attributes:
+      label: Build Version
+      description: What version of our software are you running?
+    validations:
+      required: true
+  - type: checkboxes
+    id: issue-tracking-info
+    attributes:
+      label: Issue Tracking Info
+      description: |
+        Make sure to acknowledge the following before submitting your report!
+      options:
+        - label: I understand that work is tracked outside of Github. A PR will be linked to this issue should one be opened to address it, but Bitwarden doesn't use fields like "assigned", "milestone", or "project" to track progress.
+          required: true

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,33 +1,34 @@
-## Type of change
+## 🎟️ Tracking
 
-- [ ] Bug fix
-- [ ] New feature development
-- [ ] Tech debt (refactoring, code cleanup, dependency upgrades, etc)
-- [ ] Build/deploy pipeline (DevOps)
-- [ ] Other
+<!-- Paste the link to the Jira or GitHub issue or otherwise describe / point to where this change is coming from. -->
 
-## Objective
+## 📔 Objective
 
-<!--Describe what the purpose of this PR is. For example: what bug you're fixing or what new feature you're adding-->
+<!-- Describe what the purpose of this PR is, for example what bug you're fixing or new feature you're adding. -->
 
-## Code changes
+## 📸 Screenshots
 
-<!--Explain the changes you've made to each file or major component. This should help the reviewer understand your changes-->
-<!--Also refer to any related changes or PRs in other repositories-->
+<!-- Required for any UI changes; delete if not applicable. Use fixed width images for better display. -->
 
-- **file.ext:** Description of what was changed and why
+## ⏰ Reminders before review
 
-## Screenshots
+- Contributor guidelines followed
+- All formatters and local linters executed and passed
+- Written new unit and / or integration tests where applicable
+- Used internationalization (i18n) for all UI strings
+- CI builds passed
+- Communicated to DevOps any deployment requirements
+- Updated any necessary documentation (Confluence, contributing docs) or informed the documentation team
 
-<!--Required for any UI changes. Delete if not applicable-->
+## 🦮 Reviewer guidelines
 
-## Testing requirements
+<!-- Suggested interactions but feel free to use (or not) as you desire! -->
 
-<!--What functionality requires testing by QA? This includes testing new behavior and regression testing-->
-
-## Before you submit
-
-- [ ] I have checked for **linting** errors (`npm run lint`) (required)
-- [ ] I have added **unit tests** where it makes sense to do so (encouraged but not required)
-- [ ] This change requires a **documentation update** (notify the documentation team)
-- [ ] This change has particular **deployment requirements** (notify the DevOps team)
+- 👍 (`:+1:`) or similar for great changes
+- 📝 (`:memo:`) or ℹ️ (`:information_source:`) for notes or general info
+- ❓ (`:question:`) for questions
+- 🤔 (`:thinking:`) or 💭 (`:thought_balloon:`) for more open inquiry that's not quite a confirmed issue and could potentially benefit from discussion
+- 🎨 (`:art:`) for suggestions / improvements
+- ❌ (`:x:`) or ⚠️ (`:warning:`) for more significant problems or concerns needing attention
+- 🌱 (`:seedling:`) or ♻️ (`:recycle:`) for future improvements or indications of technical debt
+- ⛏ (`:pick:`) for minor or nitpick changes

.github/renovate.json5

@@ -0,0 +1,24 @@
+{
+  $schema: "https://docs.renovatebot.com/renovate-schema.json",
+  extends: ["github>bitwarden/renovate-config"],
+  enabledManagers: ["github-actions", "npm"],
+  packageRules: [
+    {
+      groupName: "gh minor",
+      matchManagers: ["github-actions"],
+      matchUpdateTypes: ["minor", "patch"],
+    },
+  ],
+  ignoreDeps: [
+    // yao-pkg is used to create a single executable application bundle for the CLI.
+    // It is a third party build of node which carries a high supply chain risk.
+    // This must be manually vetted by our appsec team before upgrading.
+    // It is excluded from renovate to avoid accidentally upgrading to a non-vetted version.
+    "@yao-pkg/pkg",
+    // googleapis uses ESM after 149.0.0 so we are not upgrading it until we have ESM support.
+    // They release new versions every couple of weeks so ignoring it at the dependency dashboard
+    // level is not sufficient.
+    // FIXME: remove and upgrade when we have ESM support.
+    "googleapis",
+  ],
+}

.github/workflows/build.yml

@@ -1,91 +1,83 @@
----
 name: Build
 
 on:
+  pull_request: {}
   push:
-    branches-ignore:
-      - 'l10n_master'
-    paths-ignore:
-      - '.github/workflows/**'
+    branches:
+      - "main"
+      - "rc"
+      - "hotfix-rc"
   workflow_dispatch: {}
 
+permissions:
+  contents: read
 
 jobs:
-  cloc:
-    name: CLOC
-    runs-on: ubuntu-20.04
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@a12a3943b4bdde767164f792f33f40b04645d846
-
-      - name: Set up CLOC
-        run: |
-          sudo apt update
-          sudo apt -y install cloc
-
-      - name: Print lines of code
-        run: cloc --include-lang TypeScript,JavaScript,HTML,Sass,CSS --vcs git
-
-
   setup:
     name: Setup
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
+    permissions:
+      contents: read
     outputs:
       package_version: ${{ steps.retrieve-version.outputs.package_version }}
+      node_version: ${{ steps.retrieve-node-version.outputs.node_version }}
     steps:
       - name: Checkout repo
-        uses: actions/checkout@a12a3943b4bdde767164f792f33f40b04645d846
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
 
       - name: Get Package Version
         id: retrieve-version
         run: |
-          PKG_VERSION=$(jq -r .version src/package.json)
-          echo "::set-output name=package_version::$PKG_VERSION"
+          PKG_VERSION=$(jq -r .version package.json)
+          echo "package_version=$PKG_VERSION" >> "$GITHUB_OUTPUT"
 
+      - name: Get Node Version
+        id: retrieve-node-version
+        run: |
+          NODE_NVMRC=$(cat .nvmrc)
+          NODE_VERSION=${NODE_NVMRC/v/''}
+          echo "node_version=$NODE_VERSION" >> "$GITHUB_OUTPUT"
 
   linux-cli:
     name: Build Linux CLI
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     needs: setup
     env:
       _PACKAGE_VERSION: ${{ needs.setup.outputs.package_version }}
-      _PKG_FETCH_NODE_VERSION: 16.13.0
-      _PKG_FETCH_VERSION: 3.2
+      _NODE_VERSION: ${{ needs.setup.outputs.node_version }}
+    permissions:
+      contents: read
     steps:
       - name: Checkout repo
-        uses: actions/checkout@a12a3943b4bdde767164f792f33f40b04645d846
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
 
       - name: Set up Node
-        uses: actions/setup-node@9ced9a43a244f3ac94f13bfd896db8c8f30da67a  # v3.0.0
+        uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
         with:
           cache: 'npm'
           cache-dependency-path: '**/package-lock.json'
-          node-version: '16'
+          node-version: ${{ env._NODE_VERSION }}
 
       - name: Update NPM
         run: |
           npm install -g node-gyp
-          node-gyp install $(node -v)
-
-      - name: Get pkg-fetch
-        run: |
-          cd $HOME
-          fetchedUrl="https://github.com/vercel/pkg-fetch/releases/download/v$_PKG_FETCH_VERSION/node-v$_PKG_FETCH_NODE_VERSION-linux-x64"
-
-          mkdir -p .pkg-cache/v$_PKG_FETCH_VERSION
-          wget $fetchedUrl -O "./.pkg-cache/v$_PKG_FETCH_VERSION/fetched-v$_PKG_FETCH_NODE_VERSION-linux-x64"
+          node-gyp install "$(node -v)"
 
       - name: Keytar
         run: |
-          keytarVersion=$(cat src/package.json | jq -r '.dependencies.keytar')
+          keytarVersion=$(cat package.json | jq -r '.dependencies.keytar')
           keytarTar="keytar-v$keytarVersion-napi-v3-linux-x64.tar"
 
           keytarTarGz="$keytarTar.gz"
           keytarUrl="https://github.com/atom/node-keytar/releases/download/v$keytarVersion/$keytarTarGz"
 
           mkdir -p ./keytar/linux
-          wget $keytarUrl -O ./keytar/linux/$keytarTarGz
-          tar -xvf ./keytar/linux/$keytarTarGz -C ./keytar/linux
+          wget "$keytarUrl" -O "./keytar/linux/$keytarTarGz"
+          tar -xvf "./keytar/linux/$keytarTarGz" -C ./keytar/linux
 
       - name: Install
         run: npm install
@@ -94,21 +86,19 @@ jobs:
         run: npm run dist:cli:lin
 
       - name: Zip
-        run: zip -j ./dist-cli/bwdc-linux-$_PACKAGE_VERSION.zip ./dist-cli/linux/bwdc ./keytar/linux/build/Release/keytar.node
-
-      - name: Create checksums
-        run: sha256sum ./dist-cli/bwdc-linux-$_PACKAGE_VERSION.zip | cut -d " " -f 1 > ./dist-cli/bwdc-linux-sha256-$_PACKAGE_VERSION.txt
+        run: zip -j "dist-cli/bwdc-linux-$_PACKAGE_VERSION.zip" "dist-cli/linux/bwdc" "keytar/linux/build/Release/keytar.node"
 
       - name: Version Test
         run: |
+          sudo apt-get update
           sudo apt install libsecret-1-0 dbus-x11 gnome-keyring
-          eval $(dbus-launch --sh-syntax)
+          eval "$(dbus-launch --sh-syntax)"
 
-          eval $(echo -n "" | /usr/bin/gnome-keyring-daemon --login)
-          eval $(/usr/bin/gnome-keyring-daemon --components=secrets --start)
+          eval "$(echo -n "" | /usr/bin/gnome-keyring-daemon --login)"
+          eval "$(/usr/bin/gnome-keyring-daemon --components=secrets --start)"
 
           mkdir -p test/linux
-          unzip ./dist-cli/bwdc-linux-$_PACKAGE_VERSION.zip -d ./test/linux
+          unzip "./dist-cli/bwdc-linux-$_PACKAGE_VERSION.zip" -d ./test/linux
 
           testVersion=$(./test/linux/bwdc -v)
 
@@ -121,63 +111,51 @@ jobs:
           fi
 
       - name: Upload Linux Zip to GitHub
-        uses: actions/upload-artifact@6673cd052c4cd6fcf4b4e6e60ea986c889389535
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: bwdc-linux-${{ env._PACKAGE_VERSION }}.zip
           path: ./dist-cli/bwdc-linux-${{ env._PACKAGE_VERSION }}.zip
           if-no-files-found: error
 
-      - name: Upload Linux checksum to GitHub
-        uses: actions/upload-artifact@6673cd052c4cd6fcf4b4e6e60ea986c889389535
-        with:
-          name: bwdc-linux-sha256-${{ env._PACKAGE_VERSION }}.txt
-          path: ./dist-cli/bwdc-linux-sha256-${{ env._PACKAGE_VERSION }}.txt
-          if-no-files-found: error
-
 
   macos-cli:
     name: Build Mac CLI
-    runs-on: macos-11
+    runs-on: macos-15-intel
     needs: setup
+    permissions:
+      contents: read
     env:
       _PACKAGE_VERSION: ${{ needs.setup.outputs.package_version }}
-      _PKG_FETCH_NODE_VERSION: 16.13.0
-      _PKG_FETCH_VERSION: 3.2
+      _NODE_VERSION: ${{ needs.setup.outputs.node_version }}
     steps:
       - name: Checkout repo
-        uses: actions/checkout@a12a3943b4bdde767164f792f33f40b04645d846
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
 
       - name: Set up Node
-        uses: actions/setup-node@9ced9a43a244f3ac94f13bfd896db8c8f30da67a  # v3.0.0
+        uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
         with:
           cache: 'npm'
           cache-dependency-path: '**/package-lock.json'
-          node-version: '16'
+          node-version: ${{ env._NODE_VERSION }}
 
       - name: Update NPM
         run: |
           npm install -g node-gyp
-          node-gyp install $(node -v)
-
-      - name: Get pkg-fetch
-        run: |
-          cd $HOME
-          fetchedUrl="https://github.com/vercel/pkg-fetch/releases/download/v$_PKG_FETCH_VERSION/node-v$_PKG_FETCH_NODE_VERSION-macos-x64"
-
-          mkdir -p .pkg-cache/v$_PKG_FETCH_VERSION
-          wget $fetchedUrl -O "./.pkg-cache/v$_PKG_FETCH_VERSION/fetched-v$_PKG_FETCH_NODE_VERSION-macos-x64"
+          node-gyp install "$(node -v)"
 
       - name: Keytar
         run: |
-          keytarVersion=$(cat src/package.json | jq -r '.dependencies.keytar')
+          keytarVersion=$(cat package.json | jq -r '.dependencies.keytar')
           keytarTar="keytar-v$keytarVersion-napi-v3-darwin-x64.tar"
 
           keytarTarGz="$keytarTar.gz"
           keytarUrl="https://github.com/atom/node-keytar/releases/download/v$keytarVersion/$keytarTarGz"
 
           mkdir -p ./keytar/macos
-          wget $keytarUrl -O ./keytar/macos/$keytarTarGz
-          tar -xvf ./keytar/macos/$keytarTarGz -C ./keytar/macos
+          wget "$keytarUrl" -O "./keytar/macos/$keytarTarGz"
+          tar -xvf "./keytar/macos/$keytarTarGz" -C ./keytar/macos
 
       - name: Install
         run: npm install
@@ -186,15 +164,12 @@ jobs:
         run: npm run dist:cli:mac
 
       - name: Zip
-        run: zip -j ./dist-cli/bwdc-macos-$_PACKAGE_VERSION.zip ./dist-cli/macos/bwdc ./keytar/macos/build/Release/keytar.node
-
-      - name: Create checksums
-        run: sha256sum ./dist-cli/bwdc-macos-$_PACKAGE_VERSION.zip | cut -d " " -f 1 > ./dist-cli/bwdc-macos-sha256-$_PACKAGE_VERSION.txt
+        run: zip -j "dist-cli/bwdc-macos-$_PACKAGE_VERSION.zip" "dist-cli/macos/bwdc" "keytar/macos/build/Release/keytar.node"
 
       - name: Version Test
         run: |
           mkdir -p test/macos
-          unzip ./dist-cli/bwdc-macos-$_PACKAGE_VERSION.zip -d ./test/macos
+          unzip "./dist-cli/bwdc-macos-$_PACKAGE_VERSION.zip" -d ./test/macos
 
           testVersion=$(./test/macos/bwdc -v)
 
@@ -207,64 +182,48 @@ jobs:
           fi
 
       - name: Upload Mac Zip to GitHub
-        uses: actions/upload-artifact@6673cd052c4cd6fcf4b4e6e60ea986c889389535
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: bwdc-macos-${{ env._PACKAGE_VERSION }}.zip
           path: ./dist-cli/bwdc-macos-${{ env._PACKAGE_VERSION }}.zip
           if-no-files-found: error
 
-      - name: Upload Mac checksum to GitHub
-        uses: actions/upload-artifact@6673cd052c4cd6fcf4b4e6e60ea986c889389535
-        with:
-          name: bwdc-macos-sha256-${{ env._PACKAGE_VERSION }}.txt
-          path: ./dist-cli/bwdc-macos-sha256-${{ env._PACKAGE_VERSION }}.txt
-          if-no-files-found: error
-
 
   windows-cli:
     name: Build Windows CLI
-    runs-on: windows-2019
+    runs-on: windows-2022
     needs: setup
+    permissions:
+      contents: read
     env:
       _PACKAGE_VERSION: ${{ needs.setup.outputs.package_version }}
-      _WIN_PKG_FETCH_VERSION: 16.13.0
-      _WIN_PKG_VERSION: 3.2
+      _NODE_VERSION: ${{ needs.setup.outputs.node_version }}
     steps:
       - name: Checkout repo
-        uses: actions/checkout@a12a3943b4bdde767164f792f33f40b04645d846
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
 
       - name: Setup Windows builder
         run: |
           choco install checksum --no-progress
-          choco install reshack --no-progress
 
       - name: Set up Node
-        uses: actions/setup-node@9ced9a43a244f3ac94f13bfd896db8c8f30da67a  # v3.0.0
+        uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
         with:
           cache: 'npm'
           cache-dependency-path: '**/package-lock.json'
-          node-version: '16'
+          node-version: ${{ env._NODE_VERSION }}
 
       - name: Update NPM
         run: |
           npm install -g node-gyp
           node-gyp install $(node -v)
 
-      - name: Get pkg-fetch
-        shell: pwsh
-        run: |
-          cd $HOME
-          $fetchedUrl = "https://github.com/vercel/pkg-fetch/releases/download/v$env:_WIN_PKG_VERSION/node-v$env:_WIN_PKG_FETCH_VERSION-win-x64"
-
-          New-Item -ItemType directory -Path ./.pkg-cache
-          New-Item -ItemType directory -Path ./.pkg-cache/v$env:_WIN_PKG_VERSION
-          Invoke-RestMethod -Uri $fetchedUrl `
-            -OutFile "./.pkg-cache/v$env:_WIN_PKG_VERSION/fetched-v$env:_WIN_PKG_FETCH_VERSION-win-x64"
-
       - name: Keytar
         shell: pwsh
         run: |
-          $keytarVersion = (Get-Content -Raw -Path ./src/package.json | ConvertFrom-Json).dependencies.keytar
+          $keytarVersion = (Get-Content -Raw -Path ./package.json | ConvertFrom-Json).dependencies.keytar
           $keytarTar = "keytar-v${keytarVersion}-napi-v3-{0}-x64.tar"
           $keytarTarGz = "${keytarTar}.gz"
           $keytarUrl = "https://github.com/atom/node-keytar/releases/download/v${keytarVersion}/${keytarTarGz}"
@@ -277,54 +236,6 @@ jobs:
 
           7z e "./keytar/windows/$($keytarTar -f "win32")" -o"./keytar/windows"
 
-      - name: Setup Version Info
-        shell: pwsh
-        run: |
-          $major, $minor, $patch = $env:_PACKAGE_VERSION.split('.')
-
-          $versionInfo = @"
-
-          1 VERSIONINFO
-          FILEVERSION $major,$minor,$patch,0
-          PRODUCTVERSION $major,$minor,$patch,0
-          FILEOS 0x40004
-          FILETYPE 0x1
-          {
-          BLOCK "StringFileInfo"
-          {
-            BLOCK "040904b0"
-            {
-              VALUE "CompanyName", "Bitwarden Inc."
-              VALUE "ProductName", "Bitwarden"
-              VALUE "FileDescription", "Bitwarden Directory Connector CLI"
-              VALUE "FileVersion", "$env:_PACKAGE_VERSION"
-              VALUE "ProductVersion", "$env:_PACKAGE_VERSION"
-              VALUE "OriginalFilename", "bwdc.exe"
-              VALUE "InternalName", "bwdc"
-              VALUE "LegalCopyright", "Copyright Bitwarden Inc."
-            }
-          }
-
-          BLOCK "VarFileInfo"
-          {
-            VALUE "Translation", 0x0409 0x04B0
-          }
-          }
-          "@
-
-          $versionInfo | Out-File ./version-info.rc
-
-      - name: Resource Hacker
-        shell: cmd
-        run: |
-          set PATH=%PATH%;C:\Program Files (x86)\Resource Hacker
-          set WIN_PKG=C:\Users\runneradmin\.pkg-cache\v%_WIN_PKG_VERSION%\fetched-v%_WIN_PKG_FETCH_VERSION%-win-x64
-          set WIN_PKG_BUILT=C:\Users\runneradmin\.pkg-cache\v%_WIN_PKG_VERSION%\built-v%_WIN_PKG_FETCH_VERSION%-win-x64
-
-          ResourceHacker -open %WIN_PKG% -save %WIN_PKG% -action delete -mask ICONGROUP,1,
-          ResourceHacker -open version-info.rc -save version-info.res -action compile
-          ResourceHacker -open %WIN_PKG% -save %WIN_PKG% -action addoverwrite -resource version-info.res
-
       - name: Install
         run: npm install
 
@@ -333,117 +244,122 @@ jobs:
 
       - name: Zip
         shell: cmd
-        run: 7z a ./dist-cli/bwdc-windows-%_PACKAGE_VERSION%.zip ./dist-cli/windows/bwdc.exe ./keytar/windows/keytar.node
+        run: 7z a .\dist-cli\bwdc-windows-%_PACKAGE_VERSION%.zip .\dist-cli\windows\bwdc.exe .\keytar\windows\keytar.node
 
       - name: Version Test
+        shell: pwsh
         run: |
-          Expand-Archive -Path "./dist-cli/bwdc-windows-${env:_PACKAGE_VERSION}.zip" -DestinationPath "./test/windows"
-          $testVersion = Invoke-Expression '& ./test/windows/bwdc.exe -v'
-          echo "version: $env:_PACKAGE_VERSION"
+          Expand-Archive -Path "dist-cli\bwdc-windows-$env:_PACKAGE_VERSION.zip" -DestinationPath "test\windows"
+          $testVersion = Invoke-Expression '& .\test\windows\bwdc.exe -v'
+          echo "version: ${env:_PACKAGE_VERSION}"
           echo "testVersion: $testVersion"
-          if($testVersion -ne $env:_PACKAGE_VERSION) {
+          if ($testVersion -ne ${env:_PACKAGE_VERSION}) {
             Throw "Version test failed."
           }
 
-      - name: Create checksums
-        run: |
-          checksum -f="./dist-cli/bwdc-windows-${env:_PACKAGE_VERSION}.zip" `
-            -t sha256 | Out-File ./dist-cli/bwdc-windows-sha256-${env:_PACKAGE_VERSION}.txt
-
       - name: Upload Windows Zip to GitHub
-        uses: actions/upload-artifact@6673cd052c4cd6fcf4b4e6e60ea986c889389535
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: bwdc-windows-${{ env._PACKAGE_VERSION }}.zip
           path: ./dist-cli/bwdc-windows-${{ env._PACKAGE_VERSION }}.zip
           if-no-files-found: error
 
-      - name: Upload Windows checksum to GitHub
-        uses: actions/upload-artifact@6673cd052c4cd6fcf4b4e6e60ea986c889389535
-        with:
-          name: bwdc-windows-sha256-${{ env._PACKAGE_VERSION }}.txt
-          path: ./dist-cli/bwdc-windows-sha256-${{ env._PACKAGE_VERSION }}.txt
-          if-no-files-found: error
-
 
   windows-gui:
     name: Build Windows GUI
-    runs-on: windows-2019
+    runs-on: windows-2022
     needs: setup
+    permissions:
+      contents: read
+      id-token: write
     env:
+      NODE_OPTIONS: --max_old_space_size=4096
       _PACKAGE_VERSION: ${{ needs.setup.outputs.package_version }}
+      _NODE_VERSION: ${{ needs.setup.outputs.node_version }}
+      HUSKY: 0
     steps:
       - name: Checkout repo
-        uses: actions/checkout@a12a3943b4bdde767164f792f33f40b04645d846
-
-      - name: Set up .NET
-        uses: actions/setup-dotnet@9211491ffb35dd6a6657ca4f45d43dfe6e97c829
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
         with:
-          dotnet-version: "3.1.x"
+          persist-credentials: false
 
       - name: Set up Node
-        uses: actions/setup-node@9ced9a43a244f3ac94f13bfd896db8c8f30da67a  # v3.0.0
+        uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
         with:
           cache: 'npm'
           cache-dependency-path: '**/package-lock.json'
-          node-version: '16'
+          node-version: ${{ env._NODE_VERSION }}
 
       - name: Update NPM
         run: |
           npm install -g node-gyp
           node-gyp install $(node -v)
 
-      - name: Set Node options
-        run: echo "NODE_OPTIONS=--max_old_space_size=4096" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
-        shell: pwsh
-
       - name: Print environment
         run: |
           node --version
           npm --version
-          dotnet --version
 
       - name: Install AST
-        uses: bitwarden/gh-actions/install-ast@f135c42c8596cb535c5bcb7523c0b2eef89709ac
+        run: dotnet tool install --global AzureSignTool --version 4.0.1
 
       - name: Install Node dependencies
         run: npm install
 
-      # - name: Run linter
-      #   run: npm run lint
+      - name: Log in to Azure
+        uses: bitwarden/gh-actions/azure-login@main
+        with:
+          subscription_id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
+          tenant_id: ${{ secrets.AZURE_TENANT_ID }}
+          client_id: ${{ secrets.AZURE_CLIENT_ID }}
+
+      - name: Retrieve secrets
+        id: retrieve-secrets
+        uses: bitwarden/gh-actions/get-keyvault-secrets@main
+        with:
+          keyvault: "bitwarden-ci"
+          secrets: "code-signing-vault-url,
+            code-signing-client-id,
+            code-signing-tenant-id,
+            code-signing-client-secret,
+            code-signing-cert-name"
+
+      - name: Log out from Azure
+        uses: bitwarden/gh-actions/azure-logout@main
 
       - name: Build & Sign
         run: npm run dist:win
         env:
           ELECTRON_BUILDER_SIGN: 1
-          SIGNING_VAULT_URL: ${{ secrets.SIGNING_VAULT_URL }}
-          SIGNING_CLIENT_ID: ${{ secrets.SIGNING_CLIENT_ID }}
-          SIGNING_TENANT_ID: ${{ secrets.SIGNING_TENANT_ID }}
-          SIGNING_CLIENT_SECRET: ${{ secrets.SIGNING_CLIENT_SECRET }}
-          SIGNING_CERT_NAME: ${{ secrets.SIGNING_CERT_NAME }}
+          SIGNING_VAULT_URL: ${{ steps.retrieve-secrets.outputs.code-signing-vault-url }}
+          SIGNING_CLIENT_ID: ${{ steps.retrieve-secrets.outputs.code-signing-client-id }}
+          SIGNING_TENANT_ID: ${{ steps.retrieve-secrets.outputs.code-signing-tenant-id }}
+          SIGNING_CLIENT_SECRET: ${{ steps.retrieve-secrets.outputs.code-signing-client-secret }}
+          SIGNING_CERT_NAME: ${{ steps.retrieve-secrets.outputs.code-signing-cert-name }}
 
       - name: Upload Portable Executable to GitHub
-        uses: actions/upload-artifact@6673cd052c4cd6fcf4b4e6e60ea986c889389535
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: Bitwarden-Connector-Portable-${{ env._PACKAGE_VERSION }}.exe
           path: ./dist/Bitwarden-Connector-Portable-${{ env._PACKAGE_VERSION }}.exe
           if-no-files-found: error
 
       - name: Upload Installer Executable to GitHub
-        uses: actions/upload-artifact@6673cd052c4cd6fcf4b4e6e60ea986c889389535
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: Bitwarden-Connector-Installer-${{ env._PACKAGE_VERSION }}.exe
           path: ./dist/Bitwarden-Connector-Installer-${{ env._PACKAGE_VERSION }}.exe
           if-no-files-found: error
 
       - name: Upload Installer Executable Blockmap to GitHub
-        uses: actions/upload-artifact@6673cd052c4cd6fcf4b4e6e60ea986c889389535
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: Bitwarden-Connector-Installer-${{ env._PACKAGE_VERSION }}.exe.blockmap
           path: ./dist/Bitwarden-Connector-Installer-${{ env._PACKAGE_VERSION }}.exe.blockmap
           if-no-files-found: error
 
       - name: Upload latest auto-update artifact
-        uses: actions/upload-artifact@6673cd052c4cd6fcf4b4e6e60ea986c889389535
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: latest.yml
           path: ./dist/latest.yml
@@ -452,28 +368,32 @@ jobs:
 
   linux-gui:
     name: Build Linux GUI
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     needs: setup
+    permissions:
+      contents: read
     env:
+      NODE_OPTIONS: --max_old_space_size=4096
       _PACKAGE_VERSION: ${{ needs.setup.outputs.package_version }}
+      _NODE_VERSION: ${{ needs.setup.outputs.node_version }}
+      HUSKY: 0
     steps:
       - name: Checkout repo
-        uses: actions/checkout@a12a3943b4bdde767164f792f33f40b04645d846
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
 
       - name: Set up Node
-        uses: actions/setup-node@9ced9a43a244f3ac94f13bfd896db8c8f30da67a  # v3.0.0
+        uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
         with:
           cache: 'npm'
           cache-dependency-path: '**/package-lock.json'
-          node-version: '16'
+          node-version: ${{ env._NODE_VERSION }}
 
       - name: Update NPM
         run: |
           npm install -g node-gyp
-          node-gyp install $(node -v)
-
-      - name: Set Node options
-        run: echo "NODE_OPTIONS=--max_old_space_size=4096" >> $GITHUB_ENV
+          node-gyp install "$(node -v)"
 
       - name: Set up environment
         run: |
@@ -491,14 +411,14 @@ jobs:
         run: npm run dist:lin
 
       - name: Upload AppImage
-        uses: actions/upload-artifact@6673cd052c4cd6fcf4b4e6e60ea986c889389535
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: Bitwarden-Connector-${{ env._PACKAGE_VERSION }}-x86_64.AppImage
           path: ./dist/Bitwarden-Connector-${{ env._PACKAGE_VERSION }}-x86_64.AppImage
           if-no-files-found: error
 
       - name: Upload latest auto-update artifact
-        uses: actions/upload-artifact@6673cd052c4cd6fcf4b4e6e60ea986c889389535
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: latest-linux.yml
           path: ./dist/latest-linux.yml
@@ -507,28 +427,33 @@ jobs:
 
   macos-gui:
     name: Build MacOS GUI
-    runs-on: macos-11
+    runs-on: macos-15-intel
     needs: setup
+    permissions:
+      contents: read
+      id-token: write
     env:
+      NODE_OPTIONS: --max_old_space_size=4096
       _PACKAGE_VERSION: ${{ needs.setup.outputs.package_version }}
+      _NODE_VERSION: ${{ needs.setup.outputs.node_version }}
+      HUSKY: 0
     steps:
       - name: Checkout repo
-        uses: actions/checkout@a12a3943b4bdde767164f792f33f40b04645d846
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
 
       - name: Set up Node
-        uses: actions/setup-node@9ced9a43a244f3ac94f13bfd896db8c8f30da67a  # v3.0.0
+        uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
         with:
           cache: 'npm'
           cache-dependency-path: '**/package-lock.json'
-          node-version: '16'
+          node-version: ${{ env._NODE_VERSION }}
 
       - name: Update NPM
         run: |
           npm install -g node-gyp
-          node-gyp install $(node -v)
-
-      - name: Set Node options
-        run: echo "NODE_OPTIONS=--max_old_space_size=4096" >> $GITHUB_ENV
+          node-gyp install "$(node -v)"
 
       - name: Print environment
         run: |
@@ -536,50 +461,61 @@ jobs:
           npm --version
           echo "GitHub ref: $GITHUB_REF"
           echo "GitHub event: $GITHUB_EVENT"
-        shell: bash
 
-      - name: Decrypt secrets
-        env:
-          DECRYPT_FILE_PASSWORD: ${{ secrets.DECRYPT_FILE_PASSWORD }}
-        shell: bash
+      - name: Log in to Azure
+        uses: bitwarden/gh-actions/azure-login@main
+        with:
+          subscription_id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
+          tenant_id: ${{ secrets.AZURE_TENANT_ID }}
+          client_id: ${{ secrets.AZURE_CLIENT_ID }}
+
+      - name: Get Azure Key Vault secrets
+        id: get-kv-secrets
+        uses: bitwarden/gh-actions/get-keyvault-secrets@main
+        with:
+          keyvault: gh-directory-connector
+          secrets: "KEYCHAIN-PASSWORD,APP-STORE-CONNECT-AUTH-KEY,APP-STORE-CONNECT-TEAM-ISSUER"
+
+      - name: Get certificates
         run: |
-          mkdir -p $HOME/secrets
+          mkdir -p "$HOME/certificates"
 
-          gpg --quiet --batch --yes --decrypt --passphrase="$DECRYPT_FILE_PASSWORD" \
-            --output "$HOME/secrets/devid-app-cert.p12" \
-            "$GITHUB_WORKSPACE/.github/secrets/devid-app-cert.p12.gpg"
+          az keyvault secret show --id https://bitwarden-ci.vault.azure.net/certificates/devid-app-cert |
+            jq -r .value | base64 -d > "$HOME/certificates/devid-app-cert.p12"
 
-          gpg --quiet --batch --yes --decrypt --passphrase="$DECRYPT_FILE_PASSWORD" \
-            --output "$HOME/secrets/devid-installer-cert.p12" \
-            "$GITHUB_WORKSPACE/.github/secrets/devid-installer-cert.p12.gpg"
+          az keyvault secret show --id https://bitwarden-ci.vault.azure.net/certificates/devid-installer-cert |
+            jq -r .value | base64 -d > "$HOME/certificates/devid-installer-cert.p12"
 
-          gpg --quiet --batch --yes --decrypt --passphrase="$DECRYPT_FILE_PASSWORD" \
-            --output "$HOME/secrets/macdev-cert.p12" \
-            "$GITHUB_WORKSPACE/.github/secrets/macdev-cert.p12.gpg"
+          az keyvault secret show --id https://bitwarden-ci.vault.azure.net/certificates/macdev-cert |
+            jq -r .value | base64 -d > "$HOME/certificates/macdev-cert.p12"
+
+      - name: Log out from Azure
+        uses: bitwarden/gh-actions/azure-logout@main
 
       - name: Set up keychain
         env:
-          KEYCHAIN_PASSWORD: ${{ secrets.KEYCHAIN_PASSWORD }}
-          DEVID_CERT_PASSWORD: ${{ secrets.DEVID_CERT_PASSWORD }}
-          MACDEV_CERT_PASSWORD: ${{ secrets.MACDEV_CERT_PASSWORD }}
-        shell: bash
+          KEYCHAIN_PASSWORD: ${{ steps.get-kv-secrets.outputs.KEYCHAIN-PASSWORD }}
         run: |
-          security create-keychain -p $KEYCHAIN_PASSWORD build.keychain
+          security create-keychain -p "$KEYCHAIN_PASSWORD" build.keychain
           security default-keychain -s build.keychain
-          security unlock-keychain -p $KEYCHAIN_PASSWORD build.keychain
+          security unlock-keychain -p "$KEYCHAIN_PASSWORD" build.keychain
           security set-keychain-settings -lut 1200 build.keychain
-          security import "$HOME/secrets/devid-app-cert.p12" -k build.keychain -P $DEVID_CERT_PASSWORD \
+
+          security import "$HOME/certificates/devid-app-cert.p12" -k build.keychain -P "" \
             -T /usr/bin/codesign -T /usr/bin/security -T /usr/bin/productbuild
-          security import "$HOME/secrets/devid-installer-cert.p12" -k build.keychain -P $DEVID_CERT_PASSWORD \
+
+          security import "$HOME/certificates/devid-installer-cert.p12" -k build.keychain -P "" \
             -T /usr/bin/codesign -T /usr/bin/security -T /usr/bin/productbuild
-          security import "$HOME/secrets/macdev-cert.p12" -k build.keychain -P $MACDEV_CERT_PASSWORD \
+
+          security import "$HOME/certificates/macdev-cert.p12" -k build.keychain -P "" \
             -T /usr/bin/codesign -T /usr/bin/security -T /usr/bin/productbuild
-          security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k $KEYCHAIN_PASSWORD build.keychain
+
+          security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k "$KEYCHAIN_PASSWORD" build.keychain
 
       - name: Load package version
         run: |
           $rootPath = $env:GITHUB_WORKSPACE;
-          $packageVersion = (Get-Content -Raw -Path $rootPath\src\package.json | ConvertFrom-Json).version;
+          $packageVersion = (Get-Content -Raw -Path "$rootPath\package.json" | ConvertFrom-Json).version;
 
           Write-Output "Setting package version to $packageVersion";
           Write-Output "PACKAGE_VERSION=$packageVersion" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append;
@@ -588,44 +524,46 @@ jobs:
       - name: Install Node dependencies
         run: npm install
 
-      # - name: Run linter
-      #   run: npm run lint
+      - name: Set up private auth key
+        env:
+          _APP_STORE_CONNECT_AUTH_KEY: ${{ steps.get-kv-secrets.outputs.APP-STORE-CONNECT-AUTH-KEY }}
+        run: |
+          mkdir ~/private_keys
+          cat << EOF > ~/private_keys/AuthKey_UFD296548T.p8
+          ${_APP_STORE_CONNECT_AUTH_KEY}
+          EOF
 
       - name: Build application
         run: npm run dist:mac
         env:
-          APPLE_ID_USERNAME: ${{ secrets.APPLE_ID_USERNAME }}
-          APPLE_ID_PASSWORD: ${{ secrets.APPLE_ID_PASSWORD }}
-
-      - name: Rename Zip Artifact
-        run: |
-          cd dist
-          mv "Bitwarden Directory Connector-${{ env._PACKAGE_VERSION }}-mac.zip" \
-             "Bitwarden-Connector-${{ env._PACKAGE_VERSION }}-mac.zip"
+          APP_STORE_CONNECT_TEAM_ISSUER: ${{ steps.get-kv-secrets.outputs.APP-STORE-CONNECT-TEAM-ISSUER }}
+          APP_STORE_CONNECT_AUTH_KEY: UFD296548T
+          APP_STORE_CONNECT_AUTH_KEY_PATH: ~/private_keys/AuthKey_UFD296548T.p8
+          CSC_FOR_PULL_REQUEST: true
 
       - name: Upload .zip artifact
-        uses: actions/upload-artifact@6673cd052c4cd6fcf4b4e6e60ea986c889389535
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: Bitwarden-Connector-${{ env._PACKAGE_VERSION }}-mac.zip
           path: ./dist/Bitwarden-Connector-${{ env._PACKAGE_VERSION }}-mac.zip
           if-no-files-found: error
 
       - name: Upload .dmg artifact
-        uses: actions/upload-artifact@6673cd052c4cd6fcf4b4e6e60ea986c889389535
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: Bitwarden-Connector-${{ env._PACKAGE_VERSION }}.dmg
           path: ./dist/Bitwarden-Connector-${{ env._PACKAGE_VERSION }}.dmg
           if-no-files-found: error
 
       - name: Upload .dmg Blockmap artifact
-        uses: actions/upload-artifact@6673cd052c4cd6fcf4b4e6e60ea986c889389535
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: Bitwarden-Connector-${{ env._PACKAGE_VERSION }}.dmg.blockmap
           path: ./dist/Bitwarden-Connector-${{ env._PACKAGE_VERSION }}.dmg.blockmap
           if-no-files-found: error
 
       - name: Upload latest auto-update artifact
-        uses: actions/upload-artifact@6673cd052c4cd6fcf4b4e6e60ea986c889389535
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: latest-mac.yml
           path: ./dist/latest-mac.yml
@@ -634,9 +572,8 @@ jobs:
 
   check-failures:
     name: Check for failures
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     needs:
-      - cloc
       - setup
       - linux-cli
       - macos-cli
@@ -644,53 +581,38 @@ jobs:
       - windows-gui
       - linux-gui
       - macos-gui
+    permissions:
+      id-token: write
     steps:
       - name: Check if any job failed
-        if: ${{ (github.ref == 'refs/heads/master') || (github.ref == 'refs/heads/rc') }}
-        env:
-          CLOC_STATUS: ${{ needs.cloc.result }}
-          SETUP_STATUS: ${{ needs.setup.result }}
-          LINUX_CLI_STATUS: ${{ needs.linux-cli.result }}
-          MACOS_CLI_STATUS: ${{ needs.macos-cli.result }}
-          WINDOWS_CLI_STATUS: ${{ needs.windows-cli.result }}
-          WINDOWS_GUI_STATUS: ${{ needs.windows-gui.result }}
-          LINUX_GUI_STATUS: ${{ needs.linux-gui.result }}
-          MACOS_GUI_STATUS: ${{ needs.macos-gui.result }}
-        run: |
-          if [ "$CLOC_STATUS" = "failure" ]; then
-              exit 1
-          elif [ "$SETUP_STATUS" = "failure" ]; then
-              exit 1
-          elif [ "$LINUX_CLI_STATUS" = "failure" ]; then
-              exit 1
-          elif [ "$MACOS_CLI_STATUS" = "failure" ]; then
-              exit 1
-          elif [ "$WINDOWS_CLI_STATUS" = "failure" ]; then
-              exit 1
-          elif [ "$WINDOWS_GUI_STATUS" = "failure" ]; then
-              exit 1
-          elif [ "$LINUX_GUI_STATUS" = "failure" ]; then
-              exit 1
-          elif [ "$MACOS_GUI_STATUS" = "failure" ]; then
-              exit 1
-          fi
+        if: |
+          (github.ref == 'refs/heads/main'
+          || github.ref == 'refs/heads/rc'
+          || github.ref == 'refs/heads/hotfix-rc')
+          && contains(needs.*.result, 'failure')
+        run: exit 1
 
-      - name: Login to Azure - Prod Subscription
-        uses: Azure/login@1f63701bf3e6892515f1b7ce2d2bf1708b46beaf
+      - name: Log in to Azure
         if: failure()
+        uses: bitwarden/gh-actions/azure-login@main
         with:
-          creds: ${{ secrets.AZURE_PROD_KV_CREDENTIALS }}
+          subscription_id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
+          tenant_id: ${{ secrets.AZURE_TENANT_ID }}
+          client_id: ${{ secrets.AZURE_CLIENT_ID }}
 
       - name: Retrieve secrets
         id: retrieve-secrets
-        uses: Azure/get-keyvault-secrets@b5c723b9ac7870c022b8c35befe620b7009b336f
+        uses: bitwarden/gh-actions/get-keyvault-secrets@main
         if: failure()
         with:
-          keyvault: "bitwarden-prod-kv"
+          keyvault: "bitwarden-ci"
           secrets: "devops-alerts-slack-webhook-url"
 
+      - name: Log out from Azure
+        uses: bitwarden/gh-actions/azure-logout@main
+
       - name: Notify Slack on failure
-        uses: act10ns/slack@da3191ebe2e67f49b46880b4633f5591a96d1d33
+        uses: act10ns/slack@44541246747a30eb3102d87f7a4cc5471b0ffb7d # v2.1.0
         if: failure()
         env:
           SLACK_WEBHOOK_URL: ${{ steps.retrieve-secrets.outputs.devops-alerts-slack-webhook-url }}

.github/workflows/enforce-labels.yml

@@ -1,16 +1,18 @@
----
 name: Enforce PR labels
 
 on:
   pull_request:
     types: [labeled, unlabeled, opened, edited, synchronize]
+permissions:
+  contents: read
+  pull-requests: read
 jobs:
   enforce-label:
     name: EnforceLabel
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     steps:
       - name: Enforce Label
-        uses: yogevbd/enforce-label-action@8d1e1709b1011e6d90400a0e6cf7c0b77aa5efeb
+        uses: yogevbd/enforce-label-action@a3c219da6b8fa73f6ba62b68ff09c469b3a1c024 # 2.2.2
         with:
           BANNED_LABELS: "hold"
           BANNED_LABELS_DESCRIPTION: "PRs on hold cannot be merged"

.github/workflows/integration-test.yml

@@ -0,0 +1,146 @@
+name: Integration Testing
+
+on:
+  workflow_dispatch:
+  # Integration tests are slow, so only run them if relevant files have changed.
+  # This is done at the workflow level and at the job level.
+  # Make sure these triggers stay consistent with the 'changed-files' job.
+  push:
+    branches:
+      - 'main'
+      - 'rc'
+    paths:
+      - ".github/workflows/integration-test.yml" # this file
+      - "docker-compose.yml" # any change to Docker configuration
+      - "package.json" # dependencies
+      - "utils/**" # any change to test fixtures
+      - "src/services/sync.service.ts" # core sync service used by all directory services
+      - "src/services/directory-services/ldap-directory.service*" # LDAP directory service
+      - "src/services/directory-services/gsuite-directory.service*" # Google Workspace directory service
+      # Add directory services here as we add test coverage
+  pull_request:
+    paths:
+      - ".github/workflows/integration-test.yml" # this file
+      - "docker-compose.yml" # any change to Docker configuration
+      - "package.json" # dependencies
+      - "utils/**" # any change to test fixtures
+      - "src/services/sync.service.ts" # core sync service used by all directory services
+      - "src/services/directory-services/ldap-directory.service*" # LDAP directory service
+      - "src/services/directory-services/gsuite-directory.service*" # Google Workspace directory service
+      # Add directory services here as we add test coverage
+permissions:
+  contents: read
+  checks: write # required by dorny/test-reporter to upload its results
+  id-token: write # required to use OIDC to login to Azure Key Vault
+jobs:
+  testing:
+    name: Run tests
+    if: ${{ startsWith(github.head_ref, 'version_bump_') == false }}
+    runs-on: ubuntu-22.04
+
+    steps:
+      - name: Check out repo
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
+
+      - name: Get Node version
+        id: retrieve-node-version
+        run: |
+          NODE_NVMRC=$(cat .nvmrc)
+          NODE_VERSION=${NODE_NVMRC/v/''}
+          echo "node_version=$NODE_VERSION" >> "$GITHUB_OUTPUT"
+
+      - name: Set up Node
+        uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+        with:
+          cache: 'npm'
+          cache-dependency-path: '**/package-lock.json'
+          node-version: ${{ steps.retrieve-node-version.outputs.node_version }}
+
+      - name: Install Node dependencies
+        run: npm ci
+
+      # Get secrets from Azure Key Vault
+      - name: Azure Login
+        uses: bitwarden/gh-actions/azure-login@main
+        with:
+          subscription_id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
+          tenant_id: ${{ secrets.AZURE_TENANT_ID }}
+          client_id: ${{ secrets.AZURE_CLIENT_ID }}
+
+      - name: Get KV Secrets
+        id: get-kv-secrets
+        uses: bitwarden/gh-actions/get-keyvault-secrets@main
+        with:
+          keyvault: gh-directory-connector
+          secrets: "GOOGLE-ADMIN-USER,GOOGLE-CLIENT-EMAIL,GOOGLE-DOMAIN,GOOGLE-PRIVATE-KEY"
+
+      - name: Azure Logout
+        uses: bitwarden/gh-actions/azure-logout@main
+
+      # Only run relevant tests depending on what files have changed.
+      # This should be kept consistent with the workflow level triggers.
+      # Note: docker-compose.yml is only used for ldap for now
+      - name: Get changed files
+        id: changed-files
+        uses: dorny/paths-filter@de90cc6fb38fc0963ad72b210f1f284cd68cea36 # v3.0.2
+        with:
+          list-files: shell
+          token: ${{ secrets.GITHUB_TOKEN }}
+          # Add directory services here as we add test coverage
+          filters: |
+            common:
+              - '.github/workflows/integration-test.yml'
+              - 'utils/**'
+              - 'package.json'
+              - 'src/services/sync.service.ts'
+            ldap:
+              - 'docker-compose.yml'
+              - 'src/services/directory-services/ldap-directory.service*'
+            google:
+              - 'src/services/directory-services/gsuite-directory.service*'
+
+      # LDAP
+      - name: Setup LDAP integration tests
+        if: steps.changed-files.outputs.common == 'true' || steps.changed-files.outputs.ldap == 'true'
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install mkcert
+          npm run test:integration:setup
+
+      - name: Run LDAP integration tests
+        if: steps.changed-files.outputs.common == 'true' || steps.changed-files.outputs.ldap == 'true'
+        env:
+          JEST_JUNIT_UNIQUE_OUTPUT_NAME: "true" # avoids junit outputs from clashing
+        run: npx jest ldap-directory.service.integration.spec.ts --coverage --coverageDirectory=coverage-ldap
+
+      # Google Workspace
+      - name: Run Google Workspace integration tests
+        if: steps.changed-files.outputs.common == 'true' || steps.changed-files.outputs.google == 'true'
+        env:
+          GOOGLE_DOMAIN: ${{ steps.get-kv-secrets.outputs.GOOGLE-DOMAIN }}
+          GOOGLE_ADMIN_USER: ${{ steps.get-kv-secrets.outputs.GOOGLE-ADMIN-USER }}
+          GOOGLE_CLIENT_EMAIL: ${{ steps.get-kv-secrets.outputs.GOOGLE-CLIENT-EMAIL }}
+          GOOGLE_PRIVATE_KEY: ${{ steps.get-kv-secrets.outputs.GOOGLE-PRIVATE-KEY }}
+          JEST_JUNIT_UNIQUE_OUTPUT_NAME: "true" # avoids junit outputs from clashing
+        run: |
+          npx jest gsuite-directory.service.integration.spec.ts --coverage --coverageDirectory=coverage-google
+
+      - name: Report test results
+        id: report
+        uses: dorny/test-reporter@fe45e9537387dac839af0d33ba56eed8e24189e8 # v2.3.0
+        # This will skip the job if it's a pull request from a fork, because that won't have permission to upload test results.
+        # PRs from the repository and all other events are OK.
+        if: (github.event_name == 'push' || github.event_name == 'workflow_dispatch' || github.event.pull_request.head.repo.full_name == github.repository) && !cancelled()
+        with:
+          name: Test Results
+          path: "junit.xml*"
+          reporter: jest-junit
+          fail-on-error: true
+
+      - name: Upload coverage to codecov.io
+        uses: codecov/codecov-action@671740ac38dd9b0130fbe1cec585b89eea48d3de # v5.5.2
+
+      - name: Upload results to codecov.io
+        uses: codecov/test-results-action@0fa95f0e1eeaafde2c782583b36b28ad0d8c77d3 # v1.2.1

.github/workflows/release.yml

@@ -1,4 +1,3 @@
----
 name: Release
 
 on:
@@ -14,13 +13,25 @@ on:
           - Redeploy
           - Dry Run
 
+permissions:
+  contents: read
+
 jobs:
   setup:
     name: Setup
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
+    permissions:
+      contents: read
+    outputs:
+      release_version: ${{ steps.version.outputs.version }}
     steps:
+      - name: Checkout repo
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
+
       - name: Branch check
-        if: ${{ github.event.inputs.release_type != 'Dry Run' }}
+        if: ${{ inputs.release_type != 'Dry Run' }}
         run: |
           if [[ "$GITHUB_REF" != "refs/heads/rc" ]] && [[ "$GITHUB_REF" != "refs/heads/hotfix-rc" ]]; then
             echo "==================================="
@@ -29,56 +40,48 @@ jobs:
             exit 1
           fi
 
-      - name: Checkout repo
-        uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579
-
-      - name: Retrieve Directory Connector release version
-        id: retrieve-version
-        run: |
-          PKG_VERSION=$(jq -r .version src/package.json)
-          echo "::set-output name=package_version::$PKG_VERSION"
-
-      - name: Check to make sure Mobile release version has been bumped
-        if: ${{ github.event.inputs.release_type == 'Initial Release' }}
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          latest_ver=$(hub release -L 1 -f '%T')
-          latest_ver=${latest_ver:1}
-          echo "Latest version: $latest_ver"
-          ver=${{ steps.retrieve-version.outputs.package_version }}
-          echo "Version: $ver"
-          if [ "$latest_ver" = "$ver" ]; then
-            echo "Version has not been bumped!"
-            exit 1
-          fi
-        shell: bash
-
-      - name: Get branch name
-        id: branch
-        run: |
-          BRANCH_NAME=$(basename ${{ github.ref }})
-          echo "::set-output name=branch-name::$BRANCH_NAME"
+      - name: Check Release Version
+        id: version
+        uses: bitwarden/gh-actions/release-version-check@main
+        with:
+          release-type: ${{ inputs.release_type }}
+          project-type: ts
+          file: package.json
 
+  release:
+    name: Release
+    runs-on: ubuntu-24.04
+    needs: setup
+    permissions:
+      actions: read
+      packages: read
+      contents: write
+    steps:
       - name: Download all artifacts
-        uses: bitwarden/gh-actions/download-artifacts@c1fa8e09871a860862d6bbe36184b06d2c7e35a8
+        if: ${{ inputs.release_type != 'Dry Run' }}
+        uses: bitwarden/gh-actions/download-artifacts@main
         with:
           workflow: build.yml
           workflow_conclusion: success
-          branch: ${{ steps.branch.outputs.branch-name }}
+          branch: ${{ github.ref_name }}
+
+      - name: Dry Run - Download all artifacts
+        if: ${{ inputs.release_type == 'Dry Run' }}
+        uses: bitwarden/gh-actions/download-artifacts@main
+        with:
+          workflow: build.yml
+          workflow_conclusion: success
+          branch: main
 
       - name: Create release
-        if: ${{ github.event.inputs.release_type != 'Dry Run' }}
-        uses: ncipollo/release-action@40bb172bd05f266cf9ba4ff965cb61e9ee5f6d01  # v1.9.0
+        if: ${{ inputs.release_type != 'Dry Run' }}
+        uses: ncipollo/release-action@b7eabc95ff50cbeeedec83973935c8f306dfcd0b # v1.20.0
         env:
-          PKG_VERSION: ${{ steps.retrieve-version.outputs.package_version }}
+          PKG_VERSION: ${{ needs.setup.outputs.release_version }}
         with:
           artifacts: "./bwdc-windows-${{ env.PKG_VERSION }}.zip,
                       ./bwdc-macos-${{ env.PKG_VERSION }}.zip,
                       ./bwdc-linux-${{ env.PKG_VERSION }}.zip,
-                      ./bwdc-windows-sha256-${{ env.PKG_VERSION }}.txt,
-                      ./bwdc-macos-sha256-${{ env.PKG_VERSION }}.txt,
-                      ./bwdc-linux-sha256-${{ env.PKG_VERSION }}.txt,
                       ./Bitwarden-Connector-Portable-${{ env.PKG_VERSION }}.exe,
                       ./Bitwarden-Connector-Installer-${{ env.PKG_VERSION }}.exe,
                       ./Bitwarden-Connector-Installer-${{ env.PKG_VERSION }}.exe.blockmap,

.github/workflows/respond.yml

@@ -0,0 +1,28 @@
+name: Respond
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+  issues:
+    types: [opened, assigned]
+  pull_request_review:
+    types: [submitted]
+
+permissions: {}
+
+jobs:
+  respond:
+    name: Respond
+    uses: bitwarden/gh-actions/.github/workflows/_respond.yml@main
+    secrets:
+      AZURE_SUBSCRIPTION_ID: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
+      AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
+      AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
+    permissions:
+      actions: read
+      contents: write
+      id-token: write
+      issues: write
+      pull-requests: write

.github/workflows/review-code.yml

@@ -0,0 +1,21 @@
+name: Code Review
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+permissions: {}
+
+jobs:
+  review:
+    name: Review
+    uses: bitwarden/gh-actions/.github/workflows/_review-code.yml@main
+    secrets:
+      AZURE_SUBSCRIPTION_ID: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
+      AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
+      AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
+    permissions:
+      actions: read
+      contents: read
+      id-token: write
+      pull-requests: write

.github/workflows/scan.yml

@@ -0,0 +1,52 @@
+name: Scan
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - "main"
+  pull_request:
+    types: [opened, synchronize, reopened]
+    branches-ignore:
+      - "main"
+  pull_request_target:
+    types: [opened, synchronize, reopened]
+    branches:
+      - "main"
+
+permissions: {}
+
+jobs:
+  check-run:
+    name: Check PR run
+    uses: bitwarden/gh-actions/.github/workflows/check-run.yml@main
+    permissions:
+      contents: read
+
+  sast:
+    name: Checkmarx
+    uses: bitwarden/gh-actions/.github/workflows/_checkmarx.yml@main
+    needs: check-run
+    secrets:
+      AZURE_SUBSCRIPTION_ID: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
+      AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
+      AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
+    permissions:
+      contents: read
+      pull-requests: write
+      security-events: write
+      id-token: write
+
+  quality:
+    name: Sonar
+    uses: bitwarden/gh-actions/.github/workflows/_sonar.yml@main
+    needs: check-run
+    secrets:
+      AZURE_SUBSCRIPTION_ID: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
+      AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
+      AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
+    permissions:
+      contents: read
+      pull-requests: write
+      id-token: write
+      

.github/workflows/test.yml

@@ -0,0 +1,70 @@
+name: Testing
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - "main"
+      - "rc"
+      - "hotfix-rc"
+  pull_request:
+
+permissions:
+  contents: read
+  checks: write # required by dorny/test-reporter to upload its results
+
+jobs:
+
+  testing:
+    name: Run tests
+    if: ${{ startsWith(github.head_ref, 'version_bump_') == false }}
+    runs-on: ubuntu-24.04
+
+    steps:
+      - name: Check out repo
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
+
+      - name: Get Node version
+        id: retrieve-node-version
+        run: |
+          NODE_NVMRC=$(cat .nvmrc)
+          NODE_VERSION=${NODE_NVMRC/v/''}
+          echo "node_version=$NODE_VERSION" >> "$GITHUB_OUTPUT"
+
+      - name: Set up Node
+        uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+        with:
+          cache: 'npm'
+          cache-dependency-path: '**/package-lock.json'
+          node-version: ${{ steps.retrieve-node-version.outputs.node_version }}
+
+      - name: Install Node dependencies
+        run: npm ci
+
+      # We use isolatedModules: true which disables typechecking in tests
+      # Tests in apps/ are typechecked when their app is built, so we just do it here for libs/
+      # See https://bitwarden.atlassian.net/browse/EC-497
+      - name: Run typechecking
+        run: npm run test:types --coverage
+
+      - name: Run tests
+        run: npm run test --coverage
+
+      - name: Report test results
+        uses: dorny/test-reporter@fe45e9537387dac839af0d33ba56eed8e24189e8 # v2.3.0
+        # This will skip the job if it's a pull request from a fork, because that won't have permission to upload test results.
+        # PRs from the repository and all other events are OK.
+        if: (github.event_name == 'push' || github.event_name == 'workflow_dispatch' || github.event.pull_request.head.repo.full_name == github.repository) && !cancelled()
+        with:
+          name: Test Results
+          path: "junit.xml"
+          reporter: jest-junit
+          fail-on-error: true
+
+      - name: Upload coverage to codecov.io
+        uses: codecov/codecov-action@671740ac38dd9b0130fbe1cec585b89eea48d3de # v5.5.2
+
+      - name: Upload results to codecov.io
+        uses: codecov/test-results-action@0fa95f0e1eeaafde2c782583b36b28ad0d8c77d3 # v1.2.1

.github/workflows/version-bump.yml

@@ -1,65 +1,145 @@
----
 name: Version Bump
 
 on:
   workflow_dispatch:
     inputs:
-      version_number:
-        description: "New Version"
-        required: true
+      version_number_override:
+        description: "New version override (leave blank for automatic calculation, example: '2024.1.0')"
+        required: false
+        type: string
+
+permissions: {}
 
 jobs:
   bump_version:
-    name: "Create version_bump_${{ github.event.inputs.version_number }} branch"
-    runs-on: ubuntu-20.04
+    name: Bump Version
+    runs-on: ubuntu-24.04
+    permissions:
+      contents: write
+      id-token: write
     steps:
+      - name: Validate version input
+        if: ${{ inputs.version_number_override != '' }}
+        uses: bitwarden/gh-actions/version-check@main
+        with:
+          version: ${{ inputs.version_number_override }}
+
+      - name: Log in to Azure
+        uses: bitwarden/gh-actions/azure-login@main
+        with:
+          subscription_id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
+          tenant_id: ${{ secrets.AZURE_TENANT_ID }}
+          client_id: ${{ secrets.AZURE_CLIENT_ID }}
+
+      - name: Get Azure Key Vault secrets
+        id: get-kv-secrets
+        uses: bitwarden/gh-actions/get-keyvault-secrets@main
+        with:
+          keyvault: gh-org-bitwarden
+          secrets: "BW-GHAPP-ID,BW-GHAPP-KEY"
+
+      - name: Log out from Azure
+        uses: bitwarden/gh-actions/azure-logout@main
+
+      - name: Generate GH App token
+        uses: actions/create-github-app-token@29824e69f54612133e76f7eaac726eef6c875baf # v2.2.1
+        id: app-token
+        with:
+          app-id: ${{ steps.get-kv-secrets.outputs.BW-GHAPP-ID }}
+          private-key: ${{ steps.get-kv-secrets.outputs.BW-GHAPP-KEY }}
+          permission-contents: write
+
       - name: Checkout Branch
-        uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          token: ${{ steps.app-token.outputs.token }}
+          persist-credentials: true
 
-      - name: Create Version Branch
+      - name: Setup git
         run: |
-          git switch -c version_bump_${{ github.event.inputs.version_number }}
-          git push -u origin version_bump_${{ github.event.inputs.version_number }}
+          git config user.name github-actions
+          git config user.email github-actions@github.com
 
-      - name: Checkout Version Branch
-        uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579
-        with:
-          ref: version_bump_${{ github.event.inputs.version_number }}
+      - name: Get current version
+        id: current-version
+        run: |
+          CURRENT_VERSION=$(cat package.json | jq -r '.version')
+          echo "version=$CURRENT_VERSION" >> "$GITHUB_OUTPUT"
 
-      - name: Bump Version - Package
-        uses: bitwarden/gh-actions/version-bump@03ad9a873c39cdc95dd8d77dbbda67f84db43945
+      - name: Verify input version
+        if: ${{ inputs.version_number_override != '' }}
+        env:
+          CURRENT_VERSION: ${{ steps.current-version.outputs.version }}
+          NEW_VERSION: ${{ inputs.version_number_override }}
+        run: |
+          # Error if version has not changed.
+          if [[ "$NEW_VERSION" == "$CURRENT_VERSION" ]]; then
+            echo "Version has not changed."
+            exit 1
+          fi
+
+          # Check if version is newer.
+          if printf '%s\n' "${CURRENT_VERSION}" "${NEW_VERSION}" | sort -C -V; then
+            echo "Version check successful."
+          else
+            echo "Version check failed."
+            exit 1
+          fi
+
+      - name: Calculate next release version
+        if: ${{ inputs.version_number_override == '' }}
+        id: calculate-next-version
+        uses: bitwarden/gh-actions/version-next@main
         with:
-          version: ${{ github.event.inputs.version_number }}
-          file_path: "./src/package.json"
+          version: ${{ steps.current-version.outputs.version }}
+
+      - name: Bump Version - Package - Version Override
+        if: ${{ inputs.version_number_override != '' }}
+        id: bump-version-override
+        uses: bitwarden/gh-actions/version-bump@main
+        with:
+          file_path: "./package.json"
+          version: ${{ inputs.version_number_override }}
+
+      - name: Bump Version - Package - Automatic Calculation
+        if: ${{ inputs.version_number_override == '' }}
+        id: bump-version-automatic
+        uses: bitwarden/gh-actions/version-bump@main
+        with:
+          file_path: "./package.json"
+          version: ${{ steps.calculate-next-version.outputs.version }}
+
+      - name: Set final version output
+        id: set-final-version-output
+        env:
+          _BUMP_VERSION_OVERRIDE_OUTCOME: ${{ steps.bump-version-override.outcome }}
+          _INPUT_VERSION_NUMBER_OVERRIDE: ${{ inputs.version_number_override }}
+          _BUMP_VERSION_AUTOMATIC_OUTCOME: ${{ steps.bump-version-automatic.outcome }}
+          _CALCULATE_NEXT_VERSION: ${{ steps.calculate-next-version.outputs.version }}
+          
+        run: |
+          if [[ "$_BUMP_VERSION_OVERRIDE_OUTCOME" == "success" ]]; then
+            echo "version=$_INPUT_VERSION_NUMBER_OVERRIDE" >> "$GITHUB_OUTPUT"
+          elif [[ "$_BUMP_VERSION_AUTOMATIC_OUTCOME" == "success" ]]; then
+            echo "version=$_CALCULATE_NEXT_VERSION" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Check if version changed
+        id: version-changed
+        run: |
+          if [ -n "$(git status --porcelain)" ]; then
+            echo "changes_to_commit=TRUE" >> "$GITHUB_OUTPUT"
+          else
+            echo "changes_to_commit=FALSE" >> "$GITHUB_OUTPUT"
+            echo "No changes to commit!";
+          fi
 
       - name: Commit files
-        run: |
-          git config --local user.email "41898282+github-actions[bot]@users.noreply.github.com"
-          git config --local user.name "github-actions[bot]"
-          git commit -m "Bumped version to ${{ github.event.inputs.version_number }}" -a
+        if: ${{ steps.version-changed.outputs.changes_to_commit == 'TRUE' }}
+        env:
+          _VERSION: ${{ steps.set-final-version-output.outputs.version }}
+        run: git commit -m "Bumped version to $_VERSION" -a
 
       - name: Push changes
-        run: git push -u origin version_bump_${{ github.event.inputs.version_number }}
-
-      - name: Create Version PR
-        env:
-          PR_BRANCH: "version_bump_${{ github.event.inputs.version_number }}"
-          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
-          BASE_BRANCH: master
-          TITLE: "Bump version to ${{ github.event.inputs.version_number }}"
-        run: |
-          gh pr create --title "$TITLE" \
-            --base "$BASE" \
-            --head "$PR_BRANCH" \
-            --label "version update" \
-            --label "automated pr" \
-            --body "
-              ## Type of change
-              - [ ] Bug fix
-              - [ ] New feature development
-              - [ ] Tech debt (refactoring, code cleanup, dependency upgrades, etc)
-              - [ ] Build/deploy pipeline (DevOps)
-              - [X] Other
-              
-              ## Objective
-              Automated version bump to ${{ github.event.inputs.version_number }}"
+        if: ${{ steps.version-changed.outputs.changes_to_commit == 'TRUE' }}
+        run: git push

.github/workflows/workflow-linter.yml

@@ -1,11 +0,0 @@
----
-name: Workflow Linter
-
-on:
-  pull_request:
-    paths:
-      - .github/workflows/**
-
-jobs:
-  call-workflow:
-    uses: bitwarden/gh-actions/.github/workflows/workflow-linter.yml@master

.gitignore

@@ -1,17 +1,44 @@
-.vs
-.idea
+# General
+.DS_Store
+Thumbs.db
+
+# Environment variables used for tests
+.env
+
+# IDEs and editors
+.idea/
+.project
+.classpath
+.c9/
+*.launch
+.settings/
+*.sublime-workspace
+
+# Visual Studio Code
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+.history/*
+
+# Node
 node_modules
 npm-debug.log
-vwd.webinfo
-dist/
-dist-cli/
-css/
+
+# Build directories
+dist
+build
+build-cli
+.angular/cache
+
+# Testing
+coverage*
+junit.xml*
+
+# Misc
 *.crx
 *.pem
-build-cli/
-build/
-yarn-error.log
-.DS_Store
-*.nupkg
+*.zip
 *.provisionprofile
-*.env
+.swp

.nvmrc

@@ -0,0 +1 @@
+v20

README.md

@@ -3,13 +3,13 @@
 
 # Bitwarden Directory Connector
 
-The Bitwarden Directory Connector is a a desktop application used to sync your Bitwarden enterprise organization to an existing directory of users and groups.
+The Bitwarden Directory Connector is a desktop application used to sync your Bitwarden enterprise organization to an existing directory of users and groups.
 
 Supported directories:
 
 - Active Directory
 - Any other LDAP-based directory
-- Azure Active Directory
+- Microsoft Entra ID
 - G Suite (Google)
 - Okta
 
@@ -48,7 +48,7 @@ We provide detailed documentation and examples for using the Directory Connector
 
 **Requirements**
 
-- [Node.js](https://nodejs.org) v16.13.1 (LTS)
+- [Node.js](https://nodejs.org) v18 (LTS)
 - Windows users: To compile the native node modules used in the app you will need the Visual C++ toolset, available through the standard Visual Studio installer (recommended) or by installing [`windows-build-tools`](https://github.com/felixrieseberg/windows-build-tools) through `npm`. See more at [Compiling native Addon modules](https://github.com/Microsoft/nodejs-guidelines/blob/master/windows-environment.md#compiling-native-addon-modules).
 
 **Run the app**

angular.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "./node_modules/@angular/cli/lib/config/schema.json",
+  "version": 1,
+  "newProjectRoot": "apps",
+  "cli": {
+    "analytics": false
+  },
+  "projects": {
+    "app": {
+      "projectType": "application",
+      "schematics": {
+        "@schematics/angular:application": {
+          "strict": true
+        }
+      },
+      "root": ".",
+      "sourceRoot": "src",
+      "prefix": "app",
+      "architect": {
+        "build": {
+          "builder": "@angular-devkit/build-angular:browser",
+          "options": {
+            "outputPath": "dist",
+            "index": "src/index.html",
+            "main": "src/main.ts",
+            "tsConfig": "tsconfig.json",
+            "assets": [],
+            "styles": [],
+            "scripts": []
+          }
+        }
+      }
+    }
+  }
+}

docker-compose.yml

@@ -0,0 +1,18 @@
+services:
+  open-ldap:
+    image: bitnamilegacy/openldap:latest
+    hostname: openldap
+    environment:
+      - LDAP_ADMIN_USERNAME=admin
+      - LDAP_ADMIN_PASSWORD=admin
+      - LDAP_ROOT=dc=bitwarden,dc=com
+      - LDAP_ENABLE_TLS=yes
+      - LDAP_TLS_CERT_FILE=/certs/openldap.pem
+      - LDAP_TLS_KEY_FILE=/certs/openldap-key.pem
+      - LDAP_TLS_CA_FILE=/certs/rootCA.pem
+    volumes:
+      - "./utils/openldap/ldifs:/ldifs"
+      - "./utils/openldap/certs:/certs"
+    ports:
+      - "1389:1389"
+      - "1636:1636"

docs/google-workspace.md

@@ -0,0 +1,300 @@
+# Google Workspace Directory Integration
+
+This document provides technical documentation for the Google Workspace (formerly G Suite) directory integration in Bitwarden Directory Connector.
+
+## Overview
+
+The Google Workspace integration synchronizes users and groups from Google Workspace to Bitwarden organizations using the Google Admin SDK Directory API. The service uses a service account with domain-wide delegation to authenticate and access directory data.
+
+## Architecture
+
+### Service Location
+
+- **Implementation**: `src/services/directory-services/gsuite-directory.service.ts`
+- **Configuration Model**: `src/models/gsuiteConfiguration.ts`
+- **Integration Tests**: `src/services/directory-services/gsuite-directory.service.integration.spec.ts`
+
+### Authentication Flow
+
+The Google Workspace integration uses **OAuth 2.0 with Service Accounts** and domain-wide delegation:
+
+1. A service account is created in Google Cloud Console
+2. The service account is granted domain-wide delegation authority
+3. The service account is authorized for specific OAuth scopes in Google Workspace Admin Console
+4. The Directory Connector uses the service account's private key to generate JWT tokens
+5. JWT tokens are exchanged for access tokens to call the Admin SDK APIs
+
+### Required OAuth Scopes
+
+The service account must be granted the following OAuth 2.0 scopes:
+
+```
+https://www.googleapis.com/auth/admin.directory.user.readonly
+https://www.googleapis.com/auth/admin.directory.group.readonly
+https://www.googleapis.com/auth/admin.directory.group.member.readonly
+```
+
+## Configuration
+
+### Required Fields
+
+| Field         | Description                                                                             |
+| ------------- | --------------------------------------------------------------------------------------- |
+| `clientEmail` | Service account email address (e.g., `service-account@project.iam.gserviceaccount.com`) |
+| `privateKey`  | Service account private key in PEM format                                               |
+| `adminUser`   | Admin user email to impersonate for domain-wide delegation                              |
+| `domain`      | Primary domain of the Google Workspace organization                                     |
+
+### Optional Fields
+
+| Field      | Description                                                |
+| ---------- | ---------------------------------------------------------- |
+| `customer` | Customer ID for multi-domain organizations (rarely needed) |
+
+### Example Configuration
+
+```typescript
+{
+  clientEmail: "directory-connector@my-project.iam.gserviceaccount.com",
+  privateKey: "-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n",
+  adminUser: "admin@example.com",
+  domain: "example.com",
+  customer: "" // Usually not required
+}
+```
+
+## Setup Instructions
+
+### 1. Create a Service Account
+
+1. Go to [Google Cloud Console](https://console.cloud.google.com)
+2. Create or select a project
+3. Navigate to **IAM & Admin** > **Service Accounts**
+4. Click **Create Service Account**
+5. Enter a name and description
+6. Click **Create and Continue**
+7. Skip granting roles (not needed for this use case)
+8. Click **Done**
+
+### 2. Generate Service Account Key
+
+1. Click on the newly created service account
+2. Navigate to the **Keys** tab
+3. Click **Add Key** > **Create new key**
+4. Select **JSON** format
+5. Click **Create** and download the key file
+6. Extract `client_email` and `private_key` from the JSON file
+
+### 3. Enable Domain-Wide Delegation
+
+1. In the service account details, click **Show Advanced Settings**
+2. Under **Domain-wide delegation**, click **Enable Google Workspace Domain-wide Delegation**
+3. Note the **Client ID** (numeric ID)
+
+### 4. Authorize the Service Account in Google Workspace
+
+1. Go to [Google Workspace Admin Console](https://admin.google.com)
+2. Navigate to **Security** > **API Controls** > **Domain-wide Delegation**
+3. Click **Add new**
+4. Enter the **Client ID** from step 3
+5. Enter the following OAuth scopes (comma-separated):
+   ```
+   https://www.googleapis.com/auth/admin.directory.user.readonly,
+   https://www.googleapis.com/auth/admin.directory.group.readonly,
+   https://www.googleapis.com/auth/admin.directory.group.member.readonly
+   ```
+6. Click **Authorize**
+
+### 5. Configure Directory Connector
+
+Use the extracted values to configure the Directory Connector:
+
+- **Client Email**: From `client_email` in the JSON key file
+- **Private Key**: From `private_key` in the JSON key file (keep the `\n` line breaks)
+- **Admin User**: Email of a super admin user in your Google Workspace domain
+- **Domain**: Your primary Google Workspace domain
+
+## Sync Behavior
+
+### User Synchronization
+
+The service synchronizes the following user attributes:
+
+| Google Workspace Field    | Bitwarden Field             | Notes                                     |
+| ------------------------- | --------------------------- | ----------------------------------------- |
+| `id`                      | `referenceId`, `externalId` | User's unique Google ID                   |
+| `primaryEmail`            | `email`                     | Normalized to lowercase                   |
+| `suspended` OR `archived` | `disabled`                  | User is disabled if suspended or archived |
+| Deleted status            | `deleted`                   | Set to true for deleted users             |
+
+**Special Behavior:**
+
+- The service queries both **active users** and **deleted users** separately
+- Suspended and archived users are included but marked as disabled
+- Deleted users are included with the `deleted` flag set to true
+
+### Group Synchronization
+
+The service synchronizes the following group attributes:
+
+| Google Workspace Field  | Bitwarden Field             | Notes                    |
+| ----------------------- | --------------------------- | ------------------------ |
+| `id`                    | `referenceId`, `externalId` | Group's unique Google ID |
+| `name`                  | `name`                      | Group display name       |
+| Members (type=USER)     | `userMemberExternalIds`     | Individual user members  |
+| Members (type=GROUP)    | `groupMemberReferenceIds`   | Nested group members     |
+| Members (type=CUSTOMER) | `userMemberExternalIds`     | All domain users         |
+
+**Member Types:**
+
+- **USER**: Individual user accounts (only ACTIVE status users are synced)
+- **GROUP**: Nested groups (allows group hierarchy)
+- **CUSTOMER**: Special member type that includes all users in the domain
+
+### Filtering
+
+#### User Filter Examples
+
+```
+exclude:testuser1@bwrox.dev | testuser1@bwrox.dev                   # Exclude multiple users
+|orgUnitPath='/Integration testing'                                 # Users in Integration testing Organizational unit (OU)
+exclude:testuser1@bwrox.dev | orgUnitPath='/Integration testing'    # Combined filter: get users in OU excluding provided user
+|email:testuser*                                                    # Users with email starting with "testuser"
+```
+
+#### Group Filter Examples
+
+An important note for group filters is that it implicitly only syncs users that are in groups. For example, in the case of
+the integration test data, `admin@bwrox.dev` is not a member of any group. Therefore, the first example filter below will
+also implicitly exclude `admin@bwrox.dev`, who is not in any group. This is important because when it is paired with an
+empty user filter, this query may semantically be understood as "sync everyone not in Integration Test Group A," while in
+practice it means "Only sync members of groups not in integration Test Groups A."
+
+```
+exclude:Integration Test Group A                                    # Get all users in groups excluding the provided group.
+```
+
+### User AND Group Filter Examples
+
+```
+
+```
+
+**Filter Syntax:**
+
+- Prefix with `|` for custom filters
+- Use `:` for pattern matching (supports `*` wildcard)
+- Combine multiple conditions with spaces (AND logic)
+
+### Pagination
+
+The service automatically handles pagination for all API calls:
+
+- Users API (active and deleted)
+- Groups API
+- Group Members API
+
+Each API call processes all pages using the `nextPageToken` mechanism until no more results are available.
+
+## Error Handling
+
+### Common Errors
+
+| Error                  | Cause                                 | Resolution                                                 |
+| ---------------------- | ------------------------------------- | ---------------------------------------------------------- |
+| "dirConfigIncomplete"  | Missing required configuration fields | Verify all required fields are provided                    |
+| "authenticationFailed" | Invalid credentials or unauthorized   | Check service account key and domain-wide delegation setup |
+| API returns 401/403    | Missing OAuth scopes                  | Verify scopes are authorized in Admin Console              |
+| API returns 404        | Invalid domain or customer ID         | Check domain configuration                                 |
+
+### Security Considerations
+
+The service implements the following security measures:
+
+1. **Credential sanitization**: Error messages do not expose private keys or sensitive credentials
+2. **Secure authentication**: Uses OAuth 2.0 with JWT tokens, not API keys
+3. **Read-only access**: Only requires read-only scopes for directory data
+4. **No credential logging**: Service account credentials are not logged
+
+## Testing
+
+### Integration Tests
+
+Integration tests are located in `src/services/directory-services/gsuite-directory.service.integration.spec.ts`.
+
+**Test Coverage:**
+
+- Basic sync (users and groups)
+- Sync with filters
+- Users-only sync
+- Groups-only sync
+- User filtering scenarios
+- Group filtering scenarios
+- Disabled users handling
+- Group membership scenarios
+- Error handling
+
+**Running Integration Tests:**
+
+Integration tests require live Google Workspace credentials:
+
+1. Create a `.env` file in the `utils/` folder with:
+   ```
+   GOOGLE_ADMIN_USER=admin@example.com
+   GOOGLE_CLIENT_EMAIL=service-account@project.iam.gserviceaccount.com
+   GOOGLE_PRIVATE_KEY="-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n"
+   GOOGLE_DOMAIN=example.com
+   ```
+2. Run tests:
+
+   ```bash
+   # Run all integration tests (includes LDAP, Google Workspace, etc.)
+   npm run test:integration
+
+   # Run only Google Workspace integration tests
+   npx jest gsuite-directory.service.integration.spec.ts
+   ```
+
+**Test Data:**
+
+The integration tests expect specific test data in Google Workspace:
+
+- **Users**: 5 test users in organizational unit `/Integration testing`
+  - testuser1@bwrox.dev (in Group A)
+  - testuser2@bwrox.dev (in Groups A & B)
+  - testuser3@bwrox.dev (in Group B)
+  - testuser4@bwrox.dev (no groups)
+  - testuser5@bwrox.dev (disabled)
+
+- **Groups**: 2 test groups with name pattern `Integration*`
+  - Integration Test Group A
+  - Integration Test Group B
+
+## API Reference
+
+### Google Admin SDK APIs Used
+
+- **Users API**: `admin.users.list()`
+  - [Documentation](https://developers.google.com/admin-sdk/directory/reference/rest/v1/users/list)
+
+- **Groups API**: `admin.groups.list()`
+  - [Documentation](https://developers.google.com/admin-sdk/directory/reference/rest/v1/groups/list)
+
+- **Members API**: `admin.members.list()`
+  - [Documentation](https://developers.google.com/admin-sdk/directory/reference/rest/v1/members/list)
+
+### Rate Limits
+
+Google Workspace Directory API rate limits:
+
+- Default: 2,400 queries per minute per user, per Google Cloud Project
+
+The service does not implement rate limiting logic; it relies on API error responses.
+
+## Resources
+
+- [Google Admin SDK Directory API Guide](https://developers.google.com/admin-sdk/directory/v1/guides)
+- [Service Account Authentication](https://developers.google.com/identity/protocols/oauth2/service-account)
+- [Domain-wide Delegation](https://support.google.com/a/answer/162106)
+- [Google Workspace Admin Console](https://admin.google.com)
+- [Bitwarden Directory Connector Documentation](https://bitwarden.com/help/directory-sync/)

electron-builder.json

@@ -4,7 +4,7 @@
   },
   "productName": "Bitwarden Directory Connector",
   "appId": "com.bitwarden.directory-connector",
-  "copyright": "Copyright © 2015-2022 Bitwarden Inc.",
+  "copyright": "Copyright © 2015-2026 Bitwarden Inc.",
   "directories": {
     "buildResources": "resources",
     "output": "dist",
@@ -12,6 +12,7 @@
   },
   "afterSign": "scripts/notarize.js",
   "mac": {
+    "artifactName": "Bitwarden-Connector-${version}-mac.${ext}",
     "category": "public.app-category.productivity",
     "gatekeeperAssess": false,
     "hardenedRuntime": true,

eslint.config.mjs

@@ -0,0 +1,149 @@
+// @ts-check
+import eslint from "@eslint/js";
+import tsParser from "@typescript-eslint/parser";
+import tsPlugin from "@typescript-eslint/eslint-plugin";
+import prettierConfig from "eslint-config-prettier";
+import importPlugin from "eslint-plugin-import";
+import rxjsX from "eslint-plugin-rxjs-x";
+import rxjsAngularX from "eslint-plugin-rxjs-angular-x";
+import angularEslint from "@angular-eslint/eslint-plugin-template";
+import angularParser from "@angular-eslint/template-parser";
+import globals from "globals";
+
+export default [
+  // Global ignores (replaces .eslintignore)
+  {
+    ignores: [
+      "dist/**",
+      "dist-cli/**",
+      "build/**",
+      "build-cli/**",
+      "coverage/**",
+      "**/*.cjs",
+      "eslint.config.mjs",
+      "scripts/**/*.js",
+      "**/node_modules/**",
+    ],
+  },
+
+  // Base config for all JavaScript/TypeScript files
+  {
+    files: ["**/*.ts", "**/*.js"],
+    languageOptions: {
+      ecmaVersion: 2020,
+      sourceType: "module",
+      parser: tsParser,
+      parserOptions: {
+        project: ["./tsconfig.eslint.json"],
+      },
+      globals: {
+        ...globals.browser,
+        ...globals.node,
+      },
+    },
+    plugins: {
+      "@typescript-eslint": tsPlugin,
+      import: importPlugin,
+      "rxjs-x": rxjsX,
+      "rxjs-angular-x": rxjsAngularX,
+    },
+    settings: {
+      "import/parsers": {
+        "@typescript-eslint/parser": [".ts"],
+      },
+      "import/resolver": {
+        typescript: {
+          alwaysTryTypes: true,
+        },
+      },
+    },
+    rules: {
+      // ESLint recommended rules
+      ...eslint.configs.recommended.rules,
+
+      // TypeScript ESLint recommended rules
+      ...tsPlugin.configs.recommended.rules,
+
+      // Import plugin recommended rules
+      ...importPlugin.flatConfigs.recommended.rules,
+
+      // RxJS recommended rules
+      ...rxjsX.configs.recommended.rules,
+
+      // Custom project rules
+      "@typescript-eslint/explicit-member-accessibility": ["error", { accessibility: "no-public" }],
+      "@typescript-eslint/no-explicit-any": "off", // TODO: This should be re-enabled
+      "@typescript-eslint/no-misused-promises": ["error", { checksVoidReturn: false }],
+      "@typescript-eslint/no-this-alias": ["error", { allowedNames: ["self"] }],
+      "@typescript-eslint/no-unused-vars": ["error", { args: "none" }],
+      "no-console": "error",
+      "import/no-unresolved": "off", // TODO: Look into turning on once each package is an actual package.
+      "import/order": [
+        "error",
+        {
+          alphabetize: {
+            order: "asc",
+          },
+          "newlines-between": "always",
+          pathGroups: [
+            {
+              pattern: "@/jslib/**/*",
+              group: "external",
+              position: "after",
+            },
+            {
+              pattern: "@/src/**/*",
+              group: "parent",
+              position: "before",
+            },
+          ],
+          pathGroupsExcludedImportTypes: ["builtin"],
+        },
+      ],
+      "rxjs-angular-x/prefer-takeuntil": "error",
+      "rxjs-x/no-exposed-subjects": ["error", { allowProtected: true }],
+      "no-restricted-syntax": [
+        "error",
+        {
+          message: "Calling `svgIcon` directly is not allowed",
+          selector: "CallExpression[callee.name='svgIcon']",
+        },
+        {
+          message: "Accessing FormGroup using `get` is not allowed, use `.value` instead",
+          selector:
+            "ChainExpression[expression.object.callee.property.name='get'][expression.property.name='value']",
+        },
+      ],
+      curly: ["error", "all"],
+      "import/namespace": ["off"], // This doesn't resolve namespace imports correctly, but TS will throw for this anyway
+      "no-restricted-imports": ["error", { patterns: ["src/**/*"] }],
+    },
+  },
+
+  // Jest test files (includes any test-related files)
+  {
+    files: ["**/*.spec.ts", "**/test.setup.ts", "**/spec/**/*.ts", "**/utils/**/*fixtures*.ts"],
+    languageOptions: {
+      globals: {
+        ...globals.jest,
+      },
+    },
+  },
+
+  // Angular HTML templates
+  {
+    files: ["**/*.html"],
+    languageOptions: {
+      parser: angularParser,
+    },
+    plugins: {
+      "@angular-eslint/template": angularEslint,
+    },
+    rules: {
+      "@angular-eslint/template/button-has-type": "error",
+    },
+  },
+
+  // Prettier config (must be last to override other configs)
+  prettierConfig,
+];

jest.config.cjs

@@ -0,0 +1,49 @@
+const { pathsToModuleNameMapper } = require("ts-jest");
+const { compilerOptions } = require("./tsconfig");
+
+const tsPreset = require("ts-jest/jest-preset");
+const angularPreset = require("jest-preset-angular/jest-preset");
+const { defaultTransformerOptions } = require("jest-preset-angular/presets");
+
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  // ...tsPreset,
+  // ...angularPreset,
+  preset: "jest-preset-angular",
+
+  reporters: ["default", "jest-junit"],
+
+  collectCoverage: true,
+  // Ensure we collect coverage from files without tests
+  collectCoverageFrom: ["src/**/*.ts"],
+  coverageReporters: ["html", "lcov"],
+  coverageDirectory: "coverage",
+
+  testEnvironment: "jsdom",
+  testMatch: ["**/+(*.)+(spec).+(ts)"],
+
+  roots: ["<rootDir>"],
+  modulePaths: [compilerOptions.baseUrl],
+  moduleNameMapper: pathsToModuleNameMapper(compilerOptions.paths, { prefix: "<rootDir>/" }),
+  setupFilesAfterEnv: ["<rootDir>/test.setup.ts"],
+  // Workaround for a memory leak that crashes tests in CI:
+  // https://github.com/facebook/jest/issues/9430#issuecomment-1149882002
+  // Also anecdotally improves performance when run locally
+  maxWorkers: 3,
+
+  transform: {
+    "^.+\\.tsx?$": [
+      "jest-preset-angular",
+      // 'ts-jest',
+      {
+        ...defaultTransformerOptions,
+        tsconfig: "./tsconfig.json",
+        // Further workaround for memory leak, recommended here:
+        // https://github.com/kulshekhar/ts-jest/issues/1967#issuecomment-697494014
+        // Makes tests run faster and reduces size/rate of leak, but loses typechecking on test code
+        // See https://bitwarden.atlassian.net/browse/EC-497 for more info
+        isolatedModules: true,
+      },
+    ],
+  },
+};

jslib/.prettierrc.json

@@ -1,3 +0,0 @@
-{
-  "printWidth": 100
-}

jslib/angular/jest.config.js

@@ -1,17 +0,0 @@
-const { pathsToModuleNameMapper } = require("ts-jest/utils");
-
-const { compilerOptions } = require("./tsconfig");
-
-module.exports = {
-  name: "angular",
-  displayName: "angular tests",
-  preset: "jest-preset-angular",
-  testMatch: ["**/+(*.)+(spec).+(ts)"],
-  setupFilesAfterEnv: ["<rootDir>/spec/test.ts"],
-  collectCoverage: true,
-  coverageReporters: ["html", "lcov"],
-  coverageDirectory: "coverage",
-  moduleNameMapper: pathsToModuleNameMapper(compilerOptions?.paths || {}, {
-    prefix: "<rootDir>/",
-  }),
-};

jslib/angular/package-lock.json

@@ -1,13 +0,0 @@
-{
-  "name": "@bitwarden/jslib-angular",
-  "version": "0.0.0",
-  "lockfileVersion": 2,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "@bitwarden/jslib-angular",
-      "version": "0.0.0",
-      "license": "GPL-3.0"
-    }
-  }
-}

jslib/angular/package.json

@@ -1,21 +0,0 @@
-{
-  "name": "@bitwarden/jslib-angular",
-  "version": "0.0.0",
-  "description": "Common code used across Bitwarden JavaScript projects.",
-  "keywords": [
-    "bitwarden"
-  ],
-  "author": "Bitwarden Inc.",
-  "homepage": "https://bitwarden.com",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/bitwarden/jslib"
-  },
-  "license": "GPL-3.0",
-  "scripts": {
-    "clean": "rimraf dist/**/*",
-    "build": "npm run clean && tsc",
-    "build:watch": "npm run clean && tsc -watch"
-  },
-  "dependencies": {}
-}

jslib/angular/src/components/callout.component.html

@@ -1,35 +0,0 @@
-<div
-  #callout
-  class="callout callout-{{ calloutStyle }}"
-  [ngClass]="{ clickable: clickable }"
-  [attr.role]="useAlertRole ? 'alert' : null"
->
-  <h3 class="callout-heading" *ngIf="title">
-    <i class="bwi {{ icon }}" *ngIf="icon" aria-hidden="true"></i>
-    {{ title }}
-  </h3>
-  <div class="enforced-policy-options" *ngIf="enforcedPolicyOptions">
-    {{ enforcedPolicyMessage }}
-    <ul>
-      <li *ngIf="enforcedPolicyOptions?.minComplexity > 0">
-        {{ "policyInEffectMinComplexity" | i18n: getPasswordScoreAlertDisplay() }}
-      </li>
-      <li *ngIf="enforcedPolicyOptions?.minLength > 0">
-        {{ "policyInEffectMinLength" | i18n: enforcedPolicyOptions?.minLength.toString() }}
-      </li>
-      <li *ngIf="enforcedPolicyOptions?.requireUpper">
-        {{ "policyInEffectUppercase" | i18n }}
-      </li>
-      <li *ngIf="enforcedPolicyOptions?.requireLower">
-        {{ "policyInEffectLowercase" | i18n }}
-      </li>
-      <li *ngIf="enforcedPolicyOptions?.requireNumbers">
-        {{ "policyInEffectNumbers" | i18n }}
-      </li>
-      <li *ngIf="enforcedPolicyOptions?.requireSpecial">
-        {{ "policyInEffectSpecial" | i18n: "!@#$%^&*" }}
-      </li>
-    </ul>
-  </div>
-  <ng-content></ng-content>
-</div>

jslib/angular/src/components/callout.component.ts

@@ -1,78 +0,0 @@
-import { Component, Input, OnInit } from "@angular/core";
-
-import { I18nService } from "jslib-common/abstractions/i18n.service";
-import { MasterPasswordPolicyOptions } from "jslib-common/models/domain/masterPasswordPolicyOptions";
-
-@Component({
-  selector: "app-callout",
-  templateUrl: "callout.component.html",
-})
-export class CalloutComponent implements OnInit {
-  @Input() type = "info";
-  @Input() icon: string;
-  @Input() title: string;
-  @Input() clickable: boolean;
-  @Input() enforcedPolicyOptions: MasterPasswordPolicyOptions;
-  @Input() enforcedPolicyMessage: string;
-  @Input() useAlertRole = false;
-
-  calloutStyle: string;
-
-  constructor(private i18nService: I18nService) {}
-
-  ngOnInit() {
-    this.calloutStyle = this.type;
-
-    if (this.enforcedPolicyMessage === undefined) {
-      this.enforcedPolicyMessage = this.i18nService.t("masterPasswordPolicyInEffect");
-    }
-
-    if (this.type === "warning" || this.type === "danger") {
-      if (this.type === "danger") {
-        this.calloutStyle = "danger";
-      }
-      if (this.title === undefined) {
-        this.title = this.i18nService.t("warning");
-      }
-      if (this.icon === undefined) {
-        this.icon = "bwi-exclamation-triangle";
-      }
-    } else if (this.type === "error") {
-      this.calloutStyle = "danger";
-      if (this.title === undefined) {
-        this.title = this.i18nService.t("error");
-      }
-      if (this.icon === undefined) {
-        this.icon = "bwi-error";
-      }
-    } else if (this.type === "tip") {
-      this.calloutStyle = "success";
-      if (this.title === undefined) {
-        this.title = this.i18nService.t("tip");
-      }
-      if (this.icon === undefined) {
-        this.icon = "bwi-lightbulb";
-      }
-    }
-  }
-
-  getPasswordScoreAlertDisplay() {
-    if (this.enforcedPolicyOptions == null) {
-      return "";
-    }
-
-    let str: string;
-    switch (this.enforcedPolicyOptions.minComplexity) {
-      case 4:
-        str = this.i18nService.t("strong");
-        break;
-      case 3:
-        str = this.i18nService.t("good");
-        break;
-      default:
-        str = this.i18nService.t("weak");
-        break;
-    }
-    return str + " (" + this.enforcedPolicyOptions.minComplexity + ")";
-  }
-}

jslib/angular/src/components/environment.component.ts

@@ -1,8 +1,8 @@
 import { Directive, EventEmitter, Output } from "@angular/core";
 
-import { EnvironmentService } from "jslib-common/abstractions/environment.service";
-import { I18nService } from "jslib-common/abstractions/i18n.service";
-import { PlatformUtilsService } from "jslib-common/abstractions/platformUtils.service";
+import { EnvironmentService } from "@/jslib/common/src/abstractions/environment.service";
+import { I18nService } from "@/jslib/common/src/abstractions/i18n.service";
+import { PlatformUtilsService } from "@/jslib/common/src/abstractions/platformUtils.service";
 
 @Directive()
 export class EnvironmentComponent {
@@ -19,7 +19,7 @@ export class EnvironmentComponent {
   constructor(
     protected platformUtilsService: PlatformUtilsService,
     protected environmentService: EnvironmentService,
-    protected i18nService: I18nService
+    protected i18nService: I18nService,
   ) {
     const urls = this.environmentService.getUrls();
 

jslib/angular/src/components/icon.component.html

@@ -1,11 +0,0 @@
-<div class="icon" aria-hidden="true">
-  <img
-    [src]="image"
-    appFallbackSrc="{{ fallbackImage }}"
-    *ngIf="imageEnabled && image"
-    alt=""
-    decoding="async"
-    loading="lazy"
-  />
-  <i class="bwi bwi-fw bwi-lg {{ icon }}" *ngIf="!imageEnabled || !image"></i>
-</div>

jslib/angular/src/components/icon.component.ts

@@ -1,112 +0,0 @@
-import { Component, Input, OnChanges } from "@angular/core";
-
-import { EnvironmentService } from "jslib-common/abstractions/environment.service";
-import { StateService } from "jslib-common/abstractions/state.service";
-import { CipherType } from "jslib-common/enums/cipherType";
-import { Utils } from "jslib-common/misc/utils";
-import { CipherView } from "jslib-common/models/view/cipherView";
-
-/**
- * Provides a mapping from supported card brands to
- * the filenames of icon that should be present in images/cards folder of clients.
- */
-const cardIcons: Record<string, string> = {
-  Visa: "card-visa",
-  Mastercard: "card-mastercard",
-  Amex: "card-amex",
-  Discover: "card-discover",
-  "Diners Club": "card-diners-club",
-  JCB: "card-jcb",
-  Maestro: "card-maestro",
-  UnionPay: "card-union-pay",
-};
-
-@Component({
-  selector: "app-vault-icon",
-  templateUrl: "icon.component.html",
-})
-export class IconComponent implements OnChanges {
-  @Input() cipher: CipherView;
-  icon: string;
-  image: string;
-  fallbackImage: string;
-  imageEnabled: boolean;
-
-  private iconsUrl: string;
-
-  constructor(environmentService: EnvironmentService, private stateService: StateService) {
-    this.iconsUrl = environmentService.getIconsUrl();
-  }
-
-  async ngOnChanges() {
-    // Components may be re-used when using cdk-virtual-scroll. Which puts the component in a weird state,
-    // to avoid this we reset all state variables.
-    this.image = null;
-    this.fallbackImage = null;
-    this.imageEnabled = !(await this.stateService.getDisableFavicon());
-    this.load();
-  }
-
-  protected load() {
-    switch (this.cipher.type) {
-      case CipherType.Login:
-        this.icon = "bwi-globe";
-        this.setLoginIcon();
-        break;
-      case CipherType.SecureNote:
-        this.icon = "bwi-sticky-note";
-        break;
-      case CipherType.Card:
-        this.icon = "bwi-credit-card";
-        this.setCardIcon();
-        break;
-      case CipherType.Identity:
-        this.icon = "bwi-id-card";
-        break;
-      default:
-        break;
-    }
-  }
-
-  private setLoginIcon() {
-    if (this.cipher.login.uri) {
-      let hostnameUri = this.cipher.login.uri;
-      let isWebsite = false;
-
-      if (hostnameUri.indexOf("androidapp://") === 0) {
-        this.icon = "bwi-android";
-        this.image = null;
-      } else if (hostnameUri.indexOf("iosapp://") === 0) {
-        this.icon = "bwi-apple";
-        this.image = null;
-      } else if (
-        this.imageEnabled &&
-        hostnameUri.indexOf("://") === -1 &&
-        hostnameUri.indexOf(".") > -1
-      ) {
-        hostnameUri = "http://" + hostnameUri;
-        isWebsite = true;
-      } else if (this.imageEnabled) {
-        isWebsite = hostnameUri.indexOf("http") === 0 && hostnameUri.indexOf(".") > -1;
-      }
-
-      if (this.imageEnabled && isWebsite) {
-        try {
-          this.image = this.iconsUrl + "/" + Utils.getHostname(hostnameUri) + "/icon.png";
-          this.fallbackImage = "images/bwi-globe.png";
-        } catch (e) {
-          // Ignore error since the fallback icon will be shown if image is null.
-        }
-      }
-    } else {
-      this.image = null;
-    }
-  }
-
-  private setCardIcon() {
-    const brand = this.cipher.card.brand;
-    if (this.imageEnabled && brand in cardIcons) {
-      this.icon = "credit-card-icon " + cardIcons[brand];
-    }
-  }
-}

jslib/angular/src/components/modal/dynamic-modal.component.ts

@@ -35,7 +35,7 @@ export class DynamicModalComponent implements AfterViewInit, OnDestroy {
     private cd: ChangeDetectorRef,
     private el: ElementRef<HTMLElement>,
     private focusTrapFactory: ConfigurableFocusTrapFactory,
-    public modalRef: ModalRef
+    public modalRef: ModalRef,
   ) {}
 
   ngAfterViewInit() {
@@ -47,7 +47,7 @@ export class DynamicModalComponent implements AfterViewInit, OnDestroy {
 
     this.modalRef.created(this.el.nativeElement);
     this.focusTrap = this.focusTrapFactory.create(
-      this.el.nativeElement.querySelector(".modal-dialog")
+      this.el.nativeElement.querySelector(".modal-dialog"),
     );
     if (this.el.nativeElement.querySelector("[appAutoFocus]") == null) {
       this.focusTrap.focusFirstTabbableElementWhenReady();

jslib/angular/src/components/modal/modal-injector.ts

@@ -1,10 +1,20 @@
-import { InjectFlags, InjectionToken, Injector, Type } from "@angular/core";
+import { InjectOptions, Injector, ProviderToken } from "@angular/core";
 
 export class ModalInjector implements Injector {
-  constructor(private _parentInjector: Injector, private _additionalTokens: WeakMap<any, any>) {}
+  constructor(
+    private _parentInjector: Injector,
+    private _additionalTokens: WeakMap<any, any>,
+  ) {}
 
-  get<T>(token: Type<T> | InjectionToken<T>, notFoundValue?: T, flags?: InjectFlags): T;
-  get(token: any, notFoundValue?: any, flags?: any) {
+  get<T>(
+    token: ProviderToken<T>,
+    notFoundValue: undefined,
+    options: InjectOptions & { optional?: false },
+  ): T;
+  get<T>(token: ProviderToken<T>, notFoundValue: null, options: InjectOptions): T;
+  get<T>(token: ProviderToken<T>, notFoundValue?: T, options?: InjectOptions): T;
+  get(token: any, notFoundValue?: any): any;
+  get(token: any, notFoundValue?: any, flags?: any): any {
     return this._additionalTokens.get(token) ?? this._parentInjector.get<any>(token, notFoundValue);
   }
 }

jslib/angular/src/components/modal/modal.ref.ts

@@ -1,5 +1,4 @@
-import { Observable, Subject } from "rxjs";
-import { first } from "rxjs/operators";
+import { lastValueFrom, Observable, Subject } from "rxjs";
 
 export class ModalRef {
   onCreated: Observable<HTMLElement>; // Modal added to the DOM.
@@ -45,6 +44,6 @@ export class ModalRef {
   }
 
   onClosedPromise(): Promise<any> {
-    return this.onClosed.pipe(first()).toPromise();
+    return lastValueFrom(this.onClosed);
   }
 }

jslib/angular/src/components/password-reprompt.component.ts

@@ -1,41 +0,0 @@
-import { Directive } from "@angular/core";
-
-import { CryptoService } from "jslib-common/abstractions/crypto.service";
-import { I18nService } from "jslib-common/abstractions/i18n.service";
-import { PlatformUtilsService } from "jslib-common/abstractions/platformUtils.service";
-
-import { ModalRef } from "./modal/modal.ref";
-
-/**
- * Used to verify the user's Master Password for the "Master Password Re-prompt" feature only.
- * See UserVerificationComponent for any other situation where you need to verify the user's identity.
- */
-@Directive()
-export class PasswordRepromptComponent {
-  showPassword = false;
-  masterPassword = "";
-
-  constructor(
-    private modalRef: ModalRef,
-    private cryptoService: CryptoService,
-    private platformUtilsService: PlatformUtilsService,
-    private i18nService: I18nService
-  ) {}
-
-  togglePassword() {
-    this.showPassword = !this.showPassword;
-  }
-
-  async submit() {
-    if (!(await this.cryptoService.compareAndUpdateKeyHash(this.masterPassword, null))) {
-      this.platformUtilsService.showToast(
-        "error",
-        this.i18nService.t("errorOccurred"),
-        this.i18nService.t("invalidMasterPassword")
-      );
-      return;
-    }
-
-    this.modalRef.close(true);
-  }
-}

jslib/angular/src/components/toastr.component.ts

@@ -60,9 +60,13 @@ import {
     ]),
   ],
   preserveWhitespaces: false,
+  standalone: false,
 })
 export class BitwardenToast extends BaseToast {
-  constructor(protected toastrService: ToastrService, public toastPackage: ToastPackage) {
+  constructor(
+    protected toastrService: ToastrService,
+    public toastPackage: ToastPackage,
+  ) {
     super(toastrService, toastPackage);
   }
 }

jslib/angular/src/components/user-verification.component.html

@@ -1,46 +0,0 @@
-<ng-container *ngIf="!usesKeyConnector">
-  <label for="masterPassword">{{ "masterPass" | i18n }}</label>
-  <input
-    id="masterPassword"
-    type="password"
-    name="MasterPasswordHash"
-    class="form-control"
-    [formControl]="secret"
-    required
-    appAutofocus
-    appInputVerbatim
-  />
-  <small class="form-text text-muted">{{ "confirmIdentity" | i18n }}</small>
-</ng-container>
-<ng-container *ngIf="usesKeyConnector">
-  <div class="form-group">
-    <label class="d-block">{{ "sendVerificationCode" | i18n }}</label>
-    <button
-      type="button"
-      class="btn btn-outline-secondary"
-      (click)="requestOTP()"
-      [disabled]="disableRequestOTP"
-    >
-      {{ "sendCode" | i18n }}
-    </button>
-    <span class="ml-2 text-success" role="alert" @sent *ngIf="sentCode">
-      <i class="bwi bwi-check-circle" aria-hidden="true"></i>
-      {{ "codeSent" | i18n }}
-    </span>
-  </div>
-
-  <div class="form-group">
-    <label for="verificationCode">{{ "verificationCode" | i18n }}</label>
-    <input
-      id="verificationCode"
-      type="input"
-      name="verificationCode"
-      class="form-control"
-      [formControl]="secret"
-      required
-      appAutofocus
-      appInputVerbatim
-    />
-    <small class="form-text text-muted">{{ "confirmIdentity" | i18n }}</small>
-  </div>
-</ng-container>

jslib/angular/src/components/user-verification.component.ts

@@ -1,96 +0,0 @@
-import { animate, style, transition, trigger } from "@angular/animations";
-import { Component, OnInit } from "@angular/core";
-import { ControlValueAccessor, FormControl, NG_VALUE_ACCESSOR } from "@angular/forms";
-
-import { KeyConnectorService } from "jslib-common/abstractions/keyConnector.service";
-import { UserVerificationService } from "jslib-common/abstractions/userVerification.service";
-import { VerificationType } from "jslib-common/enums/verificationType";
-import { Verification } from "jslib-common/types/verification";
-
-/**
- * Used for general-purpose user verification throughout the app.
- * Collects the user's master password, or if they are using Key Connector, prompts for an OTP via email.
- * This is exposed to the parent component via the ControlValueAccessor interface (e.g. bind it to a FormControl).
- * Use UserVerificationService to verify the user's input.
- */
-@Component({
-  selector: "app-user-verification",
-  templateUrl: "user-verification.component.html",
-  providers: [
-    {
-      provide: NG_VALUE_ACCESSOR,
-      multi: true,
-      useExisting: UserVerificationComponent,
-    },
-  ],
-  animations: [
-    trigger("sent", [
-      transition(":enter", [style({ opacity: 0 }), animate("100ms", style({ opacity: 1 }))]),
-    ]),
-  ],
-})
-export class UserVerificationComponent implements ControlValueAccessor, OnInit {
-  usesKeyConnector = false;
-  disableRequestOTP = false;
-  sentCode = false;
-
-  secret = new FormControl("");
-
-  private onChange: (value: Verification) => void;
-
-  constructor(
-    private keyConnectorService: KeyConnectorService,
-    private userVerificationService: UserVerificationService
-  ) {}
-
-  async ngOnInit() {
-    this.usesKeyConnector = await this.keyConnectorService.getUsesKeyConnector();
-    this.processChanges(this.secret.value);
-
-    this.secret.valueChanges.subscribe((secret: string) => this.processChanges(secret));
-  }
-
-  async requestOTP() {
-    if (this.usesKeyConnector) {
-      this.disableRequestOTP = true;
-      try {
-        await this.userVerificationService.requestOTP();
-        this.sentCode = true;
-      } finally {
-        this.disableRequestOTP = false;
-      }
-    }
-  }
-
-  writeValue(obj: any): void {
-    this.secret.setValue(obj);
-  }
-
-  registerOnChange(fn: any): void {
-    this.onChange = fn;
-  }
-
-  registerOnTouched(fn: any): void {
-    // Not implemented
-  }
-
-  setDisabledState?(isDisabled: boolean): void {
-    this.disableRequestOTP = isDisabled;
-    if (isDisabled) {
-      this.secret.disable();
-    } else {
-      this.secret.enable();
-    }
-  }
-
-  private processChanges(secret: string) {
-    if (this.onChange == null) {
-      return;
-    }
-
-    this.onChange({
-      type: this.usesKeyConnector ? VerificationType.OTP : VerificationType.MasterPassword,
-      secret: secret,
-    });
-  }
-}

jslib/angular/src/directives/a11y-title.directive.ts

@@ -2,6 +2,7 @@ import { Directive, ElementRef, Input, Renderer2 } from "@angular/core";
 
 @Directive({
   selector: "[appA11yTitle]",
+  standalone: false,
 })
 export class A11yTitleDirective {
   @Input() set appA11yTitle(title: string) {
@@ -10,7 +11,10 @@ export class A11yTitleDirective {
 
   private title: string;
 
-  constructor(private el: ElementRef, private renderer: Renderer2) {}
+  constructor(
+    private el: ElementRef,
+    private renderer: Renderer2,
+  ) {}
 
   ngOnInit() {
     if (!this.el.nativeElement.hasAttribute("title")) {

jslib/angular/src/directives/api-action.directive.ts

@@ -1,7 +1,7 @@
 import { Directive, ElementRef, Input, OnChanges } from "@angular/core";
 
-import { LogService } from "jslib-common/abstractions/log.service";
-import { ErrorResponse } from "jslib-common/models/response/errorResponse";
+import { LogService } from "@/jslib/common/src/abstractions/log.service";
+import { ErrorResponse } from "@/jslib/common/src/models/response/errorResponse";
 
 import { ValidationService } from "../services/validation.service";
 
@@ -13,6 +13,7 @@ import { ValidationService } from "../services/validation.service";
  */
 @Directive({
   selector: "[appApiAction]",
+  standalone: false,
 })
 export class ApiActionDirective implements OnChanges {
   @Input() appApiAction: Promise<any>;
@@ -20,7 +21,7 @@ export class ApiActionDirective implements OnChanges {
   constructor(
     private el: ElementRef,
     private validationService: ValidationService,
-    private logService: LogService
+    private logService: LogService,
   ) {}
 
   ngOnChanges(changes: any) {
@@ -43,7 +44,7 @@ export class ApiActionDirective implements OnChanges {
         }
         this.logService?.error(`Received API exception: ${e}`);
         this.validationService.showError(e);
-      }
+      },
     );
   }
 }

jslib/angular/src/directives/autofocus.directive.ts

@@ -1,10 +1,11 @@
 import { Directive, ElementRef, Input, NgZone } from "@angular/core";
-import { take } from "rxjs/operators";
+import { take } from "rxjs";
 
-import { Utils } from "jslib-common/misc/utils";
+import { Utils } from "@/jslib/common/src/misc/utils";
 
 @Directive({
   selector: "[appAutofocus]",
+  standalone: false,
 })
 export class AutofocusDirective {
   @Input() set appAutofocus(condition: boolean | string) {
@@ -13,7 +14,10 @@ export class AutofocusDirective {
 
   private autofocus: boolean;
 
-  constructor(private el: ElementRef, private ngZone: NgZone) {}
+  constructor(
+    private el: ElementRef,
+    private ngZone: NgZone,
+  ) {}
 
   ngOnInit() {
     if (!Utils.isMobileBrowser && this.autofocus) {

jslib/angular/src/directives/blur-click.directive.ts

@@ -2,6 +2,7 @@ import { Directive, ElementRef, HostListener } from "@angular/core";
 
 @Directive({
   selector: "[appBlurClick]",
+  standalone: false,
 })
 export class BlurClickDirective {
   constructor(private el: ElementRef) {}

jslib/angular/src/directives/box-row.directive.ts

@@ -2,6 +2,7 @@ import { Directive, ElementRef, HostListener, OnInit } from "@angular/core";
 
 @Directive({
   selector: "[appBoxRow]",
+  standalone: false,
 })
 export class BoxRowDirective implements OnInit {
   el: HTMLElement = null;
@@ -13,7 +14,7 @@ export class BoxRowDirective implements OnInit {
 
   ngOnInit(): void {
     this.formEls = Array.from(
-      this.el.querySelectorAll('input:not([type="hidden"]), select, textarea')
+      this.el.querySelectorAll('input:not([type="hidden"]), select, textarea'),
     );
     this.formEls.forEach((formEl) => {
       formEl.addEventListener(
@@ -21,7 +22,7 @@ export class BoxRowDirective implements OnInit {
         () => {
           this.el.classList.add("active");
         },
-        false
+        false,
       );
 
       formEl.addEventListener(
@@ -29,7 +30,7 @@ export class BoxRowDirective implements OnInit {
         () => {
           this.el.classList.remove("active");
         },
-        false
+        false,
       );
     });
   }

jslib/angular/src/directives/fallback-src.directive.ts

@@ -2,6 +2,7 @@ import { Directive, ElementRef, HostListener, Input } from "@angular/core";
 
 @Directive({
   selector: "[appFallbackSrc]",
+  standalone: false,
 })
 export class FallbackSrcDirective {
   @Input("appFallbackSrc") appFallbackSrc: string;

jslib/angular/src/directives/stop-click.directive.ts

@@ -2,6 +2,7 @@ import { Directive, HostListener } from "@angular/core";
 
 @Directive({
   selector: "[appStopClick]",
+  standalone: false,
 })
 export class StopClickDirective {
   @HostListener("click", ["$event"]) onClick($event: MouseEvent) {

jslib/angular/src/directives/stop-prop.directive.ts

@@ -2,6 +2,7 @@ import { Directive, HostListener } from "@angular/core";
 
 @Directive({
   selector: "[appStopProp]",
+  standalone: false,
 })
 export class StopPropDirective {
   @HostListener("click", ["$event"]) onClick($event: MouseEvent) {

jslib/angular/src/pipes/i18n.pipe.ts

@@ -1,9 +1,10 @@
 import { Pipe, PipeTransform } from "@angular/core";
 
-import { I18nService } from "jslib-common/abstractions/i18n.service";
+import { I18nService } from "@/jslib/common/src/abstractions/i18n.service";
 
 @Pipe({
   name: "i18n",
+  standalone: false,
 })
 export class I18nPipe implements PipeTransform {
   constructor(private i18nService: I18nService) {}

jslib/angular/src/pipes/search-ciphers.pipe.ts

@@ -1,41 +0,0 @@
-import { Pipe, PipeTransform } from "@angular/core";
-
-import { CipherView } from "jslib-common/models/view/cipherView";
-
-@Pipe({
-  name: "searchCiphers",
-})
-export class SearchCiphersPipe implements PipeTransform {
-  transform(ciphers: CipherView[], searchText: string, deleted = false): CipherView[] {
-    if (ciphers == null || ciphers.length === 0) {
-      return [];
-    }
-
-    if (searchText == null || searchText.length < 2) {
-      return ciphers.filter((c) => {
-        return deleted !== c.isDeleted;
-      });
-    }
-
-    searchText = searchText.trim().toLowerCase();
-    return ciphers.filter((c) => {
-      if (deleted !== c.isDeleted) {
-        return false;
-      }
-      if (c.name != null && c.name.toLowerCase().indexOf(searchText) > -1) {
-        return true;
-      }
-      if (searchText.length >= 8 && c.id.startsWith(searchText)) {
-        return true;
-      }
-      if (c.subTitle != null && c.subTitle.toLowerCase().indexOf(searchText) > -1) {
-        return true;
-      }
-      if (c.login && c.login.uri != null && c.login.uri.toLowerCase().indexOf(searchText) > -1) {
-        return true;
-      }
-
-      return false;
-    });
-  }
-}

jslib/angular/src/scss/bwicons/styles/style.scss

@@ -1,10 +1,11 @@
 $icomoon-font-family: "bwi-font" !default;
-$icomoon-font-path: "~@bitwarden/jslib-angular/src/scss/bwicons/fonts/" !default;
+$icomoon-font-path: "/jslib/angular/src/scss/bwicons/fonts/" !default;
 
 // New font sheet? Update the font-face information below
 @font-face {
   font-family: "#{$icomoon-font-family}";
-  src: url($icomoon-font-path + "bwi-font.svg") format("svg"),
+  src:
+    url($icomoon-font-path + "bwi-font.svg") format("svg"),
     url($icomoon-font-path + "bwi-font.ttf") format("truetype"),
     url($icomoon-font-path + "bwi-font.woff") format("woff"),
     url($icomoon-font-path + "bwi-font.woff2") format("woff2");

jslib/angular/src/services/auth-guard.service.ts

@@ -1,45 +0,0 @@
-import { Injectable } from "@angular/core";
-import { ActivatedRouteSnapshot, CanActivate, Router, RouterStateSnapshot } from "@angular/router";
-
-import { KeyConnectorService } from "jslib-common/abstractions/keyConnector.service";
-import { MessagingService } from "jslib-common/abstractions/messaging.service";
-import { StateService } from "jslib-common/abstractions/state.service";
-import { VaultTimeoutService } from "jslib-common/abstractions/vaultTimeout.service";
-
-@Injectable()
-export class AuthGuardService implements CanActivate {
-  constructor(
-    private vaultTimeoutService: VaultTimeoutService,
-    private router: Router,
-    private messagingService: MessagingService,
-    private keyConnectorService: KeyConnectorService,
-    private stateService: StateService
-  ) {}
-
-  async canActivate(route: ActivatedRouteSnapshot, routerState: RouterStateSnapshot) {
-    const isAuthed = await this.stateService.getIsAuthenticated();
-    if (!isAuthed) {
-      this.messagingService.send("authBlocked");
-      return false;
-    }
-
-    const locked = await this.vaultTimeoutService.isLocked();
-    if (locked) {
-      if (routerState != null) {
-        this.messagingService.send("lockedUrl", { url: routerState.url });
-      }
-      this.router.navigate(["lock"], { queryParams: { promptBiometric: true } });
-      return false;
-    }
-
-    if (
-      !routerState.url.includes("remove-password") &&
-      (await this.keyConnectorService.getConvertAccountRequired())
-    ) {
-      this.router.navigate(["/remove-password"]);
-      return false;
-    }
-
-    return true;
-  }
-}

jslib/angular/src/services/broadcaster.service.ts

@@ -1,6 +1,6 @@
 import { Injectable } from "@angular/core";
 
-import { BroadcasterService as BaseBroadcasterService } from "jslib-common/services/broadcaster.service";
+import { BroadcasterService as BaseBroadcasterService } from "@/jslib/common/src/services/broadcaster.service";
 
 @Injectable()
 export class BroadcasterService extends BaseBroadcasterService {}

jslib/angular/src/services/jslib-services.module.ts

@@ -1,191 +1,70 @@
-import { Injector, LOCALE_ID, NgModule } from "@angular/core";
+import { LOCALE_ID, NgModule } from "@angular/core";
 
-import { ApiService as ApiServiceAbstraction } from "jslib-common/abstractions/api.service";
-import { AppIdService as AppIdServiceAbstraction } from "jslib-common/abstractions/appId.service";
-import { AuditService as AuditServiceAbstraction } from "jslib-common/abstractions/audit.service";
-import { AuthService as AuthServiceAbstraction } from "jslib-common/abstractions/auth.service";
-import { BroadcasterService as BroadcasterServiceAbstraction } from "jslib-common/abstractions/broadcaster.service";
-import { CipherService as CipherServiceAbstraction } from "jslib-common/abstractions/cipher.service";
-import { CollectionService as CollectionServiceAbstraction } from "jslib-common/abstractions/collection.service";
-import { CryptoService as CryptoServiceAbstraction } from "jslib-common/abstractions/crypto.service";
-import { CryptoFunctionService as CryptoFunctionServiceAbstraction } from "jslib-common/abstractions/cryptoFunction.service";
-import { EnvironmentService as EnvironmentServiceAbstraction } from "jslib-common/abstractions/environment.service";
-import { EventService as EventServiceAbstraction } from "jslib-common/abstractions/event.service";
-import { ExportService as ExportServiceAbstraction } from "jslib-common/abstractions/export.service";
-import { FileUploadService as FileUploadServiceAbstraction } from "jslib-common/abstractions/fileUpload.service";
-import { FolderService as FolderServiceAbstraction } from "jslib-common/abstractions/folder.service";
-import { I18nService as I18nServiceAbstraction } from "jslib-common/abstractions/i18n.service";
-import { KeyConnectorService as KeyConnectorServiceAbstraction } from "jslib-common/abstractions/keyConnector.service";
-import { LogService } from "jslib-common/abstractions/log.service";
-import { MessagingService as MessagingServiceAbstraction } from "jslib-common/abstractions/messaging.service";
-import { NotificationsService as NotificationsServiceAbstraction } from "jslib-common/abstractions/notifications.service";
-import { OrganizationService as OrganizationServiceAbstraction } from "jslib-common/abstractions/organization.service";
-import { PasswordGenerationService as PasswordGenerationServiceAbstraction } from "jslib-common/abstractions/passwordGeneration.service";
-import { PasswordRepromptService as PasswordRepromptServiceAbstraction } from "jslib-common/abstractions/passwordReprompt.service";
-import { PlatformUtilsService as PlatformUtilsServiceAbstraction } from "jslib-common/abstractions/platformUtils.service";
-import { PolicyService as PolicyServiceAbstraction } from "jslib-common/abstractions/policy.service";
-import { ProviderService as ProviderServiceAbstraction } from "jslib-common/abstractions/provider.service";
-import { SearchService as SearchServiceAbstraction } from "jslib-common/abstractions/search.service";
-import { SendService as SendServiceAbstraction } from "jslib-common/abstractions/send.service";
-import { SettingsService as SettingsServiceAbstraction } from "jslib-common/abstractions/settings.service";
-import { StateService as StateServiceAbstraction } from "jslib-common/abstractions/state.service";
-import { StateMigrationService as StateMigrationServiceAbstraction } from "jslib-common/abstractions/stateMigration.service";
-import { StorageService as StorageServiceAbstraction } from "jslib-common/abstractions/storage.service";
-import { SyncService as SyncServiceAbstraction } from "jslib-common/abstractions/sync.service";
-import { TokenService as TokenServiceAbstraction } from "jslib-common/abstractions/token.service";
-import { TotpService as TotpServiceAbstraction } from "jslib-common/abstractions/totp.service";
-import { TwoFactorService as TwoFactorServiceAbstraction } from "jslib-common/abstractions/twoFactor.service";
-import { UserVerificationService as UserVerificationServiceAbstraction } from "jslib-common/abstractions/userVerification.service";
-import { UsernameGenerationService as UsernameGenerationServiceAbstraction } from "jslib-common/abstractions/usernameGeneration.service";
-import { VaultTimeoutService as VaultTimeoutServiceAbstraction } from "jslib-common/abstractions/vaultTimeout.service";
-import { StateFactory } from "jslib-common/factories/stateFactory";
-import { Account } from "jslib-common/models/domain/account";
-import { GlobalState } from "jslib-common/models/domain/globalState";
-import { ApiService } from "jslib-common/services/api.service";
-import { AppIdService } from "jslib-common/services/appId.service";
-import { AuditService } from "jslib-common/services/audit.service";
-import { AuthService } from "jslib-common/services/auth.service";
-import { CipherService } from "jslib-common/services/cipher.service";
-import { CollectionService } from "jslib-common/services/collection.service";
-import { ConsoleLogService } from "jslib-common/services/consoleLog.service";
-import { CryptoService } from "jslib-common/services/crypto.service";
-import { EnvironmentService } from "jslib-common/services/environment.service";
-import { EventService } from "jslib-common/services/event.service";
-import { ExportService } from "jslib-common/services/export.service";
-import { FileUploadService } from "jslib-common/services/fileUpload.service";
-import { FolderService } from "jslib-common/services/folder.service";
-import { KeyConnectorService } from "jslib-common/services/keyConnector.service";
-import { NotificationsService } from "jslib-common/services/notifications.service";
-import { OrganizationService } from "jslib-common/services/organization.service";
-import { PasswordGenerationService } from "jslib-common/services/passwordGeneration.service";
-import { PolicyService } from "jslib-common/services/policy.service";
-import { ProviderService } from "jslib-common/services/provider.service";
-import { SearchService } from "jslib-common/services/search.service";
-import { SendService } from "jslib-common/services/send.service";
-import { SettingsService } from "jslib-common/services/settings.service";
-import { StateService } from "jslib-common/services/state.service";
-import { StateMigrationService } from "jslib-common/services/stateMigration.service";
-import { SyncService } from "jslib-common/services/sync.service";
-import { TokenService } from "jslib-common/services/token.service";
-import { TotpService } from "jslib-common/services/totp.service";
-import { TwoFactorService } from "jslib-common/services/twoFactor.service";
-import { UserVerificationService } from "jslib-common/services/userVerification.service";
-import { UsernameGenerationService } from "jslib-common/services/usernameGeneration.service";
-import { VaultTimeoutService } from "jslib-common/services/vaultTimeout.service";
-import { WebCryptoFunctionService } from "jslib-common/services/webCryptoFunction.service";
+import { ApiService as ApiServiceAbstraction } from "@/jslib/common/src/abstractions/api.service";
+import { AppIdService as AppIdServiceAbstraction } from "@/jslib/common/src/abstractions/appId.service";
+import { BroadcasterService as BroadcasterServiceAbstraction } from "@/jslib/common/src/abstractions/broadcaster.service";
+import { CryptoService as CryptoServiceAbstraction } from "@/jslib/common/src/abstractions/crypto.service";
+import { CryptoFunctionService as CryptoFunctionServiceAbstraction } from "@/jslib/common/src/abstractions/cryptoFunction.service";
+import { EnvironmentService as EnvironmentServiceAbstraction } from "@/jslib/common/src/abstractions/environment.service";
+import { I18nService as I18nServiceAbstraction } from "@/jslib/common/src/abstractions/i18n.service";
+import { LogService } from "@/jslib/common/src/abstractions/log.service";
+import { MessagingService as MessagingServiceAbstraction } from "@/jslib/common/src/abstractions/messaging.service";
+import { PlatformUtilsService as PlatformUtilsServiceAbstraction } from "@/jslib/common/src/abstractions/platformUtils.service";
+import { StateService as StateServiceAbstraction } from "@/jslib/common/src/abstractions/state.service";
+import { StateMigrationService as StateMigrationServiceAbstraction } from "@/jslib/common/src/abstractions/stateMigration.service";
+import { StorageService as StorageServiceAbstraction } from "@/jslib/common/src/abstractions/storage.service";
+import { TokenService as TokenServiceAbstraction } from "@/jslib/common/src/abstractions/token.service";
+import { StateFactory } from "@/jslib/common/src/factories/stateFactory";
+import { Account } from "@/jslib/common/src/models/domain/account";
+import { GlobalState } from "@/jslib/common/src/models/domain/globalState";
+import { ApiService } from "@/jslib/common/src/services/api.service";
+import { AppIdService } from "@/jslib/common/src/services/appId.service";
+import { ConsoleLogService } from "@/jslib/common/src/services/consoleLog.service";
+import { CryptoService } from "@/jslib/common/src/services/crypto.service";
+import { EnvironmentService } from "@/jslib/common/src/services/environment.service";
+import { StateService } from "@/jslib/common/src/services/state.service";
+import { StateMigrationService } from "@/jslib/common/src/services/stateMigration.service";
+import { TokenService } from "@/jslib/common/src/services/token.service";
+
+import {
+  SafeInjectionToken,
+  SECURE_STORAGE,
+  WINDOW,
+} from "../../../../src/app/services/injection-tokens";
+import { SafeProvider, safeProvider } from "../../../../src/app/services/safe-provider";
 
-import { AuthGuardService } from "./auth-guard.service";
 import { BroadcasterService } from "./broadcaster.service";
-import { LockGuardService } from "./lock-guard.service";
 import { ModalService } from "./modal.service";
-import { PasswordRepromptService } from "./passwordReprompt.service";
-import { UnauthGuardService } from "./unauth-guard.service";
 import { ValidationService } from "./validation.service";
 
 @NgModule({
   declarations: [],
   providers: [
-    { provide: "WINDOW", useValue: window },
-    {
-      provide: LOCALE_ID,
+    safeProvider({ provide: WINDOW, useValue: window }),
+    safeProvider({
+      provide: LOCALE_ID as SafeInjectionToken<string>,
       useFactory: (i18nService: I18nServiceAbstraction) => i18nService.translationLocale,
       deps: [I18nServiceAbstraction],
-    },
-    ValidationService,
-    AuthGuardService,
-    UnauthGuardService,
-    LockGuardService,
-    ModalService,
-    {
+    }),
+    safeProvider(ValidationService),
+    safeProvider(ModalService),
+    safeProvider({
       provide: AppIdServiceAbstraction,
       useClass: AppIdService,
       deps: [StorageServiceAbstraction],
-    },
-    {
-      provide: AuditServiceAbstraction,
-      useClass: AuditService,
-      deps: [CryptoFunctionServiceAbstraction, ApiServiceAbstraction],
-    },
-    {
-      provide: AuthServiceAbstraction,
-      useClass: AuthService,
-      deps: [
-        CryptoServiceAbstraction,
-        ApiServiceAbstraction,
-        TokenServiceAbstraction,
-        AppIdServiceAbstraction,
-        PlatformUtilsServiceAbstraction,
-        MessagingServiceAbstraction,
-        LogService,
-        KeyConnectorServiceAbstraction,
-        EnvironmentServiceAbstraction,
-        StateServiceAbstraction,
-        TwoFactorServiceAbstraction,
-        I18nServiceAbstraction,
-      ],
-    },
-    {
-      provide: CipherServiceAbstraction,
-      useFactory: (
-        cryptoService: CryptoServiceAbstraction,
-        settingsService: SettingsServiceAbstraction,
-        apiService: ApiServiceAbstraction,
-        fileUploadService: FileUploadServiceAbstraction,
-        i18nService: I18nServiceAbstraction,
-        injector: Injector,
-        logService: LogService,
-        stateService: StateServiceAbstraction
-      ) =>
-        new CipherService(
-          cryptoService,
-          settingsService,
-          apiService,
-          fileUploadService,
-          i18nService,
-          () => injector.get(SearchServiceAbstraction),
-          logService,
-          stateService
-        ),
-      deps: [
-        CryptoServiceAbstraction,
-        SettingsServiceAbstraction,
-        ApiServiceAbstraction,
-        FileUploadServiceAbstraction,
-        I18nServiceAbstraction,
-        Injector, // TODO: Get rid of this circular dependency!
-        LogService,
-        StateServiceAbstraction,
-      ],
-    },
-    {
-      provide: FolderServiceAbstraction,
-      useClass: FolderService,
-      deps: [
-        CryptoServiceAbstraction,
-        ApiServiceAbstraction,
-        I18nServiceAbstraction,
-        CipherServiceAbstraction,
-        StateServiceAbstraction,
-      ],
-    },
-    { provide: LogService, useFactory: () => new ConsoleLogService(false) },
-    {
-      provide: CollectionServiceAbstraction,
-      useClass: CollectionService,
-      deps: [CryptoServiceAbstraction, I18nServiceAbstraction, StateServiceAbstraction],
-    },
-    {
+    }),
+    safeProvider({ provide: LogService, useFactory: () => new ConsoleLogService(false), deps: [] }),
+    safeProvider({
       provide: EnvironmentServiceAbstraction,
       useClass: EnvironmentService,
       deps: [StateServiceAbstraction],
-    },
-    {
-      provide: TotpServiceAbstraction,
-      useClass: TotpService,
-      deps: [CryptoFunctionServiceAbstraction, LogService, StateServiceAbstraction],
-    },
-    { provide: TokenServiceAbstraction, useClass: TokenService, deps: [StateServiceAbstraction] },
-    {
+    }),
+    safeProvider({
+      provide: TokenServiceAbstraction,
+      useClass: TokenService,
+      deps: [StateServiceAbstraction],
+    }),
+    safeProvider({
       provide: CryptoServiceAbstraction,
       useClass: CryptoService,
       deps: [
@@ -194,32 +73,22 @@ import { ValidationService } from "./validation.service";
         LogService,
         StateServiceAbstraction,
       ],
-    },
-    {
-      provide: PasswordGenerationServiceAbstraction,
-      useClass: PasswordGenerationService,
-      deps: [CryptoServiceAbstraction, PolicyServiceAbstraction, StateServiceAbstraction],
-    },
-    {
-      provide: UsernameGenerationServiceAbstraction,
-      useClass: UsernameGenerationService,
-      deps: [CryptoServiceAbstraction, StateServiceAbstraction],
-    },
-    {
+    }),
+    safeProvider({
       provide: ApiServiceAbstraction,
       useFactory: (
         tokenService: TokenServiceAbstraction,
         platformUtilsService: PlatformUtilsServiceAbstraction,
         environmentService: EnvironmentServiceAbstraction,
         messagingService: MessagingServiceAbstraction,
-        appIdService: AppIdServiceAbstraction
+        appIdService: AppIdServiceAbstraction,
       ) =>
         new ApiService(
           tokenService,
           platformUtilsService,
           environmentService,
           appIdService,
-          async (expired: boolean) => messagingService.send("logout", { expired: expired })
+          async (expired: boolean) => messagingService.send("logout", { expired: expired }),
         ),
       deps: [
         TokenServiceAbstraction,
@@ -228,265 +97,47 @@ import { ValidationService } from "./validation.service";
         MessagingServiceAbstraction,
         AppIdServiceAbstraction,
       ],
-    },
-    {
-      provide: FileUploadServiceAbstraction,
-      useClass: FileUploadService,
-      deps: [LogService, ApiServiceAbstraction],
-    },
-    {
-      provide: SyncServiceAbstraction,
-      useFactory: (
-        apiService: ApiServiceAbstraction,
-        settingsService: SettingsServiceAbstraction,
-        folderService: FolderServiceAbstraction,
-        cipherService: CipherServiceAbstraction,
-        cryptoService: CryptoServiceAbstraction,
-        collectionService: CollectionServiceAbstraction,
-        messagingService: MessagingServiceAbstraction,
-        policyService: PolicyServiceAbstraction,
-        sendService: SendServiceAbstraction,
-        logService: LogService,
-        keyConnectorService: KeyConnectorServiceAbstraction,
-        stateService: StateServiceAbstraction,
-        organizationService: OrganizationServiceAbstraction,
-        providerService: ProviderServiceAbstraction
-      ) =>
-        new SyncService(
-          apiService,
-          settingsService,
-          folderService,
-          cipherService,
-          cryptoService,
-          collectionService,
-          messagingService,
-          policyService,
-          sendService,
-          logService,
-          keyConnectorService,
-          stateService,
-          organizationService,
-          providerService,
-          async (expired: boolean) => messagingService.send("logout", { expired: expired })
-        ),
-      deps: [
-        ApiServiceAbstraction,
-        SettingsServiceAbstraction,
-        FolderServiceAbstraction,
-        CipherServiceAbstraction,
-        CryptoServiceAbstraction,
-        CollectionServiceAbstraction,
-        MessagingServiceAbstraction,
-        PolicyServiceAbstraction,
-        SendServiceAbstraction,
-        LogService,
-        KeyConnectorServiceAbstraction,
-        StateServiceAbstraction,
-        OrganizationServiceAbstraction,
-        ProviderServiceAbstraction,
-      ],
-    },
-    { provide: BroadcasterServiceAbstraction, useClass: BroadcasterService },
-    {
-      provide: SettingsServiceAbstraction,
-      useClass: SettingsService,
-      deps: [StateServiceAbstraction],
-    },
-    {
-      provide: VaultTimeoutServiceAbstraction,
-      useFactory: (
-        cipherService: CipherServiceAbstraction,
-        folderService: FolderServiceAbstraction,
-        collectionService: CollectionServiceAbstraction,
-        cryptoService: CryptoServiceAbstraction,
-        platformUtilsService: PlatformUtilsServiceAbstraction,
-        messagingService: MessagingServiceAbstraction,
-        searchService: SearchServiceAbstraction,
-        tokenService: TokenServiceAbstraction,
-        policyService: PolicyServiceAbstraction,
-        keyConnectorService: KeyConnectorServiceAbstraction,
-        stateService: StateServiceAbstraction
-      ) =>
-        new VaultTimeoutService(
-          cipherService,
-          folderService,
-          collectionService,
-          cryptoService,
-          platformUtilsService,
-          messagingService,
-          searchService,
-          tokenService,
-          policyService,
-          keyConnectorService,
-          stateService,
-          null,
-          async (userId?: string) =>
-            messagingService.send("logout", { expired: false, userId: userId })
-        ),
-      deps: [
-        CipherServiceAbstraction,
-        FolderServiceAbstraction,
-        CollectionServiceAbstraction,
-        CryptoServiceAbstraction,
-        PlatformUtilsServiceAbstraction,
-        MessagingServiceAbstraction,
-        SearchServiceAbstraction,
-        TokenServiceAbstraction,
-        PolicyServiceAbstraction,
-        KeyConnectorServiceAbstraction,
-        StateServiceAbstraction,
-      ],
-    },
-    {
+    }),
+    safeProvider({
+      provide: BroadcasterServiceAbstraction,
+      useClass: BroadcasterService,
+      useAngularDecorators: true,
+    }),
+    safeProvider({
       provide: StateServiceAbstraction,
       useFactory: (
         storageService: StorageServiceAbstraction,
         secureStorageService: StorageServiceAbstraction,
         logService: LogService,
-        stateMigrationService: StateMigrationServiceAbstraction
+        stateMigrationService: StateMigrationServiceAbstraction,
       ) =>
         new StateService(
           storageService,
           secureStorageService,
           logService,
           stateMigrationService,
-          new StateFactory(GlobalState, Account)
+          new StateFactory(GlobalState, Account),
         ),
       deps: [
         StorageServiceAbstraction,
-        "SECURE_STORAGE",
+        SECURE_STORAGE,
         LogService,
         StateMigrationServiceAbstraction,
       ],
-    },
-    {
+    }),
+    safeProvider({
       provide: StateMigrationServiceAbstraction,
       useFactory: (
         storageService: StorageServiceAbstraction,
-        secureStorageService: StorageServiceAbstraction
+        secureStorageService: StorageServiceAbstraction,
       ) =>
         new StateMigrationService(
           storageService,
           secureStorageService,
-          new StateFactory(GlobalState, Account)
+          new StateFactory(GlobalState, Account),
         ),
-      deps: [StorageServiceAbstraction, "SECURE_STORAGE"],
-    },
-    {
-      provide: ExportServiceAbstraction,
-      useClass: ExportService,
-      deps: [
-        FolderServiceAbstraction,
-        CipherServiceAbstraction,
-        ApiServiceAbstraction,
-        CryptoServiceAbstraction,
-      ],
-    },
-    {
-      provide: SearchServiceAbstraction,
-      useClass: SearchService,
-      deps: [CipherServiceAbstraction, LogService, I18nServiceAbstraction],
-    },
-    {
-      provide: NotificationsServiceAbstraction,
-      useFactory: (
-        syncService: SyncServiceAbstraction,
-        appIdService: AppIdServiceAbstraction,
-        apiService: ApiServiceAbstraction,
-        vaultTimeoutService: VaultTimeoutServiceAbstraction,
-        environmentService: EnvironmentServiceAbstraction,
-        messagingService: MessagingServiceAbstraction,
-        logService: LogService,
-        stateService: StateServiceAbstraction
-      ) =>
-        new NotificationsService(
-          syncService,
-          appIdService,
-          apiService,
-          vaultTimeoutService,
-          environmentService,
-          async () => messagingService.send("logout", { expired: true }),
-          logService,
-          stateService
-        ),
-      deps: [
-        SyncServiceAbstraction,
-        AppIdServiceAbstraction,
-        ApiServiceAbstraction,
-        VaultTimeoutServiceAbstraction,
-        EnvironmentServiceAbstraction,
-        MessagingServiceAbstraction,
-        LogService,
-        StateServiceAbstraction,
-      ],
-    },
-    {
-      provide: CryptoFunctionServiceAbstraction,
-      useClass: WebCryptoFunctionService,
-      deps: ["WINDOW"],
-    },
-    {
-      provide: EventServiceAbstraction,
-      useClass: EventService,
-      deps: [
-        ApiServiceAbstraction,
-        CipherServiceAbstraction,
-        StateServiceAbstraction,
-        LogService,
-        OrganizationServiceAbstraction,
-      ],
-    },
-    {
-      provide: PolicyServiceAbstraction,
-      useClass: PolicyService,
-      deps: [StateServiceAbstraction, OrganizationServiceAbstraction, ApiServiceAbstraction],
-    },
-    {
-      provide: SendServiceAbstraction,
-      useClass: SendService,
-      deps: [
-        CryptoServiceAbstraction,
-        ApiServiceAbstraction,
-        FileUploadServiceAbstraction,
-        I18nServiceAbstraction,
-        CryptoFunctionServiceAbstraction,
-        StateServiceAbstraction,
-      ],
-    },
-    {
-      provide: KeyConnectorServiceAbstraction,
-      useClass: KeyConnectorService,
-      deps: [
-        StateServiceAbstraction,
-        CryptoServiceAbstraction,
-        ApiServiceAbstraction,
-        TokenServiceAbstraction,
-        LogService,
-        OrganizationServiceAbstraction,
-        CryptoFunctionServiceAbstraction,
-      ],
-    },
-    {
-      provide: UserVerificationServiceAbstraction,
-      useClass: UserVerificationService,
-      deps: [CryptoServiceAbstraction, I18nServiceAbstraction, ApiServiceAbstraction],
-    },
-    { provide: PasswordRepromptServiceAbstraction, useClass: PasswordRepromptService },
-    {
-      provide: OrganizationServiceAbstraction,
-      useClass: OrganizationService,
-      deps: [StateServiceAbstraction],
-    },
-    {
-      provide: ProviderServiceAbstraction,
-      useClass: ProviderService,
-      deps: [StateServiceAbstraction],
-    },
-    {
-      provide: TwoFactorServiceAbstraction,
-      useClass: TwoFactorService,
-      deps: [I18nServiceAbstraction, PlatformUtilsServiceAbstraction],
-    },
-  ],
+      deps: [StorageServiceAbstraction, SECURE_STORAGE],
+    }),
+  ] satisfies SafeProvider[],
 })
 export class JslibServicesModule {}

jslib/angular/src/services/lock-guard.service.ts

@@ -1,29 +0,0 @@
-import { Injectable } from "@angular/core";
-import { CanActivate, Router } from "@angular/router";
-
-import { StateService } from "jslib-common/abstractions/state.service";
-import { VaultTimeoutService } from "jslib-common/abstractions/vaultTimeout.service";
-
-@Injectable()
-export class LockGuardService implements CanActivate {
-  protected homepage = "vault";
-  protected loginpage = "login";
-  constructor(
-    private vaultTimeoutService: VaultTimeoutService,
-    private router: Router,
-    private stateService: StateService
-  ) {}
-
-  async canActivate() {
-    if (await this.vaultTimeoutService.isLocked()) {
-      return true;
-    }
-
-    const redirectUrl = (await this.stateService.getIsAuthenticated())
-      ? [this.homepage]
-      : [this.loginpage];
-
-    this.router.navigate(redirectUrl);
-    return false;
-  }
-}

jslib/angular/src/services/modal.service.ts

@@ -9,7 +9,7 @@ import {
   Type,
   ViewContainerRef,
 } from "@angular/core";
-import { first } from "rxjs/operators";
+import { first, firstValueFrom } from "rxjs";
 
 import { DynamicModalComponent } from "../components/modal/dynamic-modal.component";
 import { ModalInjector } from "../components/modal/modal-injector";
@@ -31,7 +31,7 @@ export class ModalService {
   constructor(
     private componentFactoryResolver: ComponentFactoryResolver,
     private applicationRef: ApplicationRef,
-    private injector: Injector
+    private injector: Injector,
   ) {
     document.addEventListener("keyup", (event) => {
       if (event.key === "Escape" && this.modalCount > 0) {
@@ -51,14 +51,14 @@ export class ModalService {
   async openViewRef<T>(
     componentType: Type<T>,
     viewContainerRef: ViewContainerRef,
-    setComponentParameters: (component: T) => void = null
+    setComponentParameters: (component: T) => void = null,
   ): Promise<[ModalRef, T]> {
     const [modalRef, modalComponentRef] = this.openInternal(componentType, null, false);
     modalComponentRef.instance.setComponentParameters = setComponentParameters;
 
     viewContainerRef.insert(modalComponentRef.hostView);
 
-    await modalRef.onCreated.pipe(first()).toPromise();
+    await firstValueFrom(modalRef.onCreated);
 
     return [modalRef, modalComponentRef.instance.componentRef.instance];
   }
@@ -76,7 +76,7 @@ export class ModalService {
 
   registerComponentFactoryResolver<T>(
     componentType: Type<T>,
-    componentFactoryResolver: ComponentFactoryResolver
+    componentFactoryResolver: ComponentFactoryResolver,
   ): void {
     this.factoryResolvers.set(componentType, componentFactoryResolver);
   }
@@ -92,7 +92,7 @@ export class ModalService {
   protected openInternal(
     componentType: Type<any>,
     config?: ModalConfig,
-    attachToDom?: boolean
+    attachToDom?: boolean,
   ): [ModalRef, ComponentRef<DynamicModalComponent>] {
     const [modalRef, componentRef] = this.createModalComponent(config);
     componentRef.instance.childComponentType = componentType;
@@ -143,7 +143,7 @@ export class ModalService {
       dialogEl.style.zIndex = `${this.modalCount}050`;
 
       const modals = Array.from(
-        el.querySelectorAll('.modal-backdrop, .modal *[data-dismiss="modal"]')
+        el.querySelectorAll('.modal-backdrop, .modal *[data-bs-dismiss="modal"]'),
       );
       for (const closeElement of modals) {
         closeElement.addEventListener("click", () => {
@@ -163,7 +163,7 @@ export class ModalService {
   }
 
   protected createModalComponent(
-    config: ModalConfig
+    config: ModalConfig,
   ): [ModalRef, ComponentRef<DynamicModalComponent>] {
     const modalRef = new ModalRef();
 

jslib/angular/src/services/passwordReprompt.service.ts

@@ -1,45 +0,0 @@
-import { Injectable } from "@angular/core";
-
-import { KeyConnectorService } from "jslib-common/abstractions/keyConnector.service";
-import { PasswordRepromptService as PasswordRepromptServiceAbstraction } from "jslib-common/abstractions/passwordReprompt.service";
-
-import { PasswordRepromptComponent } from "../components/password-reprompt.component";
-
-import { ModalService } from "./modal.service";
-
-/**
- * Used to verify the user's Master Password for the "Master Password Re-prompt" feature only.
- * See UserVerificationService for any other situation where you need to verify the user's identity.
- */
-@Injectable()
-export class PasswordRepromptService implements PasswordRepromptServiceAbstraction {
-  protected component = PasswordRepromptComponent;
-
-  constructor(
-    private modalService: ModalService,
-    private keyConnectorService: KeyConnectorService
-  ) {}
-
-  protectedFields() {
-    return ["TOTP", "Password", "H_Field", "Card Number", "Security Code"];
-  }
-
-  async showPasswordPrompt() {
-    if (!(await this.enabled())) {
-      return true;
-    }
-
-    const ref = this.modalService.open(this.component, { allowMultipleModals: true });
-
-    if (ref == null) {
-      return false;
-    }
-
-    const result = await ref.onClosedPromise();
-    return result === true;
-  }
-
-  async enabled() {
-    return !(await this.keyConnectorService.getUsesKeyConnector());
-  }
-}

jslib/angular/src/services/unauth-guard.service.ts

@@ -1,29 +0,0 @@
-import { Injectable } from "@angular/core";
-import { CanActivate, Router } from "@angular/router";
-
-import { StateService } from "jslib-common/abstractions/state.service";
-import { VaultTimeoutService } from "jslib-common/abstractions/vaultTimeout.service";
-
-@Injectable()
-export class UnauthGuardService implements CanActivate {
-  protected homepage = "vault";
-  constructor(
-    private vaultTimeoutService: VaultTimeoutService,
-    private router: Router,
-    private stateService: StateService
-  ) {}
-
-  async canActivate() {
-    const isAuthed = await this.stateService.getIsAuthenticated();
-    if (isAuthed) {
-      const locked = await this.vaultTimeoutService.isLocked();
-      if (locked) {
-        this.router.navigate(["lock"]);
-      } else {
-        this.router.navigate([this.homepage]);
-      }
-      return false;
-    }
-    return true;
-  }
-}

jslib/angular/src/services/validation.service.ts

@@ -1,14 +1,14 @@
 import { Injectable } from "@angular/core";
 
-import { I18nService } from "jslib-common/abstractions/i18n.service";
-import { PlatformUtilsService } from "jslib-common/abstractions/platformUtils.service";
-import { ErrorResponse } from "jslib-common/models/response/errorResponse";
+import { I18nService } from "@/jslib/common/src/abstractions/i18n.service";
+import { PlatformUtilsService } from "@/jslib/common/src/abstractions/platformUtils.service";
+import { ErrorResponse } from "@/jslib/common/src/models/response/errorResponse";
 
 @Injectable()
 export class ValidationService {
   constructor(
     private i18nService: I18nService,
-    private platformUtilsService: PlatformUtilsService
+    private platformUtilsService: PlatformUtilsService,
   ) {}
 
   showError(data: any): string[] {

jslib/angular/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "extends": "../shared/tsconfig",
-  "compilerOptions": {
-    "paths": {
-      "jslib-common/*": ["../common/src/*"],
-      "jslib-angular/*": ["./src/"]
-    }
-  },
-  "include": ["src", "spec"],
-  "exclude": ["node_modules", "dist"]
-}

jslib/angular/tsconfig.spec.json

@@ -1,3 +0,0 @@
-{
-  "extends": "./tsconfig.json"
-}

jslib/common/jest.config.js

@@ -1,18 +0,0 @@
-const { pathsToModuleNameMapper } = require("ts-jest/utils");
-
-const { compilerOptions } = require("./tsconfig");
-
-module.exports = {
-  name: "common",
-  displayName: "common jslib tests",
-  preset: "ts-jest",
-  testEnvironment: "jsdom",
-  testMatch: ["**/+(*.)+(spec).+(ts)"],
-  setupFilesAfterEnv: ["<rootDir>/spec/test.ts"],
-  collectCoverage: true,
-  coverageReporters: ["html", "lcov"],
-  coverageDirectory: "coverage",
-  moduleNameMapper: pathsToModuleNameMapper(compilerOptions?.paths || {}, {
-    prefix: "<rootDir>/",
-  }),
-};

jslib/common/package-lock.json

@@ -1,956 +0,0 @@
-{
-  "name": "@bitwarden/jslib-common",
-  "version": "0.0.0",
-  "lockfileVersion": 2,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "@bitwarden/jslib-common",
-      "version": "0.0.0",
-      "license": "GPL-3.0",
-      "dependencies": {
-        "@microsoft/signalr": "5.0.10",
-        "@microsoft/signalr-protocol-msgpack": "5.0.10",
-        "big-integer": "1.6.48",
-        "browser-hrtime": "^1.1.8",
-        "lunr": "^2.3.9",
-        "node-forge": "^1.2.1",
-        "papaparse": "^5.3.0",
-        "rxjs": "^7.4.0",
-        "tldjs": "^2.3.1",
-        "zxcvbn": "^4.4.2"
-      },
-      "devDependencies": {
-        "@types/lunr": "^2.3.3",
-        "@types/node": "^16.11.12",
-        "@types/node-forge": "^1.0.1",
-        "@types/papaparse": "^5.2.5",
-        "@types/tldjs": "^2.3.0",
-        "@types/zxcvbn": "^4.4.1",
-        "rimraf": "^3.0.2",
-        "typescript": "4.3.5"
-      }
-    },
-    "node_modules/@microsoft/signalr": {
-      "version": "5.0.10",
-      "resolved": "https://registry.npmjs.org/@microsoft/signalr/-/signalr-5.0.10.tgz",
-      "integrity": "sha512-7jg6s/cmULyeVvt5/bTB4N9T30HvAF1S06hL+nPcQMODXcclRo34Zcli/dfTLR8lCX31/cVEOmVgxXBOVRQ+Dw==",
-      "dependencies": {
-        "abort-controller": "^3.0.0",
-        "eventsource": "^1.0.7",
-        "fetch-cookie": "^0.7.3",
-        "node-fetch": "^2.6.0",
-        "ws": "^6.0.0"
-      }
-    },
-    "node_modules/@microsoft/signalr-protocol-msgpack": {
-      "version": "5.0.10",
-      "resolved": "https://registry.npmjs.org/@microsoft/signalr-protocol-msgpack/-/signalr-protocol-msgpack-5.0.10.tgz",
-      "integrity": "sha512-HqZiNLyjYP1ONeLgYUjFBUsnhxSp5CW4AW8InsLI7lyAXZl2drUhkiBxf3xK9UsTErO1+9r5sdaYdSmUY8nx9A==",
-      "dependencies": {
-        "@microsoft/signalr": ">=5.0.10",
-        "msgpack5": "^4.5.0"
-      }
-    },
-    "node_modules/@types/lunr": {
-      "version": "2.3.4",
-      "resolved": "https://registry.npmjs.org/@types/lunr/-/lunr-2.3.4.tgz",
-      "integrity": "sha512-j4x4XJwZvorEUbA519VdQ5b9AOU9TSvfi8tvxMAfP8XzNLtFex7A8vFQwqOx3WACbV0KMXbACV3cZl4/gynQ7g==",
-      "dev": true
-    },
-    "node_modules/@types/node": {
-      "version": "16.11.26",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-16.11.26.tgz",
-      "integrity": "sha512-GZ7bu5A6+4DtG7q9GsoHXy3ALcgeIHP4NnL0Vv2wu0uUB/yQex26v0tf6/na1mm0+bS9Uw+0DFex7aaKr2qawQ==",
-      "dev": true
-    },
-    "node_modules/@types/node-forge": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/@types/node-forge/-/node-forge-1.0.1.tgz",
-      "integrity": "sha512-96ELNKv9tQJ19afdBUiM5iDw7OYEc53iUc51gAPR2aGaqRsO1DBROjqgZRjZa1tkPj7TnEOR0EnyAX6iryGkzA==",
-      "dev": true,
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/papaparse": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/@types/papaparse/-/papaparse-5.3.2.tgz",
-      "integrity": "sha512-BNbCHJkTE4RwmAFkCxEalET4mDvGr/1ld7ZtQ4i/laWI/iiVt+GL07stdvufle4KfywyvloqqpIiJscXNCrKxA==",
-      "dev": true,
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/tldjs": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/@types/tldjs/-/tldjs-2.3.1.tgz",
-      "integrity": "sha512-BQR04zLE0ve2eNrqxXw/Qp/f6LxvNrj/4A8ZgdQi3SzbBqxFhleI7N4DS/mSjDnODrUaEGgoWg4grAZR1kVj8w==",
-      "dev": true
-    },
-    "node_modules/@types/zxcvbn": {
-      "version": "4.4.1",
-      "resolved": "https://registry.npmjs.org/@types/zxcvbn/-/zxcvbn-4.4.1.tgz",
-      "integrity": "sha512-3NoqvZC2W5gAC5DZbTpCeJ251vGQmgcWIHQJGq2J240HY6ErQ9aWKkwfoKJlHLx+A83WPNTZ9+3cd2ILxbvr1w==",
-      "dev": true
-    },
-    "node_modules/abort-controller": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz",
-      "integrity": "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==",
-      "dependencies": {
-        "event-target-shim": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=6.5"
-      }
-    },
-    "node_modules/async-limiter": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/async-limiter/-/async-limiter-1.0.1.tgz",
-      "integrity": "sha512-csOlWGAcRFJaI6m+F2WKdnMKr4HhdhFVBk0H/QbJFMCr+uO2kwohwXQPxw/9OCxp05r5ghVBFSyioixx3gfkNQ=="
-    },
-    "node_modules/balanced-match": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
-      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
-      "dev": true
-    },
-    "node_modules/big-integer": {
-      "version": "1.6.48",
-      "resolved": "https://registry.npmjs.org/big-integer/-/big-integer-1.6.48.tgz",
-      "integrity": "sha512-j51egjPa7/i+RdiRuJbPdJ2FIUYYPhvYLjzoYbcMMm62ooO6F94fETG4MTs46zPAF9Brs04OajboA/qTGuz78w==",
-      "engines": {
-        "node": ">=0.6"
-      }
-    },
-    "node_modules/bl": {
-      "version": "2.2.1",
-      "resolved": "https://registry.npmjs.org/bl/-/bl-2.2.1.tgz",
-      "integrity": "sha512-6Pesp1w0DEX1N550i/uGV/TqucVL4AM/pgThFSN/Qq9si1/DF9aIHs1BxD8V/QU0HoeHO6cQRTAuYnLPKq1e4g==",
-      "dependencies": {
-        "readable-stream": "^2.3.5",
-        "safe-buffer": "^5.1.1"
-      }
-    },
-    "node_modules/brace-expansion": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
-      "dev": true,
-      "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "node_modules/browser-hrtime": {
-      "version": "1.1.8",
-      "resolved": "https://registry.npmjs.org/browser-hrtime/-/browser-hrtime-1.1.8.tgz",
-      "integrity": "sha512-kzXheikaJsBtzUBlyVtPIY5r0soQePzjwVwT4IlDpU2RvfB5Py52gpU98M77rgqMCheoSSZvrcrdj3t6cZ3suA=="
-    },
-    "node_modules/concat-map": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
-      "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=",
-      "dev": true
-    },
-    "node_modules/core-util-is": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz",
-      "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ=="
-    },
-    "node_modules/es6-denodeify": {
-      "version": "0.1.5",
-      "resolved": "https://registry.npmjs.org/es6-denodeify/-/es6-denodeify-0.1.5.tgz",
-      "integrity": "sha1-MdTV/pxVA+ElRgQ5MQ4WoqPznB8="
-    },
-    "node_modules/event-target-shim": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz",
-      "integrity": "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/eventsource": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-1.1.0.tgz",
-      "integrity": "sha512-VSJjT5oCNrFvCS6igjzPAt5hBzQ2qPBFIbJ03zLI9SE0mxwZpMw6BfJrbFHm1a141AavMEB8JHmBhWAd66PfCg==",
-      "dependencies": {
-        "original": "^1.0.0"
-      },
-      "engines": {
-        "node": ">=0.12.0"
-      }
-    },
-    "node_modules/fetch-cookie": {
-      "version": "0.7.3",
-      "resolved": "https://registry.npmjs.org/fetch-cookie/-/fetch-cookie-0.7.3.tgz",
-      "integrity": "sha512-rZPkLnI8x5V+zYAiz8QonAHsTb4BY+iFowFBI1RFn0zrO343AVp9X7/yUj/9wL6Ef/8fLls8b/vGtzUvmyAUGA==",
-      "dependencies": {
-        "es6-denodeify": "^0.1.1",
-        "tough-cookie": "^2.3.3"
-      }
-    },
-    "node_modules/fs.realpath": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
-      "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=",
-      "dev": true
-    },
-    "node_modules/glob": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz",
-      "integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==",
-      "dev": true,
-      "dependencies": {
-        "fs.realpath": "^1.0.0",
-        "inflight": "^1.0.4",
-        "inherits": "2",
-        "minimatch": "^3.0.4",
-        "once": "^1.3.0",
-        "path-is-absolute": "^1.0.0"
-      },
-      "engines": {
-        "node": "*"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/inflight": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
-      "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
-      "dev": true,
-      "dependencies": {
-        "once": "^1.3.0",
-        "wrappy": "1"
-      }
-    },
-    "node_modules/inherits": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
-      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
-    },
-    "node_modules/isarray": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
-      "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE="
-    },
-    "node_modules/lunr": {
-      "version": "2.3.9",
-      "resolved": "https://registry.npmjs.org/lunr/-/lunr-2.3.9.tgz",
-      "integrity": "sha512-zTU3DaZaF3Rt9rhN3uBMGQD3dD2/vFQqnvZCDv4dl5iOzq2IZQqTxu90r4E5J+nP70J3ilqVCrbho2eWaeW8Ow=="
-    },
-    "node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-      "dev": true,
-      "dependencies": {
-        "brace-expansion": "^1.1.7"
-      },
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/msgpack5": {
-      "version": "4.5.1",
-      "resolved": "https://registry.npmjs.org/msgpack5/-/msgpack5-4.5.1.tgz",
-      "integrity": "sha512-zC1vkcliryc4JGlL6OfpHumSYUHWFGimSI+OgfRCjTFLmKA2/foR9rMTOhWiqfOrfxJOctrpWPvrppf8XynJxw==",
-      "dependencies": {
-        "bl": "^2.0.1",
-        "inherits": "^2.0.3",
-        "readable-stream": "^2.3.6",
-        "safe-buffer": "^5.1.2"
-      }
-    },
-    "node_modules/node-fetch": {
-      "version": "2.6.7",
-      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.7.tgz",
-      "integrity": "sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==",
-      "dependencies": {
-        "whatwg-url": "^5.0.0"
-      },
-      "engines": {
-        "node": "4.x || >=6.0.0"
-      },
-      "peerDependencies": {
-        "encoding": "^0.1.0"
-      },
-      "peerDependenciesMeta": {
-        "encoding": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/node-forge": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/node-forge/-/node-forge-1.2.1.tgz",
-      "integrity": "sha512-Fcvtbb+zBcZXbTTVwqGA5W+MKBj56UjVRevvchv5XrcyXbmNdesfZL37nlcWOfpgHhgmxApw3tQbTr4CqNmX4w==",
-      "engines": {
-        "node": ">= 6.13.0"
-      }
-    },
-    "node_modules/once": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
-      "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
-      "dev": true,
-      "dependencies": {
-        "wrappy": "1"
-      }
-    },
-    "node_modules/original": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/original/-/original-1.0.2.tgz",
-      "integrity": "sha512-hyBVl6iqqUOJ8FqRe+l/gS8H+kKYjrEndd5Pm1MfBtsEKA038HkkdbAl/72EAXGyonD/PFsvmVG+EvcIpliMBg==",
-      "dependencies": {
-        "url-parse": "^1.4.3"
-      }
-    },
-    "node_modules/papaparse": {
-      "version": "5.3.1",
-      "resolved": "https://registry.npmjs.org/papaparse/-/papaparse-5.3.1.tgz",
-      "integrity": "sha512-Dbt2yjLJrCwH2sRqKFFJaN5XgIASO9YOFeFP8rIBRG2Ain8mqk5r1M6DkfvqEVozVcz3r3HaUGw253hA1nLIcA=="
-    },
-    "node_modules/path-is-absolute": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
-      "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
-      "dev": true,
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/process-nextick-args": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
-      "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag=="
-    },
-    "node_modules/psl": {
-      "version": "1.8.0",
-      "resolved": "https://registry.npmjs.org/psl/-/psl-1.8.0.tgz",
-      "integrity": "sha512-RIdOzyoavK+hA18OGGWDqUTsCLhtA7IcZ/6NCs4fFJaHBDab+pDDmDIByWFRQJq2Cd7r1OoQxBGKOaztq+hjIQ=="
-    },
-    "node_modules/punycode": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz",
-      "integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4="
-    },
-    "node_modules/querystringify": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/querystringify/-/querystringify-2.2.0.tgz",
-      "integrity": "sha512-FIqgj2EUvTa7R50u0rGsyTftzjYmv/a3hO345bZNrqabNqjtgiDMgmo4mkUjd+nzU5oF3dClKqFIPUKybUyqoQ=="
-    },
-    "node_modules/readable-stream": {
-      "version": "2.3.7",
-      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz",
-      "integrity": "sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==",
-      "dependencies": {
-        "core-util-is": "~1.0.0",
-        "inherits": "~2.0.3",
-        "isarray": "~1.0.0",
-        "process-nextick-args": "~2.0.0",
-        "safe-buffer": "~5.1.1",
-        "string_decoder": "~1.1.1",
-        "util-deprecate": "~1.0.1"
-      }
-    },
-    "node_modules/readable-stream/node_modules/safe-buffer": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="
-    },
-    "node_modules/requires-port": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz",
-      "integrity": "sha1-kl0mAdOaxIXgkc8NpcbmlNw9yv8="
-    },
-    "node_modules/rimraf": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
-      "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
-      "dev": true,
-      "dependencies": {
-        "glob": "^7.1.3"
-      },
-      "bin": {
-        "rimraf": "bin.js"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/rxjs": {
-      "version": "7.5.5",
-      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.5.5.tgz",
-      "integrity": "sha512-sy+H0pQofO95VDmFLzyaw9xNJU4KTRSwQIGM6+iG3SypAtCiLDzpeG8sJrNCWn2Up9km+KhkvTdbkrdy+yzZdw==",
-      "dependencies": {
-        "tslib": "^2.1.0"
-      }
-    },
-    "node_modules/safe-buffer": {
-      "version": "5.2.1",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
-      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ]
-    },
-    "node_modules/string_decoder": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
-      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
-      "dependencies": {
-        "safe-buffer": "~5.1.0"
-      }
-    },
-    "node_modules/string_decoder/node_modules/safe-buffer": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="
-    },
-    "node_modules/tldjs": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/tldjs/-/tldjs-2.3.1.tgz",
-      "integrity": "sha512-W/YVH/QczLUxVjnQhFC61Iq232NWu3TqDdO0S/MtXVz4xybejBov4ud+CIwN9aYqjOecEqIy0PscGkwpG9ZyTw==",
-      "hasInstallScript": true,
-      "dependencies": {
-        "punycode": "^1.4.1"
-      },
-      "engines": {
-        "node": ">= 4"
-      }
-    },
-    "node_modules/tough-cookie": {
-      "version": "2.5.0",
-      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.5.0.tgz",
-      "integrity": "sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==",
-      "dependencies": {
-        "psl": "^1.1.28",
-        "punycode": "^2.1.1"
-      },
-      "engines": {
-        "node": ">=0.8"
-      }
-    },
-    "node_modules/tough-cookie/node_modules/punycode": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz",
-      "integrity": "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/tr46": {
-      "version": "0.0.3",
-      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
-      "integrity": "sha1-gYT9NH2snNwYWZLzpmIuFLnZq2o="
-    },
-    "node_modules/tslib": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.3.1.tgz",
-      "integrity": "sha512-77EbyPPpMz+FRFRuAFlWMtmgUWGe9UOG2Z25NqCwiIjRhOf5iKGuzSe5P2w1laq+FkRy4p+PCuVkJSGkzTEKVw=="
-    },
-    "node_modules/typescript": {
-      "version": "4.3.5",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.3.5.tgz",
-      "integrity": "sha512-DqQgihaQ9cUrskJo9kIyW/+g0Vxsk8cDtZ52a3NGh0YNTfpUSArXSohyUGnvbPazEPLu398C0UxmKSOrPumUzA==",
-      "dev": true,
-      "bin": {
-        "tsc": "bin/tsc",
-        "tsserver": "bin/tsserver"
-      },
-      "engines": {
-        "node": ">=4.2.0"
-      }
-    },
-    "node_modules/url-parse": {
-      "version": "1.5.10",
-      "resolved": "https://registry.npmjs.org/url-parse/-/url-parse-1.5.10.tgz",
-      "integrity": "sha512-WypcfiRhfeUP9vvF0j6rw0J3hrWrw6iZv3+22h6iRMJ/8z1Tj6XfLP4DsUix5MhMPnXpiHDoKyoZ/bdCkwBCiQ==",
-      "dependencies": {
-        "querystringify": "^2.1.1",
-        "requires-port": "^1.0.0"
-      }
-    },
-    "node_modules/util-deprecate": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
-      "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8="
-    },
-    "node_modules/webidl-conversions": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
-      "integrity": "sha1-JFNCdeKnvGvnvIZhHMFq4KVlSHE="
-    },
-    "node_modules/whatwg-url": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
-      "integrity": "sha1-lmRU6HZUYuN2RNNib2dCzotwll0=",
-      "dependencies": {
-        "tr46": "~0.0.3",
-        "webidl-conversions": "^3.0.0"
-      }
-    },
-    "node_modules/wrappy": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
-      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
-      "dev": true
-    },
-    "node_modules/ws": {
-      "version": "6.2.2",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-6.2.2.tgz",
-      "integrity": "sha512-zmhltoSR8u1cnDsD43TX59mzoMZsLKqUweyYBAIvTngR3shc0W6aOZylZmq/7hqyVxPdi+5Ud2QInblgyE72fw==",
-      "dependencies": {
-        "async-limiter": "~1.0.0"
-      }
-    },
-    "node_modules/zxcvbn": {
-      "version": "4.4.2",
-      "resolved": "https://registry.npmjs.org/zxcvbn/-/zxcvbn-4.4.2.tgz",
-      "integrity": "sha1-KOwXzwl0PtyrBW3dixsGJizHPDA="
-    }
-  },
-  "dependencies": {
-    "@microsoft/signalr": {
-      "version": "5.0.10",
-      "resolved": "https://registry.npmjs.org/@microsoft/signalr/-/signalr-5.0.10.tgz",
-      "integrity": "sha512-7jg6s/cmULyeVvt5/bTB4N9T30HvAF1S06hL+nPcQMODXcclRo34Zcli/dfTLR8lCX31/cVEOmVgxXBOVRQ+Dw==",
-      "requires": {
-        "abort-controller": "^3.0.0",
-        "eventsource": "^1.0.7",
-        "fetch-cookie": "^0.7.3",
-        "node-fetch": "^2.6.0",
-        "ws": "^6.0.0"
-      }
-    },
-    "@microsoft/signalr-protocol-msgpack": {
-      "version": "5.0.10",
-      "resolved": "https://registry.npmjs.org/@microsoft/signalr-protocol-msgpack/-/signalr-protocol-msgpack-5.0.10.tgz",
-      "integrity": "sha512-HqZiNLyjYP1ONeLgYUjFBUsnhxSp5CW4AW8InsLI7lyAXZl2drUhkiBxf3xK9UsTErO1+9r5sdaYdSmUY8nx9A==",
-      "requires": {
-        "@microsoft/signalr": ">=5.0.10",
-        "msgpack5": "^4.5.0"
-      }
-    },
-    "@types/lunr": {
-      "version": "2.3.4",
-      "resolved": "https://registry.npmjs.org/@types/lunr/-/lunr-2.3.4.tgz",
-      "integrity": "sha512-j4x4XJwZvorEUbA519VdQ5b9AOU9TSvfi8tvxMAfP8XzNLtFex7A8vFQwqOx3WACbV0KMXbACV3cZl4/gynQ7g==",
-      "dev": true
-    },
-    "@types/node": {
-      "version": "16.11.26",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-16.11.26.tgz",
-      "integrity": "sha512-GZ7bu5A6+4DtG7q9GsoHXy3ALcgeIHP4NnL0Vv2wu0uUB/yQex26v0tf6/na1mm0+bS9Uw+0DFex7aaKr2qawQ==",
-      "dev": true
-    },
-    "@types/node-forge": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/@types/node-forge/-/node-forge-1.0.1.tgz",
-      "integrity": "sha512-96ELNKv9tQJ19afdBUiM5iDw7OYEc53iUc51gAPR2aGaqRsO1DBROjqgZRjZa1tkPj7TnEOR0EnyAX6iryGkzA==",
-      "dev": true,
-      "requires": {
-        "@types/node": "*"
-      }
-    },
-    "@types/papaparse": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/@types/papaparse/-/papaparse-5.3.2.tgz",
-      "integrity": "sha512-BNbCHJkTE4RwmAFkCxEalET4mDvGr/1ld7ZtQ4i/laWI/iiVt+GL07stdvufle4KfywyvloqqpIiJscXNCrKxA==",
-      "dev": true,
-      "requires": {
-        "@types/node": "*"
-      }
-    },
-    "@types/tldjs": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/@types/tldjs/-/tldjs-2.3.1.tgz",
-      "integrity": "sha512-BQR04zLE0ve2eNrqxXw/Qp/f6LxvNrj/4A8ZgdQi3SzbBqxFhleI7N4DS/mSjDnODrUaEGgoWg4grAZR1kVj8w==",
-      "dev": true
-    },
-    "@types/zxcvbn": {
-      "version": "4.4.1",
-      "resolved": "https://registry.npmjs.org/@types/zxcvbn/-/zxcvbn-4.4.1.tgz",
-      "integrity": "sha512-3NoqvZC2W5gAC5DZbTpCeJ251vGQmgcWIHQJGq2J240HY6ErQ9aWKkwfoKJlHLx+A83WPNTZ9+3cd2ILxbvr1w==",
-      "dev": true
-    },
-    "abort-controller": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz",
-      "integrity": "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==",
-      "requires": {
-        "event-target-shim": "^5.0.0"
-      }
-    },
-    "async-limiter": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/async-limiter/-/async-limiter-1.0.1.tgz",
-      "integrity": "sha512-csOlWGAcRFJaI6m+F2WKdnMKr4HhdhFVBk0H/QbJFMCr+uO2kwohwXQPxw/9OCxp05r5ghVBFSyioixx3gfkNQ=="
-    },
-    "balanced-match": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
-      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
-      "dev": true
-    },
-    "big-integer": {
-      "version": "1.6.48",
-      "resolved": "https://registry.npmjs.org/big-integer/-/big-integer-1.6.48.tgz",
-      "integrity": "sha512-j51egjPa7/i+RdiRuJbPdJ2FIUYYPhvYLjzoYbcMMm62ooO6F94fETG4MTs46zPAF9Brs04OajboA/qTGuz78w=="
-    },
-    "bl": {
-      "version": "2.2.1",
-      "resolved": "https://registry.npmjs.org/bl/-/bl-2.2.1.tgz",
-      "integrity": "sha512-6Pesp1w0DEX1N550i/uGV/TqucVL4AM/pgThFSN/Qq9si1/DF9aIHs1BxD8V/QU0HoeHO6cQRTAuYnLPKq1e4g==",
-      "requires": {
-        "readable-stream": "^2.3.5",
-        "safe-buffer": "^5.1.1"
-      }
-    },
-    "brace-expansion": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
-      "dev": true,
-      "requires": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "browser-hrtime": {
-      "version": "1.1.8",
-      "resolved": "https://registry.npmjs.org/browser-hrtime/-/browser-hrtime-1.1.8.tgz",
-      "integrity": "sha512-kzXheikaJsBtzUBlyVtPIY5r0soQePzjwVwT4IlDpU2RvfB5Py52gpU98M77rgqMCheoSSZvrcrdj3t6cZ3suA=="
-    },
-    "concat-map": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
-      "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=",
-      "dev": true
-    },
-    "core-util-is": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz",
-      "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ=="
-    },
-    "es6-denodeify": {
-      "version": "0.1.5",
-      "resolved": "https://registry.npmjs.org/es6-denodeify/-/es6-denodeify-0.1.5.tgz",
-      "integrity": "sha1-MdTV/pxVA+ElRgQ5MQ4WoqPznB8="
-    },
-    "event-target-shim": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz",
-      "integrity": "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ=="
-    },
-    "eventsource": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-1.1.0.tgz",
-      "integrity": "sha512-VSJjT5oCNrFvCS6igjzPAt5hBzQ2qPBFIbJ03zLI9SE0mxwZpMw6BfJrbFHm1a141AavMEB8JHmBhWAd66PfCg==",
-      "requires": {
-        "original": "^1.0.0"
-      }
-    },
-    "fetch-cookie": {
-      "version": "0.7.3",
-      "resolved": "https://registry.npmjs.org/fetch-cookie/-/fetch-cookie-0.7.3.tgz",
-      "integrity": "sha512-rZPkLnI8x5V+zYAiz8QonAHsTb4BY+iFowFBI1RFn0zrO343AVp9X7/yUj/9wL6Ef/8fLls8b/vGtzUvmyAUGA==",
-      "requires": {
-        "es6-denodeify": "^0.1.1",
-        "tough-cookie": "^2.3.3"
-      }
-    },
-    "fs.realpath": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
-      "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=",
-      "dev": true
-    },
-    "glob": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz",
-      "integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==",
-      "dev": true,
-      "requires": {
-        "fs.realpath": "^1.0.0",
-        "inflight": "^1.0.4",
-        "inherits": "2",
-        "minimatch": "^3.0.4",
-        "once": "^1.3.0",
-        "path-is-absolute": "^1.0.0"
-      }
-    },
-    "inflight": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
-      "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
-      "dev": true,
-      "requires": {
-        "once": "^1.3.0",
-        "wrappy": "1"
-      }
-    },
-    "inherits": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
-      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
-    },
-    "isarray": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
-      "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE="
-    },
-    "lunr": {
-      "version": "2.3.9",
-      "resolved": "https://registry.npmjs.org/lunr/-/lunr-2.3.9.tgz",
-      "integrity": "sha512-zTU3DaZaF3Rt9rhN3uBMGQD3dD2/vFQqnvZCDv4dl5iOzq2IZQqTxu90r4E5J+nP70J3ilqVCrbho2eWaeW8Ow=="
-    },
-    "minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-      "dev": true,
-      "requires": {
-        "brace-expansion": "^1.1.7"
-      }
-    },
-    "msgpack5": {
-      "version": "4.5.1",
-      "resolved": "https://registry.npmjs.org/msgpack5/-/msgpack5-4.5.1.tgz",
-      "integrity": "sha512-zC1vkcliryc4JGlL6OfpHumSYUHWFGimSI+OgfRCjTFLmKA2/foR9rMTOhWiqfOrfxJOctrpWPvrppf8XynJxw==",
-      "requires": {
-        "bl": "^2.0.1",
-        "inherits": "^2.0.3",
-        "readable-stream": "^2.3.6",
-        "safe-buffer": "^5.1.2"
-      }
-    },
-    "node-fetch": {
-      "version": "2.6.7",
-      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.7.tgz",
-      "integrity": "sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==",
-      "requires": {
-        "whatwg-url": "^5.0.0"
-      }
-    },
-    "node-forge": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/node-forge/-/node-forge-1.2.1.tgz",
-      "integrity": "sha512-Fcvtbb+zBcZXbTTVwqGA5W+MKBj56UjVRevvchv5XrcyXbmNdesfZL37nlcWOfpgHhgmxApw3tQbTr4CqNmX4w=="
-    },
-    "once": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
-      "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
-      "dev": true,
-      "requires": {
-        "wrappy": "1"
-      }
-    },
-    "original": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/original/-/original-1.0.2.tgz",
-      "integrity": "sha512-hyBVl6iqqUOJ8FqRe+l/gS8H+kKYjrEndd5Pm1MfBtsEKA038HkkdbAl/72EAXGyonD/PFsvmVG+EvcIpliMBg==",
-      "requires": {
-        "url-parse": "^1.4.3"
-      }
-    },
-    "papaparse": {
-      "version": "5.3.1",
-      "resolved": "https://registry.npmjs.org/papaparse/-/papaparse-5.3.1.tgz",
-      "integrity": "sha512-Dbt2yjLJrCwH2sRqKFFJaN5XgIASO9YOFeFP8rIBRG2Ain8mqk5r1M6DkfvqEVozVcz3r3HaUGw253hA1nLIcA=="
-    },
-    "path-is-absolute": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
-      "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
-      "dev": true
-    },
-    "process-nextick-args": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
-      "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag=="
-    },
-    "psl": {
-      "version": "1.8.0",
-      "resolved": "https://registry.npmjs.org/psl/-/psl-1.8.0.tgz",
-      "integrity": "sha512-RIdOzyoavK+hA18OGGWDqUTsCLhtA7IcZ/6NCs4fFJaHBDab+pDDmDIByWFRQJq2Cd7r1OoQxBGKOaztq+hjIQ=="
-    },
-    "punycode": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz",
-      "integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4="
-    },
-    "querystringify": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/querystringify/-/querystringify-2.2.0.tgz",
-      "integrity": "sha512-FIqgj2EUvTa7R50u0rGsyTftzjYmv/a3hO345bZNrqabNqjtgiDMgmo4mkUjd+nzU5oF3dClKqFIPUKybUyqoQ=="
-    },
-    "readable-stream": {
-      "version": "2.3.7",
-      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz",
-      "integrity": "sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==",
-      "requires": {
-        "core-util-is": "~1.0.0",
-        "inherits": "~2.0.3",
-        "isarray": "~1.0.0",
-        "process-nextick-args": "~2.0.0",
-        "safe-buffer": "~5.1.1",
-        "string_decoder": "~1.1.1",
-        "util-deprecate": "~1.0.1"
-      },
-      "dependencies": {
-        "safe-buffer": {
-          "version": "5.1.2",
-          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-          "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="
-        }
-      }
-    },
-    "requires-port": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz",
-      "integrity": "sha1-kl0mAdOaxIXgkc8NpcbmlNw9yv8="
-    },
-    "rimraf": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
-      "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
-      "dev": true,
-      "requires": {
-        "glob": "^7.1.3"
-      }
-    },
-    "rxjs": {
-      "version": "7.5.5",
-      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.5.5.tgz",
-      "integrity": "sha512-sy+H0pQofO95VDmFLzyaw9xNJU4KTRSwQIGM6+iG3SypAtCiLDzpeG8sJrNCWn2Up9km+KhkvTdbkrdy+yzZdw==",
-      "requires": {
-        "tslib": "^2.1.0"
-      }
-    },
-    "safe-buffer": {
-      "version": "5.2.1",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
-      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="
-    },
-    "string_decoder": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
-      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
-      "requires": {
-        "safe-buffer": "~5.1.0"
-      },
-      "dependencies": {
-        "safe-buffer": {
-          "version": "5.1.2",
-          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-          "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="
-        }
-      }
-    },
-    "tldjs": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/tldjs/-/tldjs-2.3.1.tgz",
-      "integrity": "sha512-W/YVH/QczLUxVjnQhFC61Iq232NWu3TqDdO0S/MtXVz4xybejBov4ud+CIwN9aYqjOecEqIy0PscGkwpG9ZyTw==",
-      "requires": {
-        "punycode": "^1.4.1"
-      }
-    },
-    "tough-cookie": {
-      "version": "2.5.0",
-      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.5.0.tgz",
-      "integrity": "sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==",
-      "requires": {
-        "psl": "^1.1.28",
-        "punycode": "^2.1.1"
-      },
-      "dependencies": {
-        "punycode": {
-          "version": "2.1.1",
-          "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz",
-          "integrity": "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A=="
-        }
-      }
-    },
-    "tr46": {
-      "version": "0.0.3",
-      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
-      "integrity": "sha1-gYT9NH2snNwYWZLzpmIuFLnZq2o="
-    },
-    "tslib": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.3.1.tgz",
-      "integrity": "sha512-77EbyPPpMz+FRFRuAFlWMtmgUWGe9UOG2Z25NqCwiIjRhOf5iKGuzSe5P2w1laq+FkRy4p+PCuVkJSGkzTEKVw=="
-    },
-    "typescript": {
-      "version": "4.3.5",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.3.5.tgz",
-      "integrity": "sha512-DqQgihaQ9cUrskJo9kIyW/+g0Vxsk8cDtZ52a3NGh0YNTfpUSArXSohyUGnvbPazEPLu398C0UxmKSOrPumUzA==",
-      "dev": true
-    },
-    "url-parse": {
-      "version": "1.5.10",
-      "resolved": "https://registry.npmjs.org/url-parse/-/url-parse-1.5.10.tgz",
-      "integrity": "sha512-WypcfiRhfeUP9vvF0j6rw0J3hrWrw6iZv3+22h6iRMJ/8z1Tj6XfLP4DsUix5MhMPnXpiHDoKyoZ/bdCkwBCiQ==",
-      "requires": {
-        "querystringify": "^2.1.1",
-        "requires-port": "^1.0.0"
-      }
-    },
-    "util-deprecate": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
-      "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8="
-    },
-    "webidl-conversions": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
-      "integrity": "sha1-JFNCdeKnvGvnvIZhHMFq4KVlSHE="
-    },
-    "whatwg-url": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
-      "integrity": "sha1-lmRU6HZUYuN2RNNib2dCzotwll0=",
-      "requires": {
-        "tr46": "~0.0.3",
-        "webidl-conversions": "^3.0.0"
-      }
-    },
-    "wrappy": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
-      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
-      "dev": true
-    },
-    "ws": {
-      "version": "6.2.2",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-6.2.2.tgz",
-      "integrity": "sha512-zmhltoSR8u1cnDsD43TX59mzoMZsLKqUweyYBAIvTngR3shc0W6aOZylZmq/7hqyVxPdi+5Ud2QInblgyE72fw==",
-      "requires": {
-        "async-limiter": "~1.0.0"
-      }
-    },
-    "zxcvbn": {
-      "version": "4.4.2",
-      "resolved": "https://registry.npmjs.org/zxcvbn/-/zxcvbn-4.4.2.tgz",
-      "integrity": "sha1-KOwXzwl0PtyrBW3dixsGJizHPDA="
-    }
-  }
-}

jslib/common/package.json

@@ -1,42 +0,0 @@
-{
-  "name": "@bitwarden/jslib-common",
-  "version": "0.0.0",
-  "description": "Common code used across Bitwarden JavaScript projects.",
-  "keywords": [
-    "bitwarden"
-  ],
-  "author": "Bitwarden Inc.",
-  "homepage": "https://bitwarden.com",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/bitwarden/jslib"
-  },
-  "license": "GPL-3.0",
-  "scripts": {
-    "clean": "rimraf dist/**/*",
-    "build": "npm run clean && tsc",
-    "build:watch": "npm run clean && tsc -watch"
-  },
-  "devDependencies": {
-    "@types/lunr": "^2.3.3",
-    "@types/node": "^16.11.12",
-    "@types/node-forge": "^1.0.1",
-    "@types/papaparse": "^5.2.5",
-    "@types/tldjs": "^2.3.0",
-    "@types/zxcvbn": "^4.4.1",
-    "rimraf": "^3.0.2",
-    "typescript": "4.3.5"
-  },
-  "dependencies": {
-    "@microsoft/signalr": "5.0.10",
-    "@microsoft/signalr-protocol-msgpack": "5.0.10",
-    "big-integer": "1.6.48",
-    "browser-hrtime": "^1.1.8",
-    "lunr": "^2.3.9",
-    "node-forge": "^1.2.1",
-    "papaparse": "^5.3.0",
-    "rxjs": "^7.4.0",
-    "tldjs": "^2.3.1",
-    "zxcvbn": "^4.4.2"
-  }
-}

jslib/common/spec/domain/attachment.spec.ts

@@ -1,83 +0,0 @@
-import Substitute, { Arg } from "@fluffy-spoon/substitute";
-
-import { CryptoService } from "jslib-common/abstractions/crypto.service";
-import { AttachmentData } from "jslib-common/models/data/attachmentData";
-import { Attachment } from "jslib-common/models/domain/attachment";
-import { SymmetricCryptoKey } from "jslib-common/models/domain/symmetricCryptoKey";
-import { ContainerService } from "jslib-common/services/container.service";
-
-import { makeStaticByteArray, mockEnc } from "../utils";
-
-describe("Attachment", () => {
-  let data: AttachmentData;
-
-  beforeEach(() => {
-    data = {
-      id: "id",
-      url: "url",
-      fileName: "fileName",
-      key: "key",
-      size: "1100",
-      sizeName: "1.1 KB",
-    };
-  });
-
-  it("Convert from empty", () => {
-    const data = new AttachmentData();
-    const attachment = new Attachment(data);
-
-    expect(attachment).toEqual({
-      id: null,
-      url: null,
-      size: undefined,
-      sizeName: null,
-      key: null,
-      fileName: null,
-    });
-  });
-
-  it("Convert", () => {
-    const attachment = new Attachment(data);
-
-    expect(attachment).toEqual({
-      size: "1100",
-      id: "id",
-      url: "url",
-      sizeName: "1.1 KB",
-      fileName: { encryptedString: "fileName", encryptionType: 0 },
-      key: { encryptedString: "key", encryptionType: 0 },
-    });
-  });
-
-  it("toAttachmentData", () => {
-    const attachment = new Attachment(data);
-    expect(attachment.toAttachmentData()).toEqual(data);
-  });
-
-  it("Decrypt", async () => {
-    const attachment = new Attachment();
-    attachment.id = "id";
-    attachment.url = "url";
-    attachment.size = "1100";
-    attachment.sizeName = "1.1 KB";
-    attachment.key = mockEnc("key");
-    attachment.fileName = mockEnc("fileName");
-
-    const cryptoService = Substitute.for<CryptoService>();
-    cryptoService.getOrgKey(null).resolves(null);
-    cryptoService.decryptToBytes(Arg.any(), Arg.any()).resolves(makeStaticByteArray(32));
-
-    (window as any).bitwardenContainerService = new ContainerService(cryptoService);
-
-    const view = await attachment.decrypt(null);
-
-    expect(view).toEqual({
-      id: "id",
-      url: "url",
-      size: "1100",
-      sizeName: "1.1 KB",
-      fileName: "fileName",
-      key: expect.any(SymmetricCryptoKey),
-    });
-  });
-});

jslib/common/spec/domain/card.spec.ts

@@ -1,73 +0,0 @@
-import { CardData } from "jslib-common/models/data/cardData";
-import { Card } from "jslib-common/models/domain/card";
-
-import { mockEnc } from "../utils";
-
-describe("Card", () => {
-  let data: CardData;
-
-  beforeEach(() => {
-    data = {
-      cardholderName: "encHolder",
-      brand: "encBrand",
-      number: "encNumber",
-      expMonth: "encMonth",
-      expYear: "encYear",
-      code: "encCode",
-    };
-  });
-
-  it("Convert from empty", () => {
-    const data = new CardData();
-    const card = new Card(data);
-
-    expect(card).toEqual({
-      cardholderName: null,
-      brand: null,
-      number: null,
-      expMonth: null,
-      expYear: null,
-      code: null,
-    });
-  });
-
-  it("Convert", () => {
-    const card = new Card(data);
-
-    expect(card).toEqual({
-      cardholderName: { encryptedString: "encHolder", encryptionType: 0 },
-      brand: { encryptedString: "encBrand", encryptionType: 0 },
-      number: { encryptedString: "encNumber", encryptionType: 0 },
-      expMonth: { encryptedString: "encMonth", encryptionType: 0 },
-      expYear: { encryptedString: "encYear", encryptionType: 0 },
-      code: { encryptedString: "encCode", encryptionType: 0 },
-    });
-  });
-
-  it("toCardData", () => {
-    const card = new Card(data);
-    expect(card.toCardData()).toEqual(data);
-  });
-
-  it("Decrypt", async () => {
-    const card = new Card();
-    card.cardholderName = mockEnc("cardHolder");
-    card.brand = mockEnc("brand");
-    card.number = mockEnc("number");
-    card.expMonth = mockEnc("expMonth");
-    card.expYear = mockEnc("expYear");
-    card.code = mockEnc("code");
-
-    const view = await card.decrypt(null);
-
-    expect(view).toEqual({
-      _brand: "brand",
-      _number: "number",
-      _subTitle: null,
-      cardholderName: "cardHolder",
-      code: "code",
-      expMonth: "expMonth",
-      expYear: "expYear",
-    });
-  });
-});

jslib/common/spec/domain/cipher.spec.ts

@@ -1,599 +0,0 @@
-import Substitute, { Arg } from "@fluffy-spoon/substitute";
-
-import { CipherRepromptType } from "jslib-common/enums/cipherRepromptType";
-import { CipherType } from "jslib-common/enums/cipherType";
-import { FieldType } from "jslib-common/enums/fieldType";
-import { SecureNoteType } from "jslib-common/enums/secureNoteType";
-import { UriMatchType } from "jslib-common/enums/uriMatchType";
-import { CipherData } from "jslib-common/models/data/cipherData";
-import { Card } from "jslib-common/models/domain/card";
-import { Cipher } from "jslib-common/models/domain/cipher";
-import { Identity } from "jslib-common/models/domain/identity";
-import { Login } from "jslib-common/models/domain/login";
-import { SecureNote } from "jslib-common/models/domain/secureNote";
-import { CardView } from "jslib-common/models/view/cardView";
-import { IdentityView } from "jslib-common/models/view/identityView";
-import { LoginView } from "jslib-common/models/view/loginView";
-
-import { mockEnc } from "../utils";
-
-describe("Cipher DTO", () => {
-  it("Convert from empty CipherData", () => {
-    const data = new CipherData();
-    const cipher = new Cipher(data);
-
-    expect(cipher).toEqual({
-      id: null,
-      userId: null,
-      organizationId: null,
-      folderId: null,
-      name: null,
-      notes: null,
-      type: undefined,
-      favorite: undefined,
-      organizationUseTotp: undefined,
-      edit: undefined,
-      viewPassword: true,
-      revisionDate: null,
-      collectionIds: undefined,
-      localData: null,
-      deletedDate: null,
-      reprompt: undefined,
-      attachments: null,
-      fields: null,
-      passwordHistory: null,
-    });
-  });
-
-  describe("LoginCipher", () => {
-    let cipherData: CipherData;
-
-    beforeEach(() => {
-      cipherData = {
-        id: "id",
-        organizationId: "orgId",
-        folderId: "folderId",
-        userId: "userId",
-        edit: true,
-        viewPassword: true,
-        organizationUseTotp: true,
-        favorite: false,
-        revisionDate: "2022-01-31T12:00:00.000Z",
-        type: CipherType.Login,
-        name: "EncryptedString",
-        notes: "EncryptedString",
-        deletedDate: null,
-        reprompt: CipherRepromptType.None,
-        login: {
-          uris: [{ uri: "EncryptedString", match: UriMatchType.Domain }],
-          username: "EncryptedString",
-          password: "EncryptedString",
-          passwordRevisionDate: "2022-01-31T12:00:00.000Z",
-          totp: "EncryptedString",
-          autofillOnPageLoad: false,
-        },
-        passwordHistory: [
-          { password: "EncryptedString", lastUsedDate: "2022-01-31T12:00:00.000Z" },
-        ],
-        attachments: [
-          {
-            id: "a1",
-            url: "url",
-            size: "1100",
-            sizeName: "1.1 KB",
-            fileName: "file",
-            key: "EncKey",
-          },
-          {
-            id: "a2",
-            url: "url",
-            size: "1100",
-            sizeName: "1.1 KB",
-            fileName: "file",
-            key: "EncKey",
-          },
-        ],
-        fields: [
-          {
-            name: "EncryptedString",
-            value: "EncryptedString",
-            type: FieldType.Text,
-            linkedId: null,
-          },
-          {
-            name: "EncryptedString",
-            value: "EncryptedString",
-            type: FieldType.Hidden,
-            linkedId: null,
-          },
-        ],
-      };
-    });
-
-    it("Convert", () => {
-      const cipher = new Cipher(cipherData);
-
-      expect(cipher).toEqual({
-        id: "id",
-        userId: "userId",
-        organizationId: "orgId",
-        folderId: "folderId",
-        name: { encryptedString: "EncryptedString", encryptionType: 0 },
-        notes: { encryptedString: "EncryptedString", encryptionType: 0 },
-        type: 1,
-        favorite: false,
-        organizationUseTotp: true,
-        edit: true,
-        viewPassword: true,
-        revisionDate: new Date("2022-01-31T12:00:00.000Z"),
-        collectionIds: undefined,
-        localData: null,
-        deletedDate: null,
-        reprompt: 0,
-        login: {
-          passwordRevisionDate: new Date("2022-01-31T12:00:00.000Z"),
-          autofillOnPageLoad: false,
-          username: { encryptedString: "EncryptedString", encryptionType: 0 },
-          password: { encryptedString: "EncryptedString", encryptionType: 0 },
-          totp: { encryptedString: "EncryptedString", encryptionType: 0 },
-          uris: [{ match: 0, uri: { encryptedString: "EncryptedString", encryptionType: 0 } }],
-        },
-        attachments: [
-          {
-            fileName: { encryptedString: "file", encryptionType: 0 },
-            id: "a1",
-            key: { encryptedString: "EncKey", encryptionType: 0 },
-            size: "1100",
-            sizeName: "1.1 KB",
-            url: "url",
-          },
-          {
-            fileName: { encryptedString: "file", encryptionType: 0 },
-            id: "a2",
-            key: { encryptedString: "EncKey", encryptionType: 0 },
-            size: "1100",
-            sizeName: "1.1 KB",
-            url: "url",
-          },
-        ],
-        fields: [
-          {
-            linkedId: null,
-            name: { encryptedString: "EncryptedString", encryptionType: 0 },
-            type: 0,
-            value: { encryptedString: "EncryptedString", encryptionType: 0 },
-          },
-          {
-            linkedId: null,
-            name: { encryptedString: "EncryptedString", encryptionType: 0 },
-            type: 1,
-            value: { encryptedString: "EncryptedString", encryptionType: 0 },
-          },
-        ],
-        passwordHistory: [
-          {
-            lastUsedDate: new Date("2022-01-31T12:00:00.000Z"),
-            password: { encryptedString: "EncryptedString", encryptionType: 0 },
-          },
-        ],
-      });
-    });
-
-    it("toCipherData", () => {
-      const cipher = new Cipher(cipherData);
-      expect(cipher.toCipherData("userId")).toEqual(cipherData);
-    });
-
-    it("Decrypt", async () => {
-      const cipher = new Cipher();
-      cipher.id = "id";
-      cipher.organizationId = "orgId";
-      cipher.folderId = "folderId";
-      cipher.edit = true;
-      cipher.viewPassword = true;
-      cipher.organizationUseTotp = true;
-      cipher.favorite = false;
-      cipher.revisionDate = new Date("2022-01-31T12:00:00.000Z");
-      cipher.type = CipherType.Login;
-      cipher.name = mockEnc("EncryptedString");
-      cipher.notes = mockEnc("EncryptedString");
-      cipher.deletedDate = null;
-      cipher.reprompt = CipherRepromptType.None;
-
-      const loginView = new LoginView();
-      loginView.username = "username";
-      loginView.password = "password";
-
-      const login = Substitute.for<Login>();
-      login.decrypt(Arg.any(), Arg.any()).resolves(loginView);
-      cipher.login = login;
-
-      const cipherView = await cipher.decrypt();
-
-      expect(cipherView).toMatchObject({
-        id: "id",
-        organizationId: "orgId",
-        folderId: "folderId",
-        name: "EncryptedString",
-        notes: "EncryptedString",
-        type: 1,
-        favorite: false,
-        organizationUseTotp: true,
-        edit: true,
-        viewPassword: true,
-        login: loginView,
-        attachments: null,
-        fields: null,
-        passwordHistory: null,
-        collectionIds: undefined,
-        revisionDate: new Date("2022-01-31T12:00:00.000Z"),
-        deletedDate: null,
-        reprompt: 0,
-        localData: undefined,
-      });
-    });
-  });
-
-  describe("SecureNoteCipher", () => {
-    let cipherData: CipherData;
-
-    beforeEach(() => {
-      cipherData = {
-        id: "id",
-        organizationId: "orgId",
-        folderId: "folderId",
-        userId: "userId",
-        edit: true,
-        viewPassword: true,
-        organizationUseTotp: true,
-        favorite: false,
-        revisionDate: "2022-01-31T12:00:00.000Z",
-        type: CipherType.SecureNote,
-        name: "EncryptedString",
-        notes: "EncryptedString",
-        deletedDate: null,
-        reprompt: CipherRepromptType.None,
-        secureNote: {
-          type: SecureNoteType.Generic,
-        },
-      };
-    });
-
-    it("Convert", () => {
-      const cipher = new Cipher(cipherData);
-
-      expect(cipher).toEqual({
-        id: "id",
-        userId: "userId",
-        organizationId: "orgId",
-        folderId: "folderId",
-        name: { encryptedString: "EncryptedString", encryptionType: 0 },
-        notes: { encryptedString: "EncryptedString", encryptionType: 0 },
-        type: 2,
-        favorite: false,
-        organizationUseTotp: true,
-        edit: true,
-        viewPassword: true,
-        revisionDate: new Date("2022-01-31T12:00:00.000Z"),
-        collectionIds: undefined,
-        localData: null,
-        deletedDate: null,
-        reprompt: 0,
-        secureNote: { type: SecureNoteType.Generic },
-        attachments: null,
-        fields: null,
-        passwordHistory: null,
-      });
-    });
-
-    it("toCipherData", () => {
-      const cipher = new Cipher(cipherData);
-      expect(cipher.toCipherData("userId")).toEqual(cipherData);
-    });
-
-    it("Decrypt", async () => {
-      const cipher = new Cipher();
-      cipher.id = "id";
-      cipher.organizationId = "orgId";
-      cipher.folderId = "folderId";
-      cipher.edit = true;
-      cipher.viewPassword = true;
-      cipher.organizationUseTotp = true;
-      cipher.favorite = false;
-      cipher.revisionDate = new Date("2022-01-31T12:00:00.000Z");
-      cipher.type = CipherType.SecureNote;
-      cipher.name = mockEnc("EncryptedString");
-      cipher.notes = mockEnc("EncryptedString");
-      cipher.deletedDate = null;
-      cipher.reprompt = CipherRepromptType.None;
-      cipher.secureNote = new SecureNote();
-      cipher.secureNote.type = SecureNoteType.Generic;
-
-      const cipherView = await cipher.decrypt();
-
-      expect(cipherView).toMatchObject({
-        id: "id",
-        organizationId: "orgId",
-        folderId: "folderId",
-        name: "EncryptedString",
-        notes: "EncryptedString",
-        type: 2,
-        favorite: false,
-        organizationUseTotp: true,
-        edit: true,
-        viewPassword: true,
-        secureNote: { type: 0 },
-        attachments: null,
-        fields: null,
-        passwordHistory: null,
-        collectionIds: undefined,
-        revisionDate: new Date("2022-01-31T12:00:00.000Z"),
-        deletedDate: null,
-        reprompt: 0,
-        localData: undefined,
-      });
-    });
-  });
-
-  describe("CardCipher", () => {
-    let cipherData: CipherData;
-
-    beforeEach(() => {
-      cipherData = {
-        id: "id",
-        organizationId: "orgId",
-        folderId: "folderId",
-        userId: "userId",
-        edit: true,
-        viewPassword: true,
-        organizationUseTotp: true,
-        favorite: false,
-        revisionDate: "2022-01-31T12:00:00.000Z",
-        type: CipherType.Card,
-        name: "EncryptedString",
-        notes: "EncryptedString",
-        deletedDate: null,
-        reprompt: CipherRepromptType.None,
-        card: {
-          cardholderName: "EncryptedString",
-          brand: "EncryptedString",
-          number: "EncryptedString",
-          expMonth: "EncryptedString",
-          expYear: "EncryptedString",
-          code: "EncryptedString",
-        },
-      };
-    });
-
-    it("Convert", () => {
-      const cipher = new Cipher(cipherData);
-
-      expect(cipher).toEqual({
-        id: "id",
-        userId: "userId",
-        organizationId: "orgId",
-        folderId: "folderId",
-        name: { encryptedString: "EncryptedString", encryptionType: 0 },
-        notes: { encryptedString: "EncryptedString", encryptionType: 0 },
-        type: 3,
-        favorite: false,
-        organizationUseTotp: true,
-        edit: true,
-        viewPassword: true,
-        revisionDate: new Date("2022-01-31T12:00:00.000Z"),
-        collectionIds: undefined,
-        localData: null,
-        deletedDate: null,
-        reprompt: 0,
-        card: {
-          cardholderName: { encryptedString: "EncryptedString", encryptionType: 0 },
-          brand: { encryptedString: "EncryptedString", encryptionType: 0 },
-          number: { encryptedString: "EncryptedString", encryptionType: 0 },
-          expMonth: { encryptedString: "EncryptedString", encryptionType: 0 },
-          expYear: { encryptedString: "EncryptedString", encryptionType: 0 },
-          code: { encryptedString: "EncryptedString", encryptionType: 0 },
-        },
-        attachments: null,
-        fields: null,
-        passwordHistory: null,
-      });
-    });
-
-    it("toCipherData", () => {
-      const cipher = new Cipher(cipherData);
-      expect(cipher.toCipherData("userId")).toEqual(cipherData);
-    });
-
-    it("Decrypt", async () => {
-      const cipher = new Cipher();
-      cipher.id = "id";
-      cipher.organizationId = "orgId";
-      cipher.folderId = "folderId";
-      cipher.edit = true;
-      cipher.viewPassword = true;
-      cipher.organizationUseTotp = true;
-      cipher.favorite = false;
-      cipher.revisionDate = new Date("2022-01-31T12:00:00.000Z");
-      cipher.type = CipherType.Card;
-      cipher.name = mockEnc("EncryptedString");
-      cipher.notes = mockEnc("EncryptedString");
-      cipher.deletedDate = null;
-      cipher.reprompt = CipherRepromptType.None;
-
-      const cardView = new CardView();
-      cardView.cardholderName = "cardholderName";
-      cardView.number = "4111111111111111";
-
-      const card = Substitute.for<Card>();
-      card.decrypt(Arg.any(), Arg.any()).resolves(cardView);
-      cipher.card = card;
-
-      const cipherView = await cipher.decrypt();
-
-      expect(cipherView).toMatchObject({
-        id: "id",
-        organizationId: "orgId",
-        folderId: "folderId",
-        name: "EncryptedString",
-        notes: "EncryptedString",
-        type: 3,
-        favorite: false,
-        organizationUseTotp: true,
-        edit: true,
-        viewPassword: true,
-        card: cardView,
-        attachments: null,
-        fields: null,
-        passwordHistory: null,
-        collectionIds: undefined,
-        revisionDate: new Date("2022-01-31T12:00:00.000Z"),
-        deletedDate: null,
-        reprompt: 0,
-        localData: undefined,
-      });
-    });
-  });
-
-  describe("IdentityCipher", () => {
-    let cipherData: CipherData;
-
-    beforeEach(() => {
-      cipherData = {
-        id: "id",
-        organizationId: "orgId",
-        folderId: "folderId",
-        userId: "userId",
-        edit: true,
-        viewPassword: true,
-        organizationUseTotp: true,
-        favorite: false,
-        revisionDate: "2022-01-31T12:00:00.000Z",
-        type: CipherType.Identity,
-        name: "EncryptedString",
-        notes: "EncryptedString",
-        deletedDate: null,
-        reprompt: CipherRepromptType.None,
-        identity: {
-          title: "EncryptedString",
-          firstName: "EncryptedString",
-          middleName: "EncryptedString",
-          lastName: "EncryptedString",
-          address1: "EncryptedString",
-          address2: "EncryptedString",
-          address3: "EncryptedString",
-          city: "EncryptedString",
-          state: "EncryptedString",
-          postalCode: "EncryptedString",
-          country: "EncryptedString",
-          company: "EncryptedString",
-          email: "EncryptedString",
-          phone: "EncryptedString",
-          ssn: "EncryptedString",
-          username: "EncryptedString",
-          passportNumber: "EncryptedString",
-          licenseNumber: "EncryptedString",
-        },
-      };
-    });
-
-    it("Convert", () => {
-      const cipher = new Cipher(cipherData);
-
-      expect(cipher).toEqual({
-        id: "id",
-        userId: "userId",
-        organizationId: "orgId",
-        folderId: "folderId",
-        name: { encryptedString: "EncryptedString", encryptionType: 0 },
-        notes: { encryptedString: "EncryptedString", encryptionType: 0 },
-        type: 4,
-        favorite: false,
-        organizationUseTotp: true,
-        edit: true,
-        viewPassword: true,
-        revisionDate: new Date("2022-01-31T12:00:00.000Z"),
-        collectionIds: undefined,
-        localData: null,
-        deletedDate: null,
-        reprompt: 0,
-        identity: {
-          title: { encryptedString: "EncryptedString", encryptionType: 0 },
-          firstName: { encryptedString: "EncryptedString", encryptionType: 0 },
-          middleName: { encryptedString: "EncryptedString", encryptionType: 0 },
-          lastName: { encryptedString: "EncryptedString", encryptionType: 0 },
-          address1: { encryptedString: "EncryptedString", encryptionType: 0 },
-          address2: { encryptedString: "EncryptedString", encryptionType: 0 },
-          address3: { encryptedString: "EncryptedString", encryptionType: 0 },
-          city: { encryptedString: "EncryptedString", encryptionType: 0 },
-          state: { encryptedString: "EncryptedString", encryptionType: 0 },
-          postalCode: { encryptedString: "EncryptedString", encryptionType: 0 },
-          country: { encryptedString: "EncryptedString", encryptionType: 0 },
-          company: { encryptedString: "EncryptedString", encryptionType: 0 },
-          email: { encryptedString: "EncryptedString", encryptionType: 0 },
-          phone: { encryptedString: "EncryptedString", encryptionType: 0 },
-          ssn: { encryptedString: "EncryptedString", encryptionType: 0 },
-          username: { encryptedString: "EncryptedString", encryptionType: 0 },
-          passportNumber: { encryptedString: "EncryptedString", encryptionType: 0 },
-          licenseNumber: { encryptedString: "EncryptedString", encryptionType: 0 },
-        },
-        attachments: null,
-        fields: null,
-        passwordHistory: null,
-      });
-    });
-
-    it("toCipherData", () => {
-      const cipher = new Cipher(cipherData);
-      expect(cipher.toCipherData("userId")).toEqual(cipherData);
-    });
-
-    it("Decrypt", async () => {
-      const cipher = new Cipher();
-      cipher.id = "id";
-      cipher.organizationId = "orgId";
-      cipher.folderId = "folderId";
-      cipher.edit = true;
-      cipher.viewPassword = true;
-      cipher.organizationUseTotp = true;
-      cipher.favorite = false;
-      cipher.revisionDate = new Date("2022-01-31T12:00:00.000Z");
-      cipher.type = CipherType.Identity;
-      cipher.name = mockEnc("EncryptedString");
-      cipher.notes = mockEnc("EncryptedString");
-      cipher.deletedDate = null;
-      cipher.reprompt = CipherRepromptType.None;
-
-      const identityView = new IdentityView();
-      identityView.firstName = "firstName";
-      identityView.lastName = "lastName";
-
-      const identity = Substitute.for<Identity>();
-      identity.decrypt(Arg.any(), Arg.any()).resolves(identityView);
-      cipher.identity = identity;
-
-      const cipherView = await cipher.decrypt();
-
-      expect(cipherView).toMatchObject({
-        id: "id",
-        organizationId: "orgId",
-        folderId: "folderId",
-        name: "EncryptedString",
-        notes: "EncryptedString",
-        type: 4,
-        favorite: false,
-        organizationUseTotp: true,
-        edit: true,
-        viewPassword: true,
-        identity: identityView,
-        attachments: null,
-        fields: null,
-        passwordHistory: null,
-        collectionIds: undefined,
-        revisionDate: new Date("2022-01-31T12:00:00.000Z"),
-        deletedDate: null,
-        reprompt: 0,
-        localData: undefined,
-      });
-    });
-  });
-});

jslib/common/spec/domain/collection.spec.ts

@@ -1,66 +0,0 @@
-import { CollectionData } from "jslib-common/models/data/collectionData";
-import { Collection } from "jslib-common/models/domain/collection";
-
-import { mockEnc } from "../utils";
-
-describe("Collection", () => {
-  let data: CollectionData;
-
-  beforeEach(() => {
-    data = {
-      id: "id",
-      organizationId: "orgId",
-      name: "encName",
-      externalId: "extId",
-      readOnly: true,
-    };
-  });
-
-  it("Convert from empty", () => {
-    const data = new CollectionData({} as any);
-    const card = new Collection(data);
-
-    expect(card).toEqual({
-      externalId: null,
-      hidePasswords: null,
-      id: null,
-      name: null,
-      organizationId: null,
-      readOnly: null,
-    });
-  });
-
-  it("Convert", () => {
-    const collection = new Collection(data);
-
-    expect(collection).toEqual({
-      id: "id",
-      organizationId: "orgId",
-      name: { encryptedString: "encName", encryptionType: 0 },
-      externalId: "extId",
-      readOnly: true,
-      hidePasswords: null,
-    });
-  });
-
-  it("Decrypt", async () => {
-    const collection = new Collection();
-    collection.id = "id";
-    collection.organizationId = "orgId";
-    collection.name = mockEnc("encName");
-    collection.externalId = "extId";
-    collection.readOnly = false;
-    collection.hidePasswords = false;
-
-    const view = await collection.decrypt();
-
-    expect(view).toEqual({
-      externalId: "extId",
-      hidePasswords: false,
-      id: "id",
-      name: "encName",
-      organizationId: "orgId",
-      readOnly: false,
-    });
-  });
-});

jslib/common/spec/domain/encString.spec.ts

@@ -1,10 +1,10 @@
-import Substitute, { Arg } from "@fluffy-spoon/substitute";
+import { Substitute, Arg } from "@fluffy-spoon/substitute";
 
-import { CryptoService } from "jslib-common/abstractions/crypto.service";
-import { EncryptionType } from "jslib-common/enums/encryptionType";
-import { EncString } from "jslib-common/models/domain/encString";
-import { SymmetricCryptoKey } from "jslib-common/models/domain/symmetricCryptoKey";
-import { ContainerService } from "jslib-common/services/container.service";
+import { CryptoService } from "@/jslib/common/src/abstractions/crypto.service";
+import { EncryptionType } from "@/jslib/common/src/enums/encryptionType";
+import { EncString } from "@/jslib/common/src/models/domain/encString";
+import { SymmetricCryptoKey } from "@/jslib/common/src/models/domain/symmetricCryptoKey";
+import { ContainerService } from "@/jslib/common/src/services/container.service";
 
 describe("EncString", () => {
   afterEach(() => {

jslib/common/spec/domain/field.spec.ts

@@ -1,64 +0,0 @@
-import { FieldType } from "jslib-common/enums/fieldType";
-import { FieldData } from "jslib-common/models/data/fieldData";
-import { Field } from "jslib-common/models/domain/field";
-
-import { mockEnc } from "../utils";
-
-describe("Field", () => {
-  let data: FieldData;
-
-  beforeEach(() => {
-    data = {
-      type: FieldType.Text,
-      name: "encName",
-      value: "encValue",
-      linkedId: null,
-    };
-  });
-
-  it("Convert from empty", () => {
-    const data = new FieldData();
-    const field = new Field(data);
-
-    expect(field).toEqual({
-      type: undefined,
-      name: null,
-      value: null,
-      linkedId: undefined,
-    });
-  });
-
-  it("Convert", () => {
-    const field = new Field(data);
-
-    expect(field).toEqual({
-      type: FieldType.Text,
-      name: { encryptedString: "encName", encryptionType: 0 },
-      value: { encryptedString: "encValue", encryptionType: 0 },
-      linkedId: null,
-    });
-  });
-
-  it("toFieldData", () => {
-    const field = new Field(data);
-    expect(field.toFieldData()).toEqual(data);
-  });
-
-  it("Decrypt", async () => {
-    const field = new Field();
-    field.type = FieldType.Text;
-    field.name = mockEnc("encName");
-    field.value = mockEnc("encValue");
-
-    const view = await field.decrypt(null);
-
-    expect(view).toEqual({
-      type: 0,
-      name: "encName",
-      value: "encValue",
-      newField: false,
-      showCount: false,
-      showValue: false,
-    });
-  });
-});

jslib/common/spec/domain/folder.spec.ts

@@ -1,42 +0,0 @@
-import { FolderData } from "jslib-common/models/data/folderData";
-import { Folder } from "jslib-common/models/domain/folder";
-
-import { mockEnc } from "../utils";
-
-describe("Folder", () => {
-  let data: FolderData;
-
-  beforeEach(() => {
-    data = {
-      id: "id",
-      userId: "userId",
-      name: "encName",
-      revisionDate: "2022-01-31T12:00:00.000Z",
-    };
-  });
-
-  it("Convert", () => {
-    const field = new Folder(data);
-
-    expect(field).toEqual({
-      id: "id",
-      name: { encryptedString: "encName", encryptionType: 0 },
-      revisionDate: new Date("2022-01-31T12:00:00.000Z"),
-    });
-  });
-
-  it("Decrypt", async () => {
-    const folder = new Folder();
-    folder.id = "id";
-    folder.name = mockEnc("encName");
-    folder.revisionDate = new Date("2022-01-31T12:00:00.000Z");
-
-    const view = await folder.decrypt();
-
-    expect(view).toEqual({
-      id: "id",
-      name: "encName",
-      revisionDate: new Date("2022-01-31T12:00:00.000Z"),
-    });
-  });
-});

jslib/common/spec/domain/identity.spec.ts

@@ -1,134 +0,0 @@
-import { IdentityData } from "jslib-common/models/data/identityData";
-import { Identity } from "jslib-common/models/domain/identity";
-
-import { mockEnc } from "../utils";
-
-describe("Identity", () => {
-  let data: IdentityData;
-
-  beforeEach(() => {
-    data = {
-      title: "enctitle",
-      firstName: "encfirstName",
-      middleName: "encmiddleName",
-      lastName: "enclastName",
-      address1: "encaddress1",
-      address2: "encaddress2",
-      address3: "encaddress3",
-      city: "enccity",
-      state: "encstate",
-      postalCode: "encpostalCode",
-      country: "enccountry",
-      company: "enccompany",
-      email: "encemail",
-      phone: "encphone",
-      ssn: "encssn",
-      username: "encusername",
-      passportNumber: "encpassportNumber",
-      licenseNumber: "enclicenseNumber",
-    };
-  });
-
-  it("Convert from empty", () => {
-    const data = new IdentityData();
-    const identity = new Identity(data);
-
-    expect(identity).toEqual({
-      address1: null,
-      address2: null,
-      address3: null,
-      city: null,
-      company: null,
-      country: null,
-      email: null,
-      firstName: null,
-      lastName: null,
-      licenseNumber: null,
-      middleName: null,
-      passportNumber: null,
-      phone: null,
-      postalCode: null,
-      ssn: null,
-      state: null,
-      title: null,
-      username: null,
-    });
-  });
-
-  it("Convert", () => {
-    const identity = new Identity(data);
-
-    expect(identity).toEqual({
-      title: { encryptedString: "enctitle", encryptionType: 0 },
-      firstName: { encryptedString: "encfirstName", encryptionType: 0 },
-      middleName: { encryptedString: "encmiddleName", encryptionType: 0 },
-      lastName: { encryptedString: "enclastName", encryptionType: 0 },
-      address1: { encryptedString: "encaddress1", encryptionType: 0 },
-      address2: { encryptedString: "encaddress2", encryptionType: 0 },
-      address3: { encryptedString: "encaddress3", encryptionType: 0 },
-      city: { encryptedString: "enccity", encryptionType: 0 },
-      state: { encryptedString: "encstate", encryptionType: 0 },
-      postalCode: { encryptedString: "encpostalCode", encryptionType: 0 },
-      country: { encryptedString: "enccountry", encryptionType: 0 },
-      company: { encryptedString: "enccompany", encryptionType: 0 },
-      email: { encryptedString: "encemail", encryptionType: 0 },
-      phone: { encryptedString: "encphone", encryptionType: 0 },
-      ssn: { encryptedString: "encssn", encryptionType: 0 },
-      username: { encryptedString: "encusername", encryptionType: 0 },
-      passportNumber: { encryptedString: "encpassportNumber", encryptionType: 0 },
-      licenseNumber: { encryptedString: "enclicenseNumber", encryptionType: 0 },
-    });
-  });
-
-  it("toIdentityData", () => {
-    const identity = new Identity(data);
-    expect(identity.toIdentityData()).toEqual(data);
-  });
-
-  it("Decrypt", async () => {
-    const identity = new Identity();
-
-    identity.title = mockEnc("mockTitle");
-    identity.firstName = mockEnc("mockFirstName");
-    identity.middleName = mockEnc("mockMiddleName");
-    identity.lastName = mockEnc("mockLastName");
-    identity.address1 = mockEnc("mockAddress1");
-    identity.address2 = mockEnc("mockAddress2");
-    identity.address3 = mockEnc("mockAddress3");
-    identity.city = mockEnc("mockCity");
-    identity.state = mockEnc("mockState");
-    identity.postalCode = mockEnc("mockPostalCode");
-    identity.country = mockEnc("mockCountry");
-    identity.company = mockEnc("mockCompany");
-    identity.email = mockEnc("mockEmail");
-    identity.phone = mockEnc("mockPhone");
-    identity.ssn = mockEnc("mockSsn");
-    identity.username = mockEnc("mockUsername");
-    identity.passportNumber = mockEnc("mockPassportNumber");
-    identity.licenseNumber = mockEnc("mockLicenseNumber");
-
-    const view = await identity.decrypt(null);
-
-    expect(view).toEqual({
-      _firstName: "mockFirstName",
-      _lastName: "mockLastName",
-      _subTitle: null,
-      address1: "mockAddress1",
-      address2: "mockAddress2",
-      address3: "mockAddress3",
-      city: "mockCity",
-      company: "mockCompany",
-      country: "mockCountry",
-      email: "mockEmail",
-      licenseNumber: "mockLicenseNumber",
-      middleName: "mockMiddleName",
-      passportNumber: "mockPassportNumber",
-      phone: "mockPhone",
-      postalCode: "mockPostalCode",
-      ssn: "mockSsn",
-      state: "mockState",
-      title: "mockTitle",
-      username: "mockUsername",
-    });
-  });
-});

jslib/common/spec/domain/login.spec.ts

@@ -1,101 +0,0 @@
-import Substitute, { Arg } from "@fluffy-spoon/substitute";
-
-import { UriMatchType } from "jslib-common/enums/uriMatchType";
-import { LoginData } from "jslib-common/models/data/loginData";
-import { Login } from "jslib-common/models/domain/login";
-import { LoginUri } from "jslib-common/models/domain/loginUri";
-import { LoginUriView } from "jslib-common/models/view/loginUriView";
-
-import { mockEnc } from "../utils";
-
-describe("Login DTO", () => {
-  it("Convert from empty LoginData", () => {
-    const data = new LoginData();
-    const login = new Login(data);
-
-    expect(login).toEqual({
-      passwordRevisionDate: null,
-      autofillOnPageLoad: undefined,
-      username: null,
-      password: null,
-      totp: null,
-    });
-  });
-
-  it("Convert from full LoginData", () => {
-    const data: LoginData = {
-      uris: [{ uri: "uri", match: UriMatchType.Domain }],
-      username: "username",
-      password: "password",
-      passwordRevisionDate: "2022-01-31T12:00:00.000Z",
-      totp: "123",
-      autofillOnPageLoad: false,
-    };
-    const login = new Login(data);
-
-    expect(login).toEqual({
-      passwordRevisionDate: new Date("2022-01-31T12:00:00.000Z"),
-      autofillOnPageLoad: false,
-      username: { encryptedString: "username", encryptionType: 0 },
-      password: { encryptedString: "password", encryptionType: 0 },
-      totp: { encryptedString: "123", encryptionType: 0 },
-      uris: [{ match: 0, uri: { encryptedString: "uri", encryptionType: 0 } }],
-    });
-  });
-
-  it("Initialize without LoginData", () => {
-    const login = new Login();
-
-    expect(login).toEqual({});
-  });
-
-  it("Decrypts correctly", async () => {
-    const loginUri = Substitute.for<LoginUri>();
-    const loginUriView = new LoginUriView();
-    loginUriView.uri = "decrypted uri";
-    loginUri.decrypt(Arg.any()).resolves(loginUriView);
-
-    const login = new Login();
-    login.uris = [loginUri];
-    login.username = mockEnc("encrypted username");
-    login.password = mockEnc("encrypted password");
-    login.passwordRevisionDate = new Date("2022-01-31T12:00:00.000Z");
-    login.totp = mockEnc("encrypted totp");
-    login.autofillOnPageLoad = true;
-
-    const loginView = await login.decrypt(null);
-    expect(loginView).toEqual({
-      username: "encrypted username",
-      password: "encrypted password",
-      passwordRevisionDate: new Date("2022-01-31T12:00:00.000Z"),
-      totp: "encrypted totp",
-      uris: [
-        {
-          match: null,
-          _uri: "decrypted uri",
-          _domain: null,
-          _hostname: null,
-          _host: null,
-          _canLaunch: null,
-        },
-      ],
-      autofillOnPageLoad: true,
-    });
-  });
-
-  it("Converts from LoginData and back", () => {
-    const data: LoginData = {
-      uris: [{ uri: "uri", match: UriMatchType.Domain }],
-      username: "username",
-      password: "password",
-      passwordRevisionDate: "2022-01-31T12:00:00.000Z",
-      totp: "123",
-      autofillOnPageLoad: false,
-    };
-    const login = new Login(data);
-
-    const loginData = login.toLoginData();
-
-    expect(loginData).toEqual(data);
-  });
-});

jslib/common/spec/domain/loginUri.spec.ts

@@ -1,57 +0,0 @@
-import { UriMatchType } from "jslib-common/enums/uriMatchType";
-import { LoginUriData } from "jslib-common/models/data/loginUriData";
-import { LoginUri } from "jslib-common/models/domain/loginUri";
-
-import { mockEnc } from "../utils";
-
-describe("LoginUri", () => {
-  let data: LoginUriData;
-
-  beforeEach(() => {
-    data = {
-      uri: "encUri",
-      match: UriMatchType.Domain,
-    };
-  });
-
-  it("Convert from empty", () => {
-    const data = new LoginUriData();
-    const loginUri = new LoginUri(data);
-
-    expect(loginUri).toEqual({
-      match: null,
-      uri: null,
-    });
-  });
-
-  it("Convert", () => {
-    const loginUri = new LoginUri(data);
-
-    expect(loginUri).toEqual({
-      match: 0,
-      uri: { encryptedString: "encUri", encryptionType: 0 },
-    });
-  });
-
-  it("toLoginUriData", () => {
-    const loginUri = new LoginUri(data);
-    expect(loginUri.toLoginUriData()).toEqual(data);
-  });
-
-  it("Decrypt", async () => {
-    const loginUri = new LoginUri();
-    loginUri.match = UriMatchType.Exact;
-    loginUri.uri = mockEnc("uri");
-
-    const view = await loginUri.decrypt(null);
-
-    expect(view).toEqual({
-      _canLaunch: null,
-      _domain: null,
-      _host: null,
-      _hostname: null,
-      _uri: "uri",
-      match: 3,
-    });
-  });
-});

jslib/common/spec/domain/password.spec.ts

@@ -1,51 +0,0 @@
-import { PasswordHistoryData } from "jslib-common/models/data/passwordHistoryData";
-import { Password } from "jslib-common/models/domain/password";
-
-import { mockEnc } from "../utils";
-
-describe("Password", () => {
-  let data: PasswordHistoryData;
-
-  beforeEach(() => {
-    data = {
-      password: "encPassword",
-      lastUsedDate: "2022-01-31T12:00:00.000Z",
-    };
-  });
-
-  it("Convert from empty", () => {
-    const data = new PasswordHistoryData();
-    const password = new Password(data);
-
-    expect(password).toMatchObject({
-      password: null,
-    });
-  });
-
-  it("Convert", () => {
-    const password = new Password(data);
-
-    expect(password).toEqual({
-      password: { encryptedString: "encPassword", encryptionType: 0 },
-      lastUsedDate: new Date("2022-01-31T12:00:00.000Z"),
-    });
-  });
-
-  it("toPasswordHistoryData", () => {
-    const password = new Password(data);
-    expect(password.toPasswordHistoryData()).toEqual(data);
-  });
-
-  it("Decrypt", async () => {
-    const password = new Password();
-    password.password = mockEnc("password");
-    password.lastUsedDate = new Date("2022-01-31T12:00:00.000Z");
-
-    const view = await password.decrypt(null);
-
-    expect(view).toEqual({
-      password: "password",
-      lastUsedDate: new Date("2022-01-31T12:00:00.000Z"),
-    });
-  });
-});

jslib/common/spec/domain/secureNote.spec.ts

@@ -1,46 +0,0 @@
-import { SecureNoteType } from "jslib-common/enums/secureNoteType";
-import { SecureNoteData } from "jslib-common/models/data/secureNoteData";
-import { SecureNote } from "jslib-common/models/domain/secureNote";
-
-describe("SecureNote", () => {
-  let data: SecureNoteData;
-
-  beforeEach(() => {
-    data = {
-      type: SecureNoteType.Generic,
-    };
-  });
-
-  it("Convert from empty", () => {
-    const data = new SecureNoteData();
-    const secureNote = new SecureNote(data);
-
-    expect(secureNote).toEqual({
-      type: undefined,
-    });
-  });
-
-  it("Convert", () => {
-    const secureNote = new SecureNote(data);
-
-    expect(secureNote).toEqual({
-      type: 0,
-    });
-  });
-
-  it("toSecureNoteData", () => {
-    const secureNote = new SecureNote(data);
-    expect(secureNote.toSecureNoteData()).toEqual(data);
-  });
-
-  it("Decrypt", async () => {
-    const secureNote = new SecureNote();
-    secureNote.type = SecureNoteType.Generic;
-
-    const view = await secureNote.decrypt(null);
-
-    expect(view).toEqual({
-      type: 0,
-    });
-  });
-});

jslib/common/spec/domain/send.spec.ts

@@ -1,144 +0,0 @@
-import Substitute, { Arg, SubstituteOf } from "@fluffy-spoon/substitute";
-
-import { CryptoService } from "jslib-common/abstractions/crypto.service";
-import { SendType } from "jslib-common/enums/sendType";
-import { SendData } from "jslib-common/models/data/sendData";
-import { EncString } from "jslib-common/models/domain/encString";
-import { Send } from "jslib-common/models/domain/send";
-import { SendText } from "jslib-common/models/domain/sendText";
-import { ContainerService } from "jslib-common/services/container.service";
-
-import { makeStaticByteArray, mockEnc } from "../utils";
-
-describe("Send", () => {
-  let data: SendData;
-
-  beforeEach(() => {
-    data = {
-      id: "id",
-      accessId: "accessId",
-      userId: "userId",
-      type: SendType.Text,
-      name: "encName",
-      notes: "encNotes",
-      text: {
-        text: "encText",
-        hidden: true,
-      },
-      file: null,
-      key: "encKey",
-      maxAccessCount: null,
-      accessCount: 10,
-      revisionDate: "2022-01-31T12:00:00.000Z",
-      expirationDate: "2022-01-31T12:00:00.000Z",
-      deletionDate: "2022-01-31T12:00:00.000Z",
-      password: "password",
-      disabled: false,
-      hideEmail: true,
-    };
-  });
-
-  it("Convert from empty", () => {
-    const data = new SendData();
-    const send = new Send(data);
-
-    expect(send).toEqual({
-      id: null,
-      accessId: null,
-      userId: null,
-      type: undefined,
-      name: null,
-      notes: null,
-      text: undefined,
-      file: undefined,
-      key: null,
-      maxAccessCount: undefined,
-      accessCount: undefined,
-      revisionDate: null,
-      expirationDate: null,
-      deletionDate: null,
-      password: undefined,
-      disabled: undefined,
-      hideEmail: undefined,
-    });
-  });
-
-  it("Convert", () => {
-    const send = new Send(data);
-
-    expect(send).toEqual({
-      id: "id",
-      accessId: "accessId",
-      userId: "userId",
-      type: SendType.Text,
-      name: { encryptedString: "encName", encryptionType: 0 },
-      notes: { encryptedString: "encNotes", encryptionType: 0 },
-      text: {
-        text: { encryptedString: "encText", encryptionType: 0 },
-        hidden: true,
-      },
-      key: { encryptedString: "encKey", encryptionType: 0 },
-      maxAccessCount: null,
-      accessCount: 10,
-      revisionDate: new Date("2022-01-31T12:00:00.000Z"),
-      expirationDate: new Date("2022-01-31T12:00:00.000Z"),
-      deletionDate: new Date("2022-01-31T12:00:00.000Z"),
-      password: "password",
-      disabled: false,
-      hideEmail: true,
-    });
-  });
-
-  it("Decrypt", async () => {
-    const text = Substitute.for<SendText>();
-    text.decrypt(Arg.any()).resolves("textView" as any);
-
-    const send = new Send();
-    send.id = "id";
-    send.accessId = "accessId";
-    send.userId = "userId";
-    send.type = SendType.Text;
-    send.name = mockEnc("name");
-    send.notes = mockEnc("notes");
-    send.text = text;
-    send.key = mockEnc("key");
-    send.accessCount = 10;
-    send.revisionDate = new Date("2022-01-31T12:00:00.000Z");
-    send.expirationDate = new Date("2022-01-31T12:00:00.000Z");
-    send.deletionDate = new Date("2022-01-31T12:00:00.000Z");
-    send.password = "password";
-    send.disabled = false;
-    send.hideEmail = true;
-
-    const cryptoService = Substitute.for<CryptoService>();
-    cryptoService.decryptToBytes(send.key, null).resolves(makeStaticByteArray(32));
-    cryptoService.makeSendKey(Arg.any()).resolves("cryptoKey" as any);
-
-    (window as any).bitwardenContainerService = new ContainerService(cryptoService);
-
-    const view = await send.decrypt();
-
-    text.received(1).decrypt("cryptoKey" as any);
-    (send.name as SubstituteOf<EncString>).received(1).decrypt(null, "cryptoKey" as any);
-
-    expect(view).toMatchObject({
-      id: "id",
-      accessId: "accessId",
-      name: "name",
-      notes: "notes",
-      type: 0,
-      key: expect.anything(),
-      cryptoKey: "cryptoKey",
-      file: expect.anything(),
-      text: "textView",
-      maxAccessCount: undefined,
-      accessCount: 10,
-      revisionDate: new Date("2022-01-31T12:00:00.000Z"),
-      expirationDate: new Date("2022-01-31T12:00:00.000Z"),
-      deletionDate: new Date("2022-01-31T12:00:00.000Z"),
-      password: "password",
-      disabled: false,
-      hideEmail: true,
-    });
-  });
-});

jslib/common/spec/domain/sendAccess.spec.ts

@@ -1,84 +0,0 @@
-import Substitute, { Arg } from "@fluffy-spoon/substitute";
-
-import { SendType } from "jslib-common/enums/sendType";
-import { SendAccess } from "jslib-common/models/domain/sendAccess";
-import { SendText } from "jslib-common/models/domain/sendText";
-import { SendAccessResponse } from "jslib-common/models/response/sendAccessResponse";
-
-import { mockEnc } from "../utils";
-
-describe("SendAccess", () => {
-  let request: SendAccessResponse;
-
-  beforeEach(() => {
-    request = {
-      id: "id",
-      type: SendType.Text,
-      name: "encName",
-      file: null,
-      text: {
-        text: "encText",
-        hidden: true,
-      },
-      expirationDate: new Date("2022-01-31T12:00:00.000Z"),
-      creatorIdentifier: "creatorIdentifier",
-    } as SendAccessResponse;
-  });
-
-  it("Convert from empty", () => {
-    const request = new SendAccessResponse({});
-    const sendAccess = new SendAccess(request);
-
-    expect(sendAccess).toEqual({
-      id: null,
-      type: undefined,
-      name: null,
-      creatorIdentifier: null,
-      expirationDate: null,
-    });
-  });
-
-  it("Convert", () => {
-    const sendAccess = new SendAccess(request);
-
-    expect(sendAccess).toEqual({
-      id: "id",
-      type: 0,
-      name: { encryptedString: "encName", encryptionType: 0 },
-      text: {
-        hidden: true,
-        text: { encryptedString: "encText", encryptionType: 0 },
-      },
-      expirationDate: new Date("2022-01-31T12:00:00.000Z"),
-      creatorIdentifier: "creatorIdentifier",
-    });
-  });
-
-  it("Decrypt", async () => {
-    const sendAccess = new SendAccess();
-    sendAccess.id = "id";
-    sendAccess.type = SendType.Text;
-    sendAccess.name = mockEnc("name");
-
-    const text = Substitute.for<SendText>();
-    text.decrypt(Arg.any()).resolves({} as any);
-    sendAccess.text = text;
-
-    sendAccess.expirationDate = new Date("2022-01-31T12:00:00.000Z");
-    sendAccess.creatorIdentifier = "creatorIdentifier";
-
-    const view = await sendAccess.decrypt(null);
-
-    text.received(1).decrypt(Arg.any());
-
-    expect(view).toEqual({
-      id: "id",
-      type: 0,
-      name: "name",
-      text: {},
-      file: expect.anything(),
-      expirationDate: new Date("2022-01-31T12:00:00.000Z"),
-      creatorIdentifier: "creatorIdentifier",
-    });
-  });
-});

jslib/common/spec/domain/sendFile.spec.ts

@@ -1,57 +0,0 @@
-import { SendFileData } from "jslib-common/models/data/sendFileData";
-import { SendFile } from "jslib-common/models/domain/sendFile";
-
-import { mockEnc } from "../utils";
-
-describe("SendFile", () => {
-  let data: SendFileData;
-
-  beforeEach(() => {
-    data = {
-      id: "id",
-      size: "1100",
-      sizeName: "1.1 KB",
-      fileName: "encFileName",
-    };
-  });
-
-  it("Convert from empty", () => {
-    const data = new SendFileData();
-    const sendFile = new SendFile(data);
-
-    expect(sendFile).toEqual({
-      fileName: null,
-      id: null,
-      size: undefined,
-      sizeName: null,
-    });
-  });
-
-  it("Convert", () => {
-    const sendFile = new SendFile(data);
-
-    expect(sendFile).toEqual({
-      id: "id",
-      size: "1100",
-      sizeName: "1.1 KB",
-      fileName: { encryptedString: "encFileName", encryptionType: 0 },
-    });
-  });
-
-  it("Decrypt", async () => {
-    const sendFile = new SendFile();
-    sendFile.id = "id";
-    sendFile.size = "1100";
-    sendFile.sizeName = "1.1 KB";
-    sendFile.fileName = mockEnc("fileName");
-
-    const view = await sendFile.decrypt(null);
-
-    expect(view).toEqual({
-      fileName: "fileName",
-      id: "id",
-      size: "1100",
-      sizeName: "1.1 KB",
-    });
-  });
-});

jslib/common/spec/domain/sendText.spec.ts

@@ -1,47 +0,0 @@
-import { SendTextData } from "jslib-common/models/data/sendTextData";
-import { SendText } from "jslib-common/models/domain/sendText";
-
-import { mockEnc } from "../utils";
-
-describe("SendText", () => {
-  let data: SendTextData;
-
-  beforeEach(() => {
-    data = {
-      text: "encText",
-      hidden: false,
-    };
-  });
-
-  it("Convert from empty", () => {
-    const data = new SendTextData();
-    const secureNote = new SendText(data);
-
-    expect(secureNote).toEqual({
-      hidden: undefined,
-      text: null,
-    });
-  });
-
-  it("Convert", () => {
-    const secureNote = new SendText(data);
-
-    expect(secureNote).toEqual({
-      hidden: false,
-      text: { encryptedString: "encText", encryptionType: 0 },
-    });
-  });
-
-  it("Decrypt", async () => {
-    const secureNote = new SendText();
-    secureNote.text = mockEnc("text");
-    secureNote.hidden = true;
-
-    const view = await secureNote.decrypt(null);
-
-    expect(view).toEqual({
-      text: "text",
-      hidden: true,
-    });
-  });
-});

jslib/common/spec/domain/symmetricCryptoKey.spec.ts

@@ -1,5 +1,5 @@
-import { EncryptionType } from "jslib-common/enums/encryptionType";
-import { SymmetricCryptoKey } from "jslib-common/models/domain/symmetricCryptoKey";
+import { EncryptionType } from "@/jslib/common/src/enums/encryptionType";
+import { SymmetricCryptoKey } from "@/jslib/common/src/models/domain/symmetricCryptoKey";
 
 import { makeStaticByteArray } from "../utils";
 

jslib/common/spec/importers/bitwardenJsonImporter.spec.ts

@@ -1,31 +0,0 @@
-import { Substitute, SubstituteOf } from "@fluffy-spoon/substitute";
-
-import { CryptoService } from "jslib-common/abstractions/crypto.service";
-import { I18nService } from "jslib-common/abstractions/i18n.service";
-import { BitwardenJsonImporter } from "jslib-common/importers/bitwardenJsonImporter";
-
-import { data as passwordProtectedData } from "./testData/bitwardenJson/passwordProtected.json";
-
-describe("bitwarden json importer", () => {
-  let sut: BitwardenJsonImporter;
-  let cryptoService: SubstituteOf<CryptoService>;
-  let i18nService: SubstituteOf<I18nService>;
-
-  beforeEach(() => {
-    cryptoService = Substitute.for<CryptoService>();
-    i18nService = Substitute.for<I18nService>();
-
-    sut = new BitwardenJsonImporter(cryptoService, i18nService);
-  });
-
-  it("should fail if password is needed", async () => {
-    expect((await sut.parse(passwordProtectedData)).success).toBe(false);
-  });
-
-  it("should return password needed error message", async () => {
-    const expected = "Password required error message";
-    i18nService.t("importPasswordRequired").returns(expected);
-
-    expect((await sut.parse(passwordProtectedData)).errorMessage).toEqual(expected);
-  });
-});

jslib/common/spec/importers/bitwardenPasswordProtectedImporter.spec.ts

@@ -1,113 +0,0 @@
-import Substitute, { Arg, SubstituteOf } from "@fluffy-spoon/substitute";
-
-import { CryptoService } from "jslib-common/abstractions/crypto.service";
-import { I18nService } from "jslib-common/abstractions/i18n.service";
-import { KdfType } from "jslib-common/enums/kdfType";
-import { BitwardenPasswordProtectedImporter } from "jslib-common/importers/bitwardenPasswordProtectedImporter";
-import { Utils } from "jslib-common/misc/utils";
-import { ImportResult } from "jslib-common/models/domain/importResult";
-
-import { data as emptyDecryptedData } from "./testData/bitwardenJson/empty.json";
-
-describe("BitwardenPasswordProtectedImporter", () => {
-  let importer: BitwardenPasswordProtectedImporter;
-  let cryptoService: SubstituteOf<CryptoService>;
-  let i18nService: SubstituteOf<I18nService>;
-  const password = Utils.newGuid();
-  const result = new ImportResult();
-  let jDoc: {
-    encrypted?: boolean;
-    passwordProtected?: boolean;
-    salt?: string;
-    kdfIterations?: any;
-    kdfType?: any;
-    encKeyValidation_DO_NOT_EDIT?: string;
-    data?: string;
-  };
-
-  beforeEach(() => {
-    cryptoService = Substitute.for<CryptoService>();
-    i18nService = Substitute.for<I18nService>();
-
-    jDoc = {
-      encrypted: true,
-      passwordProtected: true,
-      salt: "c2FsdA==",
-      kdfIterations: 100000,
-      kdfType: KdfType.PBKDF2_SHA256,
-      encKeyValidation_DO_NOT_EDIT: Utils.newGuid(),
-      data: Utils.newGuid(),
-    };
-
-    result.success = true;
-    importer = new BitwardenPasswordProtectedImporter(cryptoService, i18nService, password);
-  });
-
-  describe("Required Json Data", () => {
-    it("succeeds with default jdoc", async () => {
-      cryptoService.decryptToUtf8(Arg.any(), Arg.any()).resolves(emptyDecryptedData);
-
-      expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(true);
-    });
-
-    it("fails if encrypted === false", async () => {
-      jDoc.encrypted = false;
-      expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
-    });
-
-    it("fails if encrypted === null", async () => {
-      jDoc.encrypted = null;
-      expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
-    });
-
-    it("fails if passwordProtected === false", async () => {
-      jDoc.passwordProtected = false;
-      expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
-    });
-
-    it("fails if passwordProtected === null", async () => {
-      jDoc.passwordProtected = null;
-      expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
-    });
-
-    it("fails if salt === null", async () => {
-      jDoc.salt = null;
-      expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
-    });
-
-    it("fails if kdfIterations === null", async () => {
-      jDoc.kdfIterations = null;
-      expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
-    });
-
-    it("fails if kdfIterations is not a number", async () => {
-      jDoc.kdfIterations = "not a number";
-      expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
-    });
-
-    it("fails if kdfType === null", async () => {
-      jDoc.kdfType = null;
-      expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
-    });
-
-    it("fails if kdfType is not a string", async () => {
-      jDoc.kdfType = "not a valid kdf type";
-      expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
-    });
-
-    it("fails if kdfType is not a known kdfType", async () => {
-      jDoc.kdfType = -1;
-      expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
-    });
-
-    it("fails if encKeyValidation_DO_NOT_EDIT === null", async () => {
-      jDoc.encKeyValidation_DO_NOT_EDIT = null;
-      expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
-    });
-
-    it("fails if data === null", async () => {
-      jDoc.data = null;
-      expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
-    });
-  });
-});

jslib/common/spec/importers/dashlaneCsvImporter.spec.ts

@@ -1,367 +0,0 @@
-import { CipherType } from "jslib-common/enums/cipherType";
-import { DashlaneCsvImporter as Importer } from "jslib-common/importers/dashlaneImporters/dashlaneCsvImporter";
-
-import { credentialsData } from "./testData/dashlaneCsv/credentials.csv";
-import { identityData } from "./testData/dashlaneCsv/id.csv";
-import { multiplePersonalInfoData } from "./testData/dashlaneCsv/multiplePersonalInfo.csv";
-import { paymentsData } from "./testData/dashlaneCsv/payments.csv";
-import { personalInfoData } from "./testData/dashlaneCsv/personalInfo.csv";
-import { secureNoteData } from "./testData/dashlaneCsv/securenotes.csv";
-
-describe("Dashlane CSV Importer", () => {
-  let importer: Importer;
-  beforeEach(() => {
-    importer = new Importer();
-  });
-
-  it("should parse login records", async () => {
-    const result = await importer.parse(credentialsData);
-    expect(result != null).toBe(true);
-
-    const cipher = result.ciphers.shift();
-    expect(cipher.name).toEqual("example.com");
-    expect(cipher.login.username).toEqual("jdoe");
-    expect(cipher.login.password).toEqual("somePassword");
-    expect(cipher.login.totp).toEqual("someTOTPSeed");
-    expect(cipher.login.uris.length).toEqual(1);
-    const uriView = cipher.login.uris.shift();
-    expect(uriView.uri).toEqual("https://www.example.com");
-    expect(cipher.notes).toEqual("some note for example.com");
-  });
-
-  it("should parse an item and create a folder", async () => {
-    const result = await importer.parse(credentialsData);
-
-    expect(result).not.toBeNull();
-    expect(result.success).toBe(true);
-    expect(result.folders.length).toBe(1);
-    expect(result.folders[0].name).toBe("Entertainment");
-    expect(result.folderRelationships[0]).toEqual([0, 0]);
-  });
-
-  it("should parse payment records", async () => {
-    const result = await importer.parse(paymentsData);
-
-    expect(result).not.toBeNull();
-    expect(result.success).toBe(true);
-    expect(result.ciphers.length).toBe(2);
-
-    // Account
-    const cipher = result.ciphers.shift();
-    expect(cipher.type).toBe(CipherType.Card);
-    expect(cipher.name).toBe("John's savings account");
-    expect(cipher.card.brand).toBeNull();
-    expect(cipher.card.cardholderName).toBe("John Doe");
-    expect(cipher.card.number).toBe("accountNumber");
-    expect(cipher.card.code).toBeNull();
-    expect(cipher.card.expMonth).toBeNull();
-    expect(cipher.card.expYear).toBeNull();
-
-    expect(cipher.fields.length).toBe(4);
-
-    expect(cipher.fields[0].name).toBe("type");
-    expect(cipher.fields[0].value).toBe("bank");
-
-    expect(cipher.fields[1].name).toBe("routing_number");
-    expect(cipher.fields[1].value).toBe("routingNumber");
-
-    expect(cipher.fields[2].name).toBe("country");
-    expect(cipher.fields[2].value).toBe("US");
-
-    expect(cipher.fields[3].name).toBe("issuing_bank");
-    expect(cipher.fields[3].value).toBe("US-ALLY");
-
-    // CreditCard
-    const cipher2 = result.ciphers.shift();
-    expect(cipher2.type).toBe(CipherType.Card);
-    expect(cipher2.name).toBe("John Doe");
-    expect(cipher2.card.brand).toBe("Visa");
-    expect(cipher2.card.cardholderName).toBe("John Doe");
-    expect(cipher2.card.number).toBe("41111111111111111");
-    expect(cipher2.card.code).toBe("123");
-    expect(cipher2.card.expMonth).toBe("01");
-    expect(cipher2.card.expYear).toBe("23");
-
-    expect(cipher2.fields.length).toBe(2);
-
-    expect(cipher2.fields[0].name).toBe("type");
-    expect(cipher2.fields[0].value).toBe("credit_card");
-
-    expect(cipher2.fields[1].name).toBe("country");
-    expect(cipher2.fields[1].value).toBe("US");
-  });
-
-  it("should parse ids records", async () => {
-    const result = await importer.parse(identityData);
-
-    expect(result).not.toBeNull();
-    expect(result.success).toBe(true);
-
-    // Type card
-    const cipher = result.ciphers.shift();
-    expect(cipher.type).toBe(CipherType.Identity);
-    expect(cipher.name).toBe("John Doe card");
-    expect(cipher.identity.fullName).toBe("John Doe");
-    expect(cipher.identity.firstName).toBe("John");
-    expect(cipher.identity.middleName).toBeNull();
-    expect(cipher.identity.lastName).toBe("Doe");
-    expect(cipher.identity.licenseNumber).toBe("123123123");
-
-    expect(cipher.fields.length).toBe(3);
-
-    expect(cipher.fields[0].name).toEqual("type");
-    expect(cipher.fields[0].value).toEqual("card");
-
-    expect(cipher.fields[1].name).toEqual("issue_date");
-    expect(cipher.fields[1].value).toEqual("2022-1-30");
-
-    expect(cipher.fields[2].name).toEqual("expiration_date");
-    expect(cipher.fields[2].value).toEqual("2032-1-30");
-
-    // Type passport
-    const cipher2 = result.ciphers.shift();
-    expect(cipher2.type).toBe(CipherType.Identity);
-    expect(cipher2.name).toBe("John Doe passport");
-    expect(cipher2.identity.fullName).toBe("John Doe");
-    expect(cipher2.identity.firstName).toBe("John");
-    expect(cipher2.identity.middleName).toBeNull();
-    expect(cipher2.identity.lastName).toBe("Doe");
-    expect(cipher2.identity.passportNumber).toBe("123123123");
-
-    expect(cipher2.fields.length).toBe(4);
-
-    expect(cipher2.fields[0].name).toEqual("type");
-    expect(cipher2.fields[0].value).toEqual("passport");
-    expect(cipher2.fields[1].name).toEqual("issue_date");
-    expect(cipher2.fields[1].value).toEqual("2022-1-30");
-    expect(cipher2.fields[2].name).toEqual("expiration_date");
-    expect(cipher2.fields[2].value).toEqual("2032-1-30");
-    expect(cipher2.fields[3].name).toEqual("place_of_issue");
-    expect(cipher2.fields[3].value).toEqual("somewhere in Germany");
-
-    // Type license
-    const cipher3 = result.ciphers.shift();
-    expect(cipher3.type).toBe(CipherType.Identity);
-    expect(cipher3.name).toBe("John Doe license");
-    expect(cipher3.identity.fullName).toBe("John Doe");
-    expect(cipher3.identity.firstName).toBe("John");
-    expect(cipher3.identity.middleName).toBeNull();
-    expect(cipher3.identity.lastName).toBe("Doe");
-    expect(cipher3.identity.licenseNumber).toBe("1234556");
-    expect(cipher3.identity.state).toBe("DC");
-
-    expect(cipher3.fields.length).toBe(3);
-    expect(cipher3.fields[0].name).toEqual("type");
-    expect(cipher3.fields[0].value).toEqual("license");
-    expect(cipher3.fields[1].name).toEqual("issue_date");
-    expect(cipher3.fields[1].value).toEqual("2022-8-10");
-    expect(cipher3.fields[2].name).toEqual("expiration_date");
-    expect(cipher3.fields[2].value).toEqual("2022-10-10");
-
-    // Type social_security
-    const cipher4 = result.ciphers.shift();
-    expect(cipher4.type).toBe(CipherType.Identity);
-    expect(cipher4.name).toBe("John Doe social_security");
-    expect(cipher4.identity.fullName).toBe("John Doe");
-    expect(cipher4.identity.firstName).toBe("John");
-    expect(cipher4.identity.middleName).toBeNull();
-    expect(cipher4.identity.lastName).toBe("Doe");
-    expect(cipher4.identity.ssn).toBe("123123123");
-
-    expect(cipher4.fields.length).toBe(1);
-    expect(cipher4.fields[0].name).toEqual("type");
-    expect(cipher4.fields[0].value).toEqual("social_security");
-
-    // Type tax_number
-    const cipher5 = result.ciphers.shift();
-    expect(cipher5.type).toBe(CipherType.Identity);
-    expect(cipher5.name).toBe("tax_number");
-    expect(cipher5.identity.licenseNumber).toBe("123123123");
-
-    expect(cipher5.fields.length).toBe(1);
-    expect(cipher5.fields[0].name).toEqual("type");
-    expect(cipher5.fields[0].value).toEqual("tax_number");
-  });
-
-  it("should parse secureNote records", async () => {
-    const result = await importer.parse(secureNoteData);
-
-    expect(result).not.toBeNull();
-    expect(result.success).toBe(true);
-    expect(result.ciphers.length).toBe(1);
-
-    const cipher = result.ciphers.shift();
-    expect(cipher.type).toBe(CipherType.SecureNote);
-    expect(cipher.name).toBe("01");
-    expect(cipher.notes).toBe("test");
-  });
-
-  it("should parse personal information records (multiple identities)", async () => {
-    const result = await importer.parse(multiplePersonalInfoData);
-
-    expect(result).not.toBeNull();
-    expect(result.success).toBe(true);
-    expect(result.ciphers.length).toBe(6);
-
-    // name
-    const cipher = result.ciphers.shift();
-    expect(cipher.type).toBe(CipherType.SecureNote);
-    expect(cipher.name).toBe("MR John Doe");
-
-    expect(cipher.fields.length).toBe(7);
-    expect(cipher.fields[0].name).toEqual("type");
-    expect(cipher.fields[0].value).toEqual("name");
-    expect(cipher.fields[1].name).toEqual("title");
-    expect(cipher.fields[1].value).toEqual("MR");
-    expect(cipher.fields[2].name).toEqual("first_name");
-    expect(cipher.fields[2].value).toEqual("John");
-    expect(cipher.fields[3].name).toEqual("last_name");
-    expect(cipher.fields[3].value).toEqual("Doe");
-    expect(cipher.fields[4].name).toEqual("login");
-    expect(cipher.fields[4].value).toEqual("jdoe");
-    expect(cipher.fields[5].name).toEqual("date_of_birth");
-    expect(cipher.fields[5].value).toEqual("2022-01-30");
-    expect(cipher.fields[6].name).toEqual("place_of_birth");
-    expect(cipher.fields[6].value).toEqual("world");
-
-    // email
-    const cipher2 = result.ciphers.shift();
-    expect(cipher2.type).toBe(CipherType.SecureNote);
-    expect(cipher2.name).toBe("Johns email");
-
-    expect(cipher2.fields.length).toBe(4);
-    expect(cipher2.fields[0].name).toEqual("type");
-    expect(cipher2.fields[0].value).toEqual("email");
-    expect(cipher2.fields[1].name).toEqual("email");
-    expect(cipher2.fields[1].value).toEqual("jdoe@example.com");
-    expect(cipher2.fields[2].name).toEqual("email_type");
-    expect(cipher2.fields[2].value).toEqual("personal");
-    expect(cipher2.fields[3].name).toEqual("item_name");
-    expect(cipher2.fields[3].value).toEqual("Johns email");
-
-    // number
-    const cipher3 = result.ciphers.shift();
-    expect(cipher3.type).toBe(CipherType.SecureNote);
-    expect(cipher3.name).toBe("John's number");
-
-    expect(cipher3.fields.length).toBe(3);
-    expect(cipher3.fields[0].name).toEqual("type");
-    expect(cipher3.fields[0].value).toEqual("number");
-    expect(cipher3.fields[1].name).toEqual("item_name");
-    expect(cipher3.fields[1].value).toEqual("John's number");
-    expect(cipher3.fields[2].name).toEqual("phone_number");
-    expect(cipher3.fields[2].value).toEqual("+49123123123");
-
-    // address
-    const cipher4 = result.ciphers.shift();
-    expect(cipher4.type).toBe(CipherType.SecureNote);
-    expect(cipher4.name).toBe("John's home address");
-
-    expect(cipher4.fields.length).toBe(12);
-    expect(cipher4.fields[0].name).toEqual("type");
-    expect(cipher4.fields[0].value).toEqual("address");
-    expect(cipher4.fields[1].name).toEqual("item_name");
-    expect(cipher4.fields[1].value).toEqual("John's home address");
-    expect(cipher4.fields[2].name).toEqual("address");
-    expect(cipher4.fields[2].value).toEqual("1 some street");
-    expect(cipher4.fields[3].name).toEqual("country");
-    expect(cipher4.fields[3].value).toEqual("de");
-    expect(cipher4.fields[4].name).toEqual("state");
-    expect(cipher4.fields[4].value).toEqual("DE-0-NW");
-    expect(cipher4.fields[5].name).toEqual("city");
-    expect(cipher4.fields[5].value).toEqual("some city");
-    expect(cipher4.fields[6].name).toEqual("zip");
-    expect(cipher4.fields[6].value).toEqual("123123");
-    expect(cipher4.fields[7].name).toEqual("address_recipient");
-    expect(cipher4.fields[7].value).toEqual("John");
-    expect(cipher4.fields[8].name).toEqual("address_building");
-    expect(cipher4.fields[8].value).toEqual("1");
-    expect(cipher4.fields[9].name).toEqual("address_apartment");
-    expect(cipher4.fields[9].value).toEqual("1");
-    expect(cipher4.fields[10].name).toEqual("address_floor");
-    expect(cipher4.fields[10].value).toEqual("1");
-    expect(cipher4.fields[11].name).toEqual("address_door_code");
-    expect(cipher4.fields[11].value).toEqual("123");
-
-    // website
-    const cipher5 = result.ciphers.shift();
-    expect(cipher5.type).toBe(CipherType.SecureNote);
-    expect(cipher5.name).toBe("Website");
-
-    expect(cipher5.fields.length).toBe(3);
-    expect(cipher5.fields[0].name).toEqual("type");
-    expect(cipher5.fields[0].value).toEqual("website");
-    expect(cipher5.fields[1].name).toEqual("item_name");
-    expect(cipher5.fields[1].value).toEqual("Website");
-    expect(cipher5.fields[2].name).toEqual("url");
-    expect(cipher5.fields[2].value).toEqual("website.com");
-
-    // 2nd name/identity
-    const cipher6 = result.ciphers.shift();
-    expect(cipher6.type).toBe(CipherType.SecureNote);
-    expect(cipher6.name).toBe("Mrs Jane Doe");
-
-    expect(cipher6.fields.length).toBe(7);
-    expect(cipher6.fields[0].name).toEqual("type");
-    expect(cipher6.fields[0].value).toEqual("name");
-    expect(cipher6.fields[1].name).toEqual("title");
-    expect(cipher6.fields[1].value).toEqual("Mrs");
-    expect(cipher6.fields[2].name).toEqual("first_name");
-    expect(cipher6.fields[2].value).toEqual("Jane");
-    expect(cipher6.fields[3].name).toEqual("last_name");
-    expect(cipher6.fields[3].value).toEqual("Doe");
-    expect(cipher6.fields[4].name).toEqual("login");
-    expect(cipher6.fields[4].value).toEqual("jdoe");
-    expect(cipher6.fields[5].name).toEqual("date_of_birth");
-    expect(cipher6.fields[5].value).toEqual("2022-01-30");
-    expect(cipher6.fields[6].name).toEqual("place_of_birth");
-    expect(cipher6.fields[6].value).toEqual("earth");
-  });
-
-  it("should combine personal information records to one identity if only one identity present", async () => {
-    const result = await importer.parse(personalInfoData);
-
-    expect(result).not.toBeNull();
-    expect(result.success).toBe(true);
-
-    const cipher = result.ciphers.shift();
-    expect(cipher.type).toBe(CipherType.Identity);
-    expect(cipher.name).toBe("MR John Doe");
-    expect(cipher.identity.fullName).toBe("MR John Doe");
-    expect(cipher.identity.title).toBe("MR");
-    expect(cipher.identity.firstName).toBe("John");
-    expect(cipher.identity.middleName).toBeNull();
-    expect(cipher.identity.lastName).toBe("Doe");
-    expect(cipher.identity.username).toBe("jdoe");
-    expect(cipher.identity.email).toBe("jdoe@example.com");
-    expect(cipher.identity.phone).toBe("+49123123123");
-
-    expect(cipher.fields.length).toBe(9);
-    expect(cipher.fields[0].name).toBe("date_of_birth");
-    expect(cipher.fields[0].value).toBe("2022-01-30");
-
-    expect(cipher.fields[1].name).toBe("place_of_birth");
-    expect(cipher.fields[1].value).toBe("world");
-
-    expect(cipher.fields[2].name).toBe("email_type");
-    expect(cipher.fields[2].value).toBe("personal");
-
-    expect(cipher.fields[3].name).toBe("address_recipient");
-    expect(cipher.fields[3].value).toBe("John");
-
-    expect(cipher.fields[4].name).toBe("address_building");
-    expect(cipher.fields[4].value).toBe("1");
-
-    expect(cipher.fields[5].name).toBe("address_apartment");
-    expect(cipher.fields[5].value).toBe("1");
-
-    expect(cipher.fields[6].name).toBe("address_floor");
-    expect(cipher.fields[6].value).toBe("1");
-
-    expect(cipher.fields[7].name).toBe("address_door_code");
-    expect(cipher.fields[7].value).toBe("123");
-
-    expect(cipher.fields[8].name).toBe("url");
-    expect(cipher.fields[8].value).toBe("website.com");
-  });
-});

jslib/common/spec/importers/firefoxCsvImporter.spec.ts

@@ -1,74 +0,0 @@
-import { FirefoxCsvImporter as Importer } from "jslib-common/importers/firefoxCsvImporter";
-import { CipherView } from "jslib-common/models/view/cipherView";
-import { LoginUriView } from "jslib-common/models/view/loginUriView";
-import { LoginView } from "jslib-common/models/view/loginView";
-
-import { data as firefoxAccountsData } from "./testData/firefoxCsv/firefoxAccountsData.csv";
-import { data as simplePasswordData } from "./testData/firefoxCsv/simplePasswordData.csv";
-
-const CipherData = [
-  {
-    title: "should parse password",
-    csv: simplePasswordData,
-    expected: Object.assign(new CipherView(), {
-      id: null,
-      organizationId: null,
-      folderId: null,
-      name: "example.com",
-      login: Object.assign(new LoginView(), {
-        username: "foo",
-        password: "bar",
-        uris: [
-          Object.assign(new LoginUriView(), {
-            uri: "https://example.com",
-          }),
-        ],
-      }),
-      notes: null,
-      type: 1,
-    }),
-  },
-  {
-    title: 'should skip "chrome://FirefoxAccounts"',
-    csv: firefoxAccountsData,
-    expected: Object.assign(new CipherView(), {
-      id: null,
-      organizationId: null,
-      folderId: null,
-      name: "example.com",
-      login: Object.assign(new LoginView(), {
-        username: "foo",
-        password: "bar",
-        uris: [
-          Object.assign(new LoginUriView(), {
-            uri: "https://example.com",
-          }),
-        ],
-      }),
-      notes: null,
-      type: 1,
-    }),
-  },
-];
-
-describe("Firefox CSV Importer", () => {
-  CipherData.forEach((data) => {
-    it(data.title, async () => {
-      const importer = new Importer();
-      const result = await importer.parse(data.csv);
-      expect(result != null).toBe(true);
-      expect(result.ciphers.length).toBeGreaterThan(0);
-
-      const cipher = result.ciphers.shift();
-      let property: keyof typeof data.expected;
-      for (property in data.expected) {
-        // eslint-disable-next-line
-        if (data.expected.hasOwnProperty(property)) {
-          // eslint-disable-next-line
-          expect(cipher.hasOwnProperty(property)).toBe(true);
-          expect(cipher[property]).toEqual(data.expected[property]);
-        }
-      }
-    });
-  });
-});

jslib/common/spec/importers/fsecureFskImporter.spec.ts

@@ -1,77 +0,0 @@
-import { FSecureFskImporter as Importer } from "jslib-common/importers/fsecureFskImporter";
-
-const TestDataWithStyleSetToWebsite: string = JSON.stringify({
-  data: {
-    "8d58b5cf252dd06fbd98f5289e918ab1": {
-      color: "#00baff",
-      reatedDate: 1609302913,
-      creditCvv: "",
-      creditExpiry: "",
-      creditNumber: "",
-      favorite: 0,
-      modifiedDate: 1609302913,
-      notes: "note",
-      password: "word",
-      passwordList: [],
-      passwordModifiedDate: 1609302913,
-      rev: 1,
-      service: "My first pass",
-      style: "website",
-      type: 1,
-      url: "https://bitwarden.com",
-      username: "pass",
-    },
-  },
-});
-
-const TestDataWithStyleSetToGlobe: string = JSON.stringify({
-  data: {
-    "8d58b5cf252dd06fbd98f5289e918ab1": {
-      color: "#00baff",
-      reatedDate: 1609302913,
-      creditCvv: "",
-      creditExpiry: "",
-      creditNumber: "",
-      favorite: 0,
-      modifiedDate: 1609302913,
-      notes: "note",
-      password: "word",
-      passwordList: [],
-      passwordModifiedDate: 1609302913,
-      rev: 1,
-      service: "My first pass",
-      style: "globe",
-      type: 1,
-      url: "https://bitwarden.com",
-      username: "pass",
-    },
-  },
-});
-
-describe("FSecure FSK Importer", () => {
-  it("should parse data with style set to website", async () => {
-    const importer = new Importer();
-    const result = await importer.parse(TestDataWithStyleSetToWebsite);
-    expect(result != null).toBe(true);
-
-    const cipher = result.ciphers.shift();
-    expect(cipher.login.username).toEqual("pass");
-    expect(cipher.login.password).toEqual("word");
-    expect(cipher.login.uris.length).toEqual(1);
-    const uriView = cipher.login.uris.shift();
-    expect(uriView.uri).toEqual("https://bitwarden.com");
-  });
-
-  it("should parse data with style set to globe", async () => {
-    const importer = new Importer();
-    const result = await importer.parse(TestDataWithStyleSetToGlobe);
-    expect(result != null).toBe(true);
-
-    const cipher = result.ciphers.shift();
-    expect(cipher.login.username).toEqual("pass");
-    expect(cipher.login.password).toEqual("word");
-    expect(cipher.login.uris.length).toEqual(1);
-    const uriView = cipher.login.uris.shift();
-    expect(uriView.uri).toEqual("https://bitwarden.com");
-  });
-});

jslib/common/spec/importers/keepass2XmlImporter.spec.ts

@@ -1,189 +0,0 @@
-import { KeePass2XmlImporter as Importer } from "jslib-common/importers/keepass2XmlImporter";
-
-const TestData = `<?xml version="1.0" encoding="utf-8" standalone="yes"?>
-<KeePassFile>
-	<Meta>
-		<Generator>KeePass</Generator>
-		<DatabaseName />
-		<DatabaseNameChanged>2016-12-31T21:33:52Z</DatabaseNameChanged>
-		<DatabaseDescription />
-		<DatabaseDescriptionChanged>2016-12-31T21:33:52Z</DatabaseDescriptionChanged>
-		<DefaultUserName />
-		<DefaultUserNameChanged>2016-12-31T21:33:52Z</DefaultUserNameChanged>
-		<MaintenanceHistoryDays>365</MaintenanceHistoryDays>
-		<Color />
-		<MasterKeyChanged>2016-12-31T21:33:59Z</MasterKeyChanged>
-		<MasterKeyChangeRec>-1</MasterKeyChangeRec>
-		<MasterKeyChangeForce>-1</MasterKeyChangeForce>
-		<MemoryProtection>
-			<ProtectTitle>False</ProtectTitle>
-			<ProtectUserName>False</ProtectUserName>
-			<ProtectPassword>True</ProtectPassword>
-			<ProtectURL>False</ProtectURL>
-			<ProtectNotes>False</ProtectNotes>
-		</MemoryProtection>
-		<RecycleBinEnabled>True</RecycleBinEnabled>
-		<RecycleBinUUID>AAAAAAAAAAAAAAAAAAAAAA==</RecycleBinUUID>
-		<RecycleBinChanged>2016-12-31T21:33:52Z</RecycleBinChanged>
-		<EntryTemplatesGroup>AAAAAAAAAAAAAAAAAAAAAA==</EntryTemplatesGroup>
-		<EntryTemplatesGroupChanged>2016-12-31T21:33:52Z</EntryTemplatesGroupChanged>
-		<HistoryMaxItems>10</HistoryMaxItems>
-		<HistoryMaxSize>6291456</HistoryMaxSize>
-		<LastSelectedGroup>AAAAAAAAAAAAAAAAAAAAAA==</LastSelectedGroup>
-		<LastTopVisibleGroup>AAAAAAAAAAAAAAAAAAAAAA==</LastTopVisibleGroup>
-		<Binaries />
-		<CustomData />
-	</Meta>
-	<Root>
-		<Group>
-			<UUID>KvS57lVwl13AfGFLwkvq4Q==</UUID>
-			<Name>Root</Name>
-			<Notes />
-			<IconID>48</IconID>
-			<Times>
-				<CreationTime>2016-12-31T21:33:52Z</CreationTime>
-				<LastModificationTime>2016-12-31T21:33:52Z</LastModificationTime>
-				<LastAccessTime>2017-01-01T22:58:00Z</LastAccessTime>
-				<ExpiryTime>2016-12-31T21:33:52Z</ExpiryTime>
-				<Expires>False</Expires>
-				<UsageCount>1</UsageCount>
-				<LocationChanged>2016-12-31T21:33:52Z</LocationChanged>
-			</Times>
-			<IsExpanded>True</IsExpanded>
-			<DefaultAutoTypeSequence />
-			<EnableAutoType>null</EnableAutoType>
-			<EnableSearching>null</EnableSearching>
-			<LastTopVisibleEntry>AAAAAAAAAAAAAAAAAAAAAA==</LastTopVisibleEntry>
-			<Group>
-				<UUID>P0ParXgGMBW6caOL2YrhqQ==</UUID>
-				<Name>Folder2</Name>
-				<Notes>a note about the folder</Notes>
-				<IconID>48</IconID>
-				<Times>
-					<CreationTime>2016-12-31T21:43:30Z</CreationTime>
-					<LastModificationTime>2016-12-31T21:43:43Z</LastModificationTime>
-					<LastAccessTime>2017-01-01T22:58:00Z</LastAccessTime>
-					<ExpiryTime>2016-12-31T21:43:30Z</ExpiryTime>
-					<Expires>False</Expires>
-					<UsageCount>1</UsageCount>
-					<LocationChanged>2016-12-31T21:43:43Z</LocationChanged>
-				</Times>
-				<IsExpanded>True</IsExpanded>
-				<DefaultAutoTypeSequence />
-				<EnableAutoType>null</EnableAutoType>
-				<EnableSearching>null</EnableSearching>
-				<LastTopVisibleEntry>AAAAAAAAAAAAAAAAAAAAAA==</LastTopVisibleEntry>
-				<Entry>
-					<UUID>fAa543oYlgnJKkhKag5HLw==</UUID>
-					<IconID>1</IconID>
-					<ForegroundColor />
-					<BackgroundColor />
-					<OverrideURL />
-					<Tags />
-					<Times>
-						<CreationTime>2016-12-31T21:34:13Z</CreationTime>
-						<LastModificationTime>2016-12-31T21:40:23Z</LastModificationTime>
-						<LastAccessTime>2016-12-31T21:40:23Z</LastAccessTime>
-						<ExpiryTime>2016-12-31T21:34:13Z</ExpiryTime>
-						<Expires>False</Expires>
-						<UsageCount>0</UsageCount>
-						<LocationChanged>2016-12-31T21:43:48Z</LocationChanged>
-					</Times>
-					<String>
-						<Key>att2</Key>
-						<Value>att2value</Value>
-					</String>
-					<String>
-						<Key>attr1</Key>
-						<Value>att1value
-
-line1
-line2</Value>
-					</String>
-					<String>
-						<Key>Notes</Key>
-						<Value>This is a note!!!
-
-line1
-line2</Value>
-					</String>
-					<String>
-						<Key>Password</Key>
-						<Value ProtectInMemory="True">googpass</Value>
-					</String>
-					<String>
-						<Key>Title</Key>
-						<Value>Google</Value>
-					</String>
-					<String>
-						<Key>URL</Key>
-						<Value>google.com</Value>
-					</String>
-					<String>
-						<Key>UserName</Key>
-						<Value>googleuser</Value>
-					</String>
-					<AutoType>
-						<Enabled>True</Enabled>
-						<DataTransferObfuscation>0</DataTransferObfuscation>
-					</AutoType>
-					<History>
-						<Entry>
-							<UUID>fAa543oYlgnJKkhKag5HLw==</UUID>
-							<IconID>0</IconID>
-							<ForegroundColor />
-							<BackgroundColor />
-							<OverrideURL />
-							<Tags />
-							<Times>
-								<CreationTime>2016-12-31T21:34:13Z</CreationTime>
-								<LastModificationTime>2016-12-31T21:34:40Z</LastModificationTime>
-								<LastAccessTime>2016-12-31T21:34:40Z</LastAccessTime>
-								<ExpiryTime>2016-12-31T21:34:13Z</ExpiryTime>
-								<Expires>False</Expires>
-								<UsageCount>0</UsageCount>
-								<LocationChanged>2016-12-31T21:34:40Z</LocationChanged>
-							</Times>
-							<String>
-								<Key>Notes</Key>
-								<Value>This is a note!!!
-
-line1
-line2</Value>
-							</String>
-							<String>
-								<Key>Password</Key>
-								<Value ProtectInMemory="True">googpass</Value>
-							</String>
-							<String>
-								<Key>Title</Key>
-								<Value>Google</Value>
-							</String>
-							<String>
-								<Key>URL</Key>
-								<Value>google.com</Value>
-							</String>
-							<String>
-								<Key>UserName</Key>
-								<Value>googleuser</Value>
-							</String>
-							<AutoType>
-								<Enabled>True</Enabled>
-								<DataTransferObfuscation>0</DataTransferObfuscation>
-							</AutoType>
-						</Entry>
-					</History>
-				</Entry>
-			</Group>
-		</Group>
-		<DeletedObjects />
-	</Root>
-</KeePassFile>`;
-
-describe("KeePass2 Xml Importer", () => {
-  it("should parse XML data", async () => {
-    const importer = new Importer();
-    const result = await importer.parse(TestData);
-    expect(result != null).toBe(true);
-  });
-});

jslib/common/spec/importers/keeperJsonImporter.spec.ts

@@ -1,108 +0,0 @@
-import { KeeperJsonImporter as Importer } from "jslib-common/importers/keeperImporters/keeperJsonImporter";
-import { Utils } from "jslib-common/misc/utils";
-
-import { testData as TestData } from "./testData/keeperJson/testData";
-
-describe("Keeper Json Importer", () => {
-  const testDataJson = JSON.stringify(TestData);
-
-  let importer: Importer;
-  beforeEach(() => {
-    importer = new Importer();
-  });
-
-  it("should parse login data", async () => {
-    const result = await importer.parse(testDataJson);
-    expect(result != null).toBe(true);
-
-    const cipher = result.ciphers.shift();
-    expect(cipher.name).toEqual("Bank Account 1");
-    expect(cipher.login.username).toEqual("customer1234");
-    expect(cipher.login.password).toEqual("4813fJDHF4239fdk");
-    expect(cipher.login.uris.length).toEqual(1);
-    const uriView = cipher.login.uris.shift();
-    expect(uriView.uri).toEqual("https://chase.com");
-    expect(cipher.notes).toEqual("These are some notes.");
-
-    const cipher2 = result.ciphers.shift();
-    expect(cipher2.name).toEqual("Bank Account 2");
-    expect(cipher2.login.username).toEqual("mybankusername");
-    expect(cipher2.login.password).toEqual("w4k4k193f$^&@#*%2");
-    expect(cipher2.login.uris.length).toEqual(1);
-    const uriView2 = cipher2.login.uris.shift();
-    expect(uriView2.uri).toEqual("https://amex.com");
-    expect(cipher2.notes).toEqual("Some great information here.");
-
-    const cipher3 = result.ciphers.shift();
-    expect(cipher3.name).toEqual("Some Account");
-    expect(cipher3.login.username).toEqual("someUserName");
-    expect(cipher3.login.password).toEqual("w4k4k1wergf$^&@#*%2");
-    expect(cipher3.notes).toBeNull();
-    expect(cipher3.fields).toBeNull();
-    expect(cipher3.login.uris.length).toEqual(1);
-    const uriView3 = cipher3.login.uris.shift();
-    expect(uriView3.uri).toEqual("https://example.com");
-  });
-
-  it("should import TOTP when present", async () => {
-    const result = await importer.parse(testDataJson);
-    expect(result != null).toBe(true);
-
-    const cipher = result.ciphers.shift();
-    expect(cipher.login.totp).toBeNull();
-
-    // 2nd Cipher
-    const cipher2 = result.ciphers.shift();
-    expect(cipher2.login.totp).toEqual(
-      "otpauth://totp/Amazon:me@company.com?secret=JBSWY3DPEHPK3PXP&issuer=Amazon&algorithm=SHA1&digits=6&period=30"
-    );
-  });
-
-  it("should parse custom fields", async () => {
-    const result = await importer.parse(testDataJson);
-    expect(result != null).toBe(true);
-
-    const cipher = result.ciphers.shift();
-    expect(cipher.fields.length).toBe(1);
-    expect(cipher.fields[0].name).toEqual("Account Number");
-    expect(cipher.fields[0].value).toEqual("123-456-789");
-
-    // 2nd Cipher
-    const cipher2 = result.ciphers.shift();
-    expect(cipher2.fields.length).toBe(2);
-    expect(cipher2.fields[0].name).toEqual("Security Group");
-    expect(cipher2.fields[0].value).toEqual("Public");
-
-    expect(cipher2.fields[1].name).toEqual("IP Address");
-    expect(cipher2.fields[1].value).toEqual("12.45.67.8");
-  });
-
-  it("should create folders and assigned ciphers to them", async () => {
-    const result = await importer.parse(testDataJson);
-    expect(result != null).toBe(true);
-
-    const folders = result.folders;
-    expect(folders.length).toBe(2);
-    expect(folders[0].name).toBe("Optional Private Folder 1");
-    expect(folders[1].name).toBe("My Customer 1");
-
-    expect(result.folderRelationships[0]).toEqual([0, 0]);
-    expect(result.folderRelationships[1]).toEqual([1, 0]);
-    expect(result.folderRelationships[2]).toEqual([1, 1]);
-  });
-
-  it("should create collections if part of an organization", async () => {
-    importer.organizationId = Utils.newGuid();
-    const result = await importer.parse(testDataJson);
-    expect(result != null).toBe(true);
-
-    const collections = result.collections;
-    expect(collections.length).toBe(2);
-    expect(collections[0].name).toBe("Optional Private Folder 1");
-    expect(collections[1].name).toBe("My Customer 1");
-
-    expect(result.collectionRelationships[0]).toEqual([0, 0]);
-    expect(result.collectionRelationships[1]).toEqual([1, 0]);
-    expect(result.collectionRelationships[2]).toEqual([1, 1]);
-  });
-});

jslib/common/spec/importers/lastpassCsvImporter.spec.ts

@@ -1,202 +0,0 @@
-import { CipherType } from "jslib-common/enums/cipherType";
-import { FieldType } from "jslib-common/enums/fieldType";
-import { LastPassCsvImporter as Importer } from "jslib-common/importers/lastpassCsvImporter";
-import { ImportResult } from "jslib-common/models/domain/importResult";
-import { CipherView } from "jslib-common/models/view/cipherView";
-import { FieldView } from "jslib-common/models/view/fieldView";
-
-function baseExcept(result: ImportResult) {
-  expect(result).not.toBeNull();
-  expect(result.success).toBe(true);
-  expect(result.ciphers.length).toBe(1);
-}
-
-function expectLogin(cipher: CipherView) {
-  expect(cipher.type).toBe(CipherType.Login);
-
-  expect(cipher.name).toBe("example.com");
-  expect(cipher.notes).toBe("super secure notes");
-  expect(cipher.login.uri).toBe("http://example.com");
-  expect(cipher.login.username).toBe("someUser");
-  expect(cipher.login.password).toBe("myPassword");
-  expect(cipher.login.totp).toBe("Y64VEVMBTSXCYIWRSHRNDZW62MPGVU2G");
-}
-
-const CipherData = [
-  {
-    title: "should parse expiration date",
-    csv: `url,username,password,extra,name,grouping,fav
-http://sn,,,"NoteType:Credit Card
-Name on Card:John Doe
-Type:
-Number:1234567812345678
-Security Code:123
-Start Date:October,2017
-Expiration Date:June,2020
-Notes:some text
-",Credit-card,,0`,
-    expected: Object.assign(new CipherView(), {
-      id: null,
-      organizationId: null,
-      folderId: null,
-      name: "Credit-card",
-      notes: "some text\n",
-      type: 3,
-      card: {
-        cardholderName: "John Doe",
-        number: "1234567812345678",
-        code: "123",
-        expYear: "2020",
-        expMonth: "6",
-      },
-      fields: [
-        Object.assign(new FieldView(), {
-          name: "Start Date",
-          value: "October,2017",
-          type: FieldType.Text,
-        }),
-      ],
-    }),
-  },
-  {
-    title: "should parse blank card note",
-    csv: `url,username,password,extra,name,grouping,fav
-http://sn,,,"NoteType:Credit Card
-Name on Card:
-Type:
-Number:
-Security Code:
-Start Date:,
-Expiration Date:,
-Notes:",empty,,0`,
-    expected: Object.assign(new CipherView(), {
-      id: null,
-      organizationId: null,
-      folderId: null,
-      name: "empty",
-      notes: null,
-      type: 3,
-      card: {
-        expMonth: undefined,
-      },
-      fields: [
-        Object.assign(new FieldView(), {
-          name: "Start Date",
-          value: ",",
-          type: FieldType.Text,
-        }),
-      ],
-    }),
-  },
-  {
-    title: "should parse card expiration date w/ no exp year",
-    csv: `url,username,password,extra,name,grouping,fav
-http://sn,,,"NoteType:Credit Card
-Name on Card:John Doe
-Type:Visa
-Number:1234567887654321
-Security Code:321
-Start Date:,
-Expiration Date:January,
-Notes:",noyear,,0`,
-    expected: Object.assign(new CipherView(), {
-      id: null,
-      organizationId: null,
-      folderId: null,
-      name: "noyear",
-      notes: null,
-      type: 3,
-      card: {
-        cardholderName: "John Doe",
-        number: "1234567887654321",
-        code: "321",
-        expMonth: "1",
-      },
-      fields: [
-        Object.assign(new FieldView(), {
-          name: "Type",
-          value: "Visa",
-          type: FieldType.Text,
-        }),
-        Object.assign(new FieldView(), {
-          name: "Start Date",
-          value: ",",
-          type: FieldType.Text,
-        }),
-      ],
-    }),
-  },
-  {
-    title: "should parse card expiration date w/ no month",
-    csv: `url,username,password,extra,name,grouping,fav
-http://sn,,,"NoteType:Credit Card
-Name on Card:John Doe
-Type:Mastercard
-Number:8765432112345678
-Security Code:987
-Start Date:,
-Expiration Date:,2020
-Notes:",nomonth,,0`,
-    expected: Object.assign(new CipherView(), {
-      id: null,
-      organizationId: null,
-      folderId: null,
-      name: "nomonth",
-      notes: null,
-      type: 3,
-      card: {
-        cardholderName: "John Doe",
-        number: "8765432112345678",
-        code: "987",
-        expYear: "2020",
-        expMonth: undefined,
-      },
-      fields: [
-        Object.assign(new FieldView(), {
-          name: "Type",
-          value: "Mastercard",
-          type: FieldType.Text,
-        }),
-        Object.assign(new FieldView(), {
-          name: "Start Date",
-          value: ",",
-          type: FieldType.Text,
-        }),
-      ],
-    }),
-  },
-];
-
-describe("Lastpass CSV Importer", () => {
-  CipherData.forEach((data) => {
-    it(data.title, async () => {
-      const importer = new Importer();
-      const result = await importer.parse(data.csv);
-      expect(result != null).toBe(true);
-      expect(result.ciphers.length).toBeGreaterThan(0);
-
-      const cipher = result.ciphers.shift();
-      let property: keyof typeof data.expected;
-      for (property in data.expected) {
-        // eslint-disable-next-line
-        if (data.expected.hasOwnProperty(property)) {
-          // eslint-disable-next-line
-          expect(cipher.hasOwnProperty(property)).toBe(true);
-          expect(cipher[property]).toEqual(data.expected[property]);
-        }
-      }
-    });
-  });
-
-  it("should parse login with totp", async () => {
-    const input = `url,username,password,totp,extra,name,grouping,fav
-        http://example.com,someUser,myPassword,Y64VEVMBTSXCYIWRSHRNDZW62MPGVU2G,super secure notes,example.com,,0`;
-
-    const importer = new Importer();
-    const result = await importer.parse(input);
-    baseExcept(result);
-
-    const cipher = result.ciphers[0];
-    expectLogin(cipher);
-  });
-});

jslib/common/spec/importers/mykiCsvImporter.spec.ts

@@ -1,633 +0,0 @@
-import { CipherType } from "jslib-common/enums/cipherType";
-import { MykiCsvImporter as Importer } from "jslib-common/importers/mykiCsvImporter";
-import { CipherView } from "jslib-common/models/view/cipherView";
-
-import { userAccountData } from "./testData/mykiCsv/UserAccount.csv";
-import { userCreditCardData } from "./testData/mykiCsv/UserCreditCard.csv";
-import { userIdCardData } from "./testData/mykiCsv/UserIdCard.csv";
-import { userIdentityData } from "./testData/mykiCsv/UserIdentity.csv";
-import { userNoteData } from "./testData/mykiCsv/UserNote.csv";
-import { userTwoFaData } from "./testData/mykiCsv/UserTwofa.csv";
-
-function expectDriversLicense(cipher: CipherView) {
-  expect(cipher.type).toBe(CipherType.Identity);
-  expect(cipher.name).toBe("Joe User's nickname");
-  expect(cipher.notes).toBe("Additional information");
-
-  expect(cipher.identity.fullName).toBe("Joe M User");
-  expect(cipher.identity.firstName).toBe("Joe");
-  expect(cipher.identity.middleName).toBe("M");
-  expect(cipher.identity.lastName).toBe("User");
-  expect(cipher.identity.licenseNumber).toBe("123456");
-  expect(cipher.identity.country).toBe("United States");
-
-  expect(cipher.fields.length).toBe(5);
-
-  expect(cipher.fields[0].name).toEqual("status");
-  expect(cipher.fields[0].value).toEqual("active");
-
-  expect(cipher.fields[1].name).toEqual("tags");
-  expect(cipher.fields[1].value).toEqual("someTag");
-
-  expect(cipher.fields[2].name).toEqual("idType");
-  expect(cipher.fields[2].value).toEqual("Driver's License");
-
-  expect(cipher.fields[3].name).toEqual("idIssuanceDate");
-  expect(cipher.fields[3].value).toEqual("02/02/2022");
-
-  expect(cipher.fields[4].name).toEqual("idExpirationDate");
-  expect(cipher.fields[4].value).toEqual("02/02/2024");
-}
-
-function expectPassport(cipher: CipherView) {
-  expect(cipher.type).toBe(CipherType.Identity);
-  expect(cipher.name).toBe("Passport ID card");
-  expect(cipher.notes).toBe("Additional information field");
-
-  expect(cipher.identity.fullName).toBe("Joe M User");
-  expect(cipher.identity.firstName).toBe("Joe");
-  expect(cipher.identity.middleName).toBe("M");
-  expect(cipher.identity.lastName).toBe("User");
-  expect(cipher.identity.passportNumber).toBe("1234567");
-  expect(cipher.identity.country).toBe("United States");
-
-  expect(cipher.fields.length).toBe(5);
-
-  expect(cipher.fields[0].name).toEqual("status");
-  expect(cipher.fields[0].value).toEqual("active");
-
-  expect(cipher.fields[1].name).toEqual("tags");
-  expect(cipher.fields[1].value).toEqual("someTag");
-
-  expect(cipher.fields[2].name).toEqual("idType");
-  expect(cipher.fields[2].value).toEqual("Passport");
-
-  expect(cipher.fields[3].name).toEqual("idIssuanceDate");
-  expect(cipher.fields[3].value).toEqual("03/07/2022");
-
-  expect(cipher.fields[4].name).toEqual("idExpirationDate");
-  expect(cipher.fields[4].value).toEqual("03/07/2028");
-}
-
-function expectSocialSecurity(cipher: CipherView) {
-  expect(cipher.type).toBe(CipherType.Identity);
-  expect(cipher.name).toBe("Social Security ID card");
-  expect(cipher.notes).toBe("Additional information field text");
-
-  expect(cipher.identity.fullName).toBe("Joe M User");
-  expect(cipher.identity.firstName).toBe("Joe");
-  expect(cipher.identity.middleName).toBe("M");
-  expect(cipher.identity.lastName).toBe("User");
-  expect(cipher.identity.ssn).toBe("123455678");
-  expect(cipher.identity.country).toBe("United States");
-
-  expect(cipher.fields.length).toBe(5);
-
-  expect(cipher.fields[0].name).toEqual("status");
-  expect(cipher.fields[0].value).toEqual("active");
-
-  expect(cipher.fields[1].name).toEqual("tags");
-  expect(cipher.fields[1].value).toEqual("someTag");
-
-  expect(cipher.fields[2].name).toEqual("idType");
-  expect(cipher.fields[2].value).toEqual("Social Security");
-
-  expect(cipher.fields[3].name).toEqual("idIssuanceDate");
-  expect(cipher.fields[3].value).toEqual("03/07/2022");
-
-  expect(cipher.fields[4].name).toEqual("idExpirationDate");
-  expect(cipher.fields[4].value).toEqual("03/07/2028");
-}
-
-function expectIdCard(cipher: CipherView) {
-  expect(cipher.type).toBe(CipherType.Identity);
-  expect(cipher.name).toBe("ID card type ID card");
-  expect(cipher.notes).toBe("Additional Information field text");
-
-  expect(cipher.identity.fullName).toBe("Joe M User");
-  expect(cipher.identity.firstName).toBe("Joe");
-  expect(cipher.identity.middleName).toBe("M");
-  expect(cipher.identity.lastName).toBe("User");
-  expect(cipher.identity.licenseNumber).toBe("1234566");
-  expect(cipher.identity.country).toBe("United States");
-
-  expect(cipher.fields.length).toBe(5);
-
-  expect(cipher.fields[0].name).toEqual("status");
-  expect(cipher.fields[0].value).toEqual("active");
-
-  expect(cipher.fields[1].name).toEqual("tags");
-  expect(cipher.fields[1].value).toEqual("someTag");
-
-  expect(cipher.fields[2].name).toEqual("idType");
-  expect(cipher.fields[2].value).toEqual("ID Card");
-
-  expect(cipher.fields[3].name).toEqual("idIssuanceDate");
-  expect(cipher.fields[3].value).toEqual("03/07/2022");
-
-  expect(cipher.fields[4].name).toEqual("idExpirationDate");
-  expect(cipher.fields[4].value).toEqual("03/07/2028");
-}
-
-function expectTaxNumber(cipher: CipherView) {
-  expect(cipher.type).toBe(CipherType.Identity);
-  expect(cipher.name).toBe("Tax number ID card");
-  expect(cipher.notes).toBe("Additinoal information text field");
-
-  expect(cipher.identity.fullName).toBe("Joe M User");
-  expect(cipher.identity.firstName).toBe("Joe");
-  expect(cipher.identity.middleName).toBe("M");
-  expect(cipher.identity.lastName).toBe("User");
-  expect(cipher.identity.licenseNumber).toBe("12345678");
-  expect(cipher.identity.country).toBe("United States");
-
-  expect(cipher.fields.length).toBe(5);
-
-  expect(cipher.fields[0].name).toEqual("status");
-  expect(cipher.fields[0].value).toEqual("active");
-
-  expect(cipher.fields[1].name).toEqual("tags");
-  expect(cipher.fields[1].value).toEqual("someTag");
-
-  expect(cipher.fields[2].name).toEqual("idType");
-  expect(cipher.fields[2].value).toEqual("Tax Number");
-
-  expect(cipher.fields[3].name).toEqual("idIssuanceDate");
-  expect(cipher.fields[3].value).toEqual("03/07/2022");
-
-  expect(cipher.fields[4].name).toEqual("idExpirationDate");
-  expect(cipher.fields[4].value).toEqual("03/07/2028");
-}
-
-function expectBankAccount(cipher: CipherView) {
-  expect(cipher.type).toBe(CipherType.Identity);
-  expect(cipher.name).toBe("Bank account ID card");
-  expect(cipher.notes).toBe("Additional text information here");
-
-  expect(cipher.identity.fullName).toBe("Joe M User");
-  expect(cipher.identity.firstName).toBe("Joe");
-  expect(cipher.identity.middleName).toBe("M");
-  expect(cipher.identity.lastName).toBe("User");
-  expect(cipher.identity.licenseNumber).toBe("12344556677");
-  expect(cipher.identity.country).toBe("United States");
-
-  expect(cipher.fields.length).toBe(5);
-
-  expect(cipher.fields[0].name).toEqual("status");
-  expect(cipher.fields[0].value).toEqual("active");
-
-  expect(cipher.fields[1].name).toEqual("tags");
-  expect(cipher.fields[1].value).toEqual("someTag");
-
-  expect(cipher.fields[2].name).toEqual("idType");
-  expect(cipher.fields[2].value).toEqual("Bank Account");
-
-  expect(cipher.fields[3].name).toEqual("idIssuanceDate");
-  expect(cipher.fields[3].value).toEqual("03/07/2022");
-
-  expect(cipher.fields[4].name).toEqual("idExpirationDate");
-  expect(cipher.fields[4].value).toEqual("03/07/2028");
-}
-
-function expectInsuranceCard(cipher: CipherView) {
-  expect(cipher.type).toBe(CipherType.Identity);
-  expect(cipher.name).toBe("Insurance card ID card");
-  expect(cipher.notes).toBe("Additional information text goes here");
-
-  expect(cipher.identity.fullName).toBe("Joe M User");
-  expect(cipher.identity.firstName).toBe("Joe");
-  expect(cipher.identity.middleName).toBe("M");
-  expect(cipher.identity.lastName).toBe("User");
-  expect(cipher.identity.licenseNumber).toBe("123456677");
-  expect(cipher.identity.country).toBe("United States");
-
-  expect(cipher.fields.length).toBe(5);
-
-  expect(cipher.fields[0].name).toEqual("status");
-  expect(cipher.fields[0].value).toEqual("active");
-
-  expect(cipher.fields[1].name).toEqual("tags");
-  expect(cipher.fields[1].value).toEqual("someTag");
-
-  expect(cipher.fields[2].name).toEqual("idType");
-  expect(cipher.fields[2].value).toEqual("Insurance Card");
-
-  expect(cipher.fields[3].name).toEqual("idIssuanceDate");
-  expect(cipher.fields[3].value).toEqual("03/07/2022");
-
-  expect(cipher.fields[4].name).toEqual("idExpirationDate");
-  expect(cipher.fields[4].value).toEqual("03/07/2022");
-}
-
-function expectHealthCard(cipher: CipherView) {
-  expect(cipher.type).toBe(CipherType.Identity);
-  expect(cipher.name).toBe("Health card Id card");
-  expect(cipher.notes).toBe("More info");
-
-  expect(cipher.identity.fullName).toBe("Joe M User");
-  expect(cipher.identity.firstName).toBe("Joe");
-  expect(cipher.identity.middleName).toBe("M");
-  expect(cipher.identity.lastName).toBe("User");
-  expect(cipher.identity.licenseNumber).toBe("1234670");
-  expect(cipher.identity.country).toBe("United States");
-
-  expect(cipher.fields.length).toBe(5);
-
-  expect(cipher.fields[0].name).toEqual("status");
-  expect(cipher.fields[0].value).toEqual("active");
-
-  expect(cipher.fields[1].name).toEqual("tags");
-  expect(cipher.fields[1].value).toEqual("someTag");
-
-  expect(cipher.fields[2].name).toEqual("idType");
-  expect(cipher.fields[2].value).toEqual("Health Card");
-
-  expect(cipher.fields[3].name).toEqual("idIssuanceDate");
-  expect(cipher.fields[3].value).toEqual("03/07/2022");
-
-  expect(cipher.fields[4].name).toEqual("idExpirationDate");
-  expect(cipher.fields[4].value).toEqual("03/07/2028");
-}
-
-function expectMembershipCard(cipher: CipherView) {
-  expect(cipher.type).toBe(CipherType.Identity);
-  expect(cipher.name).toBe("Membership ID card");
-  expect(cipher.notes).toBe("Add'l info");
-
-  expect(cipher.identity.fullName).toBe("Joe M User");
-  expect(cipher.identity.firstName).toBe("Joe");
-  expect(cipher.identity.middleName).toBe("M");
-  expect(cipher.identity.lastName).toBe("User");
-  expect(cipher.identity.licenseNumber).toBe("12345709");
-  expect(cipher.identity.country).toBe("United States");
-
-  expect(cipher.fields.length).toBe(5);
-
-  expect(cipher.fields[0].name).toEqual("status");
-  expect(cipher.fields[0].value).toEqual("active");
-
-  expect(cipher.fields[1].name).toEqual("tags");
-  expect(cipher.fields[1].value).toEqual("someTag");
-
-  expect(cipher.fields[2].name).toEqual("idType");
-  expect(cipher.fields[2].value).toEqual("Membership");
-
-  expect(cipher.fields[3].name).toEqual("idIssuanceDate");
-  expect(cipher.fields[3].value).toEqual("03/07/2022");
-
-  expect(cipher.fields[4].name).toEqual("idExpirationDate");
-  expect(cipher.fields[4].value).toEqual("03/07/2028");
-}
-
-function expectDatabase(cipher: CipherView) {
-  expect(cipher.type).toBe(CipherType.Identity);
-  expect(cipher.name).toBe("Database ID card");
-  expect(cipher.notes).toBe("Addin't info");
-
-  expect(cipher.identity.fullName).toBe("Joe M User");
-  expect(cipher.identity.firstName).toBe("Joe");
-  expect(cipher.identity.middleName).toBe("M");
-  expect(cipher.identity.lastName).toBe("User");
-  expect(cipher.identity.licenseNumber).toBe("12345089u");
-  expect(cipher.identity.country).toBe("United States");
-
-  expect(cipher.fields.length).toBe(5);
-
-  expect(cipher.fields[0].name).toEqual("status");
-  expect(cipher.fields[0].value).toEqual("active");
-
-  expect(cipher.fields[1].name).toEqual("tags");
-  expect(cipher.fields[1].value).toEqual("someTag");
-
-  expect(cipher.fields[2].name).toEqual("idType");
-  expect(cipher.fields[2].value).toEqual("Database");
-
-  expect(cipher.fields[3].name).toEqual("idIssuanceDate");
-  expect(cipher.fields[3].value).toEqual("03/07/2022");
-
-  expect(cipher.fields[4].name).toEqual("idExpirationDate");
-  expect(cipher.fields[4].value).toEqual("03/07/2028");
-}
-
-function expectOutdoorLicense(cipher: CipherView) {
-  expect(cipher.type).toBe(CipherType.Identity);
-  expect(cipher.name).toBe("Outdoor license ID card");
-  expect(cipher.notes).toBe("Additional info");
-
-  expect(cipher.identity.fullName).toBe("Joe M User");
-  expect(cipher.identity.firstName).toBe("Joe");
-  expect(cipher.identity.middleName).toBe("M");
-  expect(cipher.identity.lastName).toBe("User");
-  expect(cipher.identity.licenseNumber).toBe("123890090");
-  expect(cipher.identity.country).toBe("United States");
-
-  expect(cipher.fields.length).toBe(5);
-
-  expect(cipher.fields[0].name).toEqual("status");
-  expect(cipher.fields[0].value).toEqual("active");
-
-  expect(cipher.fields[1].name).toEqual("tags");
-  expect(cipher.fields[1].value).toEqual("someTag");
-
-  expect(cipher.fields[2].name).toEqual("idType");
-  expect(cipher.fields[2].value).toEqual("Outdoor License");
-
-  expect(cipher.fields[3].name).toEqual("idIssuanceDate");
-  expect(cipher.fields[3].value).toEqual("03/07/2022");
-
-  expect(cipher.fields[4].name).toEqual("idExpirationDate");
-  expect(cipher.fields[4].value).toEqual("03/07/2028");
-}
-
-function expectRewardProgram(cipher: CipherView) {
-  expect(cipher.type).toBe(CipherType.Identity);
-  expect(cipher.name).toBe("Reward program Id card");
-  expect(cipher.notes).toBe("1234890");
-
-  expect(cipher.identity.fullName).toBe("Joe M User");
-  expect(cipher.identity.firstName).toBe("Joe");
-  expect(cipher.identity.middleName).toBe("M");
-  expect(cipher.identity.lastName).toBe("User");
-  expect(cipher.identity.licenseNumber).toBe("12345890b");
-  expect(cipher.identity.country).toBe("United States");
-
-  expect(cipher.fields.length).toBe(5);
-
-  expect(cipher.fields[0].name).toEqual("status");
-  expect(cipher.fields[0].value).toEqual("active");
-
-  expect(cipher.fields[1].name).toEqual("tags");
-  expect(cipher.fields[1].value).toEqual("someTag");
-
-  expect(cipher.fields[2].name).toEqual("idType");
-  expect(cipher.fields[2].value).toEqual("Reward Program");
-
-  expect(cipher.fields[3].name).toEqual("idIssuanceDate");
-  expect(cipher.fields[3].value).toEqual("03/07/2022");
-
-  expect(cipher.fields[4].name).toEqual("idExpirationDate");
-  expect(cipher.fields[4].value).toEqual("03/07/2028");
-}
-
-function expectSoftwareLicense(cipher: CipherView) {
-  expect(cipher.type).toBe(CipherType.Identity);
-  expect(cipher.name).toBe("Software license ID card");
-  expect(cipher.notes).toBe(
-    "It seems like the fields don't change, which makes it pretty useless that they have so many ID card types."
-  );
-
-  expect(cipher.identity.fullName).toBe("Joe M User");
-  expect(cipher.identity.firstName).toBe("Joe");
-  expect(cipher.identity.middleName).toBe("M");
-  expect(cipher.identity.lastName).toBe("User");
-  expect(cipher.identity.licenseNumber).toBe("1234567c");
-  expect(cipher.identity.country).toBe("United States");
-
-  expect(cipher.fields.length).toBe(5);
-
-  expect(cipher.fields[0].name).toEqual("status");
-  expect(cipher.fields[0].value).toEqual("active");
-
-  expect(cipher.fields[1].name).toEqual("tags");
-  expect(cipher.fields[1].value).toEqual("someTag");
-
-  expect(cipher.fields[2].name).toEqual("idType");
-  expect(cipher.fields[2].value).toEqual("Software License");
-
-  expect(cipher.fields[3].name).toEqual("idIssuanceDate");
-  expect(cipher.fields[3].value).toEqual("03/07/2022");
-
-  expect(cipher.fields[4].name).toEqual("idExpirationDate");
-  expect(cipher.fields[4].value).toEqual("03/07/2028");
-}
-
-function expectTourVisa(cipher: CipherView) {
-  expect(cipher.type).toBe(CipherType.Identity);
-  expect(cipher.name).toBe("Tour visa ID card");
-  expect(cipher.notes).toBe("Additional Informaion text");
-
-  expect(cipher.identity.fullName).toBe("Joe M User");
-  expect(cipher.identity.firstName).toBe("Joe");
-  expect(cipher.identity.middleName).toBe("M");
-  expect(cipher.identity.lastName).toBe("User");
-  expect(cipher.identity.licenseNumber).toBe("123456lkhj");
-  expect(cipher.identity.country).toBe("United States");
-
-  expect(cipher.fields.length).toBe(5);
-
-  expect(cipher.fields[0].name).toEqual("status");
-  expect(cipher.fields[0].value).toEqual("active");
-
-  expect(cipher.fields[1].name).toEqual("tags");
-  expect(cipher.fields[1].value).toEqual("someTag");
-
-  expect(cipher.fields[2].name).toEqual("idType");
-  expect(cipher.fields[2].value).toEqual("Tour Visa");
-
-  expect(cipher.fields[3].name).toEqual("idIssuanceDate");
-  expect(cipher.fields[3].value).toEqual("03/07/2022");
-
-  expect(cipher.fields[4].name).toEqual("idExpirationDate");
-  expect(cipher.fields[4].value).toEqual("03/07/2028");
-}
-
-describe("Myki CSV Importer", () => {
-  let importer: Importer;
-  beforeEach(() => {
-    importer = new Importer();
-  });
-
-  it("should parse userAccount records", async () => {
-    const result = await importer.parse(userAccountData);
-    expect(result != null).toBe(true);
-
-    const cipher = result.ciphers.shift();
-
-    expect(cipher.name).toEqual("PasswordNickname");
-    expect(cipher.login.username).toEqual("user.name@email.com");
-    expect(cipher.login.password).toEqual("abc123");
-    expect(cipher.login.totp).toEqual("someTOTPSeed");
-    expect(cipher.login.uris.length).toEqual(1);
-    const uriView = cipher.login.uris.shift();
-    expect(uriView.uri).toEqual("http://www.google.com");
-    expect(cipher.notes).toEqual("This is the additional information text.");
-
-    expect(cipher.fields.length).toBe(2);
-
-    expect(cipher.fields[0].name).toBe("status");
-    expect(cipher.fields[0].value).toBe("active");
-
-    expect(cipher.fields[1].name).toBe("tags");
-    expect(cipher.fields[1].value).toBe("someTag");
-  });
-
-  it("should parse userTwoFa records", async () => {
-    const result = await importer.parse(userTwoFaData);
-    expect(result != null).toBe(true);
-
-    const cipher = result.ciphers.shift();
-
-    expect(cipher.name).toEqual("2FA nickname");
-    expect(cipher.login.username).toBeNull();
-    expect(cipher.login.password).toBeNull();
-    expect(cipher.login.totp).toBe("someTOTPSeed");
-    expect(cipher.notes).toEqual("Additional information field content.");
-
-    expect(cipher.fields.length).toBe(2);
-
-    expect(cipher.fields[0].name).toBe("status");
-    expect(cipher.fields[0].value).toBe("active");
-
-    expect(cipher.fields[1].name).toBe("tags");
-    expect(cipher.fields[1].value).toBe("someTag");
-  });
-
-  it("should parse creditCard records", async () => {
-    const result = await importer.parse(userCreditCardData);
-
-    expect(result).not.toBeNull();
-    expect(result.success).toBe(true);
-    expect(result.ciphers.length).toBe(1);
-
-    const cipher = result.ciphers.shift();
-    expect(cipher.type).toBe(CipherType.Card);
-    expect(cipher.name).toBe("Visa test card");
-    expect(cipher.card.brand).toBe("Visa");
-    expect(cipher.card.cardholderName).toBe("Joe User");
-    expect(cipher.card.number).toBe("4111111111111111");
-    expect(cipher.card.code).toBe("222");
-    expect(cipher.card.expMonth).toBe("04");
-    expect(cipher.card.expYear).toBe("24");
-
-    expect(cipher.notes).toBe("This is the additional information field");
-
-    expect(cipher.fields.length).toBe(2);
-
-    expect(cipher.fields[0].name).toBe("status");
-    expect(cipher.fields[0].value).toBe("active");
-
-    expect(cipher.fields[1].name).toBe("tags");
-    expect(cipher.fields[1].value).toBe("someTag");
-  });
-
-  it("should parse identity records", async () => {
-    const result = await importer.parse(userIdentityData);
-
-    expect(result).not.toBeNull();
-    expect(result.success).toBe(true);
-
-    const cipher = result.ciphers.shift();
-    expect(cipher.type).toBe(CipherType.Identity);
-    expect(cipher.name).toBe("Joe User's nickname");
-    expect(cipher.identity.fullName).toBe("Mr Joe M User");
-    expect(cipher.identity.title).toBe("Mr");
-    expect(cipher.identity.firstName).toBe("Joe");
-    expect(cipher.identity.middleName).toBe("M");
-    expect(cipher.identity.lastName).toBe("User");
-    expect(cipher.identity.email).toBe("joe.user@email.com");
-
-    expect(cipher.identity.address1).toBe("1 Example House");
-    expect(cipher.identity.address2).toBe("Suite 300");
-
-    expect(cipher.identity.city).toBe("Portland");
-    expect(cipher.identity.postalCode).toBe("04101");
-    expect(cipher.identity.country).toBe("United States");
-
-    expect(cipher.fields.length).toBe(4);
-
-    expect(cipher.fields[0].name).toEqual("status");
-    expect(cipher.fields[0].value).toEqual("active");
-
-    expect(cipher.fields[1].name).toBe("tags");
-    expect(cipher.fields[1].value).toBe("someTag");
-
-    expect(cipher.fields[2].name).toEqual("gender");
-    expect(cipher.fields[2].value).toEqual("Male");
-
-    expect(cipher.fields[3].name).toEqual("number");
-    expect(cipher.fields[3].value).toEqual("2223334444");
-  });
-
-  it("should parse secureNote records", async () => {
-    const result = await importer.parse(userNoteData);
-
-    expect(result).not.toBeNull();
-    expect(result.success).toBe(true);
-    expect(result.ciphers.length).toBe(1);
-
-    const cipher = result.ciphers.shift();
-    expect(cipher.type).toBe(CipherType.SecureNote);
-    expect(cipher.name).toBe("The title of a secure note");
-    expect(cipher.notes).toBe("The content of a secure note. Lorem ipsum, etc.");
-
-    expect(cipher.fields.length).toBe(1);
-
-    expect(cipher.fields[0].name).toBe("status");
-    expect(cipher.fields[0].value).toBe("active");
-  });
-
-  it("should parse idCard records", async () => {
-    const result = await importer.parse(userIdCardData);
-
-    expect(result).not.toBeNull();
-    expect(result.success).toBe(true);
-
-    expect(result.ciphers.length).toBe(14);
-
-    // Driver's license
-    const cipher = result.ciphers.shift();
-    expectDriversLicense(cipher);
-
-    // Passport
-    const cipher2 = result.ciphers.shift();
-    expectPassport(cipher2);
-
-    // Social Security
-    const cipher3 = result.ciphers.shift();
-    expectSocialSecurity(cipher3);
-
-    // Id Card
-    const cipher4 = result.ciphers.shift();
-    expectIdCard(cipher4);
-
-    // Tax Number
-    const cipher5 = result.ciphers.shift();
-    expectTaxNumber(cipher5);
-
-    // Bank Account
-    const cipher6 = result.ciphers.shift();
-    expectBankAccount(cipher6);
-
-    // Insurance card
-    const cipher7 = result.ciphers.shift();
-    expectInsuranceCard(cipher7);
-
-    // Health card
-    const cipher8 = result.ciphers.shift();
-    expectHealthCard(cipher8);
-
-    // Membership card
-    const cipher9 = result.ciphers.shift();
-    expectMembershipCard(cipher9);
-
-    // Database card
-    const cipher10 = result.ciphers.shift();
-    expectDatabase(cipher10);
-
-    // Outdoor license
-    const cipher11 = result.ciphers.shift();
-    expectOutdoorLicense(cipher11);
-
-    // Reward program
-    const cipher12 = result.ciphers.shift();
-    expectRewardProgram(cipher12);
-
-    // Software license
-    const cipher13 = result.ciphers.shift();
-    expectSoftwareLicense(cipher13);
-
-    // Tour visa
-    const cipher14 = result.ciphers.shift();
-    expectTourVisa(cipher14);
-  });
-});

jslib/common/spec/importers/nordpassCsvImporter.spec.ts

@@ -1,181 +0,0 @@
-import { CipherType } from "jslib-common/enums/cipherType";
-import { SecureNoteType } from "jslib-common/enums/secureNoteType";
-import { NordPassCsvImporter as Importer } from "jslib-common/importers/nordpassCsvImporter";
-import { CipherView } from "jslib-common/models/view/cipherView";
-import { IdentityView } from "jslib-common/models/view/identityView";
-
-import { data as creditCardData } from "./testData/nordpassCsv/nordpass.card.csv";
-import { data as identityData } from "./testData/nordpassCsv/nordpass.identity.csv";
-import { data as loginData } from "./testData/nordpassCsv/nordpass.login.csv";
-import { data as secureNoteData } from "./testData/nordpassCsv/nordpass.secureNote.csv";
-
-const namesTestData = [
-  {
-    title: "Given #fullName should set firstName",
-    fullName: "MyFirstName",
-    expected: Object.assign(new IdentityView(), {
-      firstName: "MyFirstName",
-      middleName: null,
-      lastName: null,
-    }),
-  },
-  {
-    title: "Given #fullName should set first- and lastName",
-    fullName: "MyFirstName MyLastName",
-    expected: Object.assign(new IdentityView(), {
-      firstName: "MyFirstName",
-      middleName: null,
-      lastName: "MyLastName",
-    }),
-  },
-  {
-    title: "Given #fullName should set first-, middle and lastName",
-    fullName: "MyFirstName MyMiddleName MyLastName",
-    expected: Object.assign(new IdentityView(), {
-      firstName: "MyFirstName",
-      middleName: "MyMiddleName",
-      lastName: "MyLastName",
-    }),
-  },
-  {
-    title: "Given #fullName should set first-, middle and lastName with Jr",
-    fullName: "MyFirstName MyMiddleName MyLastName Jr",
-    expected: Object.assign(new IdentityView(), {
-      firstName: "MyFirstName",
-      middleName: "MyMiddleName",
-      lastName: "MyLastName Jr",
-    }),
-  },
-  {
-    title: "Given #fullName should set first-, middle and lastName with Jr and III",
-    fullName: "MyFirstName MyMiddleName MyLastName Jr III",
-    expected: Object.assign(new IdentityView(), {
-      firstName: "MyFirstName",
-      middleName: "MyMiddleName",
-      lastName: "MyLastName Jr III",
-    }),
-  },
-];
-
-function expectLogin(cipher: CipherView) {
-  expect(cipher.type).toBe(CipherType.Login);
-
-  expect(cipher.name).toBe("SomeVaultItemName");
-  expect(cipher.notes).toBe("Some note for the VaultItem");
-  expect(cipher.login.uri).toBe("https://example.com");
-  expect(cipher.login.username).toBe("hello@bitwarden.com");
-  expect(cipher.login.password).toBe("someStrongPassword");
-}
-
-function expectCreditCard(cipher: CipherView) {
-  expect(cipher.type).toBe(CipherType.Card);
-
-  expect(cipher.name).toBe("SomeVisa");
-  expect(cipher.card.brand).toBe("Visa");
-  expect(cipher.card.cardholderName).toBe("SomeHolder");
-  expect(cipher.card.number).toBe("4024007103939509");
-  expect(cipher.card.code).toBe("123");
-  expect(cipher.card.expMonth).toBe("1");
-  expect(cipher.card.expYear).toBe("22");
-}
-
-function expectIdentity(cipher: CipherView) {
-  expect(cipher.type).toBe(CipherType.Identity);
-
-  expect(cipher.name).toBe("SomeTitle");
-  expect(cipher.identity.fullName).toBe("MyFirstName MyMiddleName MyLastName");
-  expect(cipher.identity.firstName).toBe("MyFirstName");
-  expect(cipher.identity.middleName).toBe("MyMiddleName");
-  expect(cipher.identity.lastName).toBe("MyLastName");
-  expect(cipher.identity.email).toBe("hello@bitwarden.com");
-  expect(cipher.identity.phone).toBe("123456789");
-
-  expect(cipher.identity.address1).toBe("Test street 123");
-  expect(cipher.identity.address2).toBe("additional addressinfo");
-  expect(cipher.identity.postalCode).toBe("123456");
-  expect(cipher.identity.city).toBe("Cologne");
-  expect(cipher.identity.state).toBe("North-Rhine-Westphalia");
-  expect(cipher.identity.country).toBe("GERMANY");
-  expect(cipher.notes).toBe("SomeNoteToMyIdentity");
-}
-
-function expectSecureNote(cipher: CipherView) {
-  expect(cipher.type).toBe(CipherType.SecureNote);
-
-  expect(cipher.name).toBe("MySuperSecureNoteTitle");
-  expect(cipher.secureNote.type).toBe(SecureNoteType.Generic);
-  expect(cipher.notes).toBe("MySuperSecureNote");
-}
-
-describe("NordPass CSV Importer", () => {
-  let importer: Importer;
-  beforeEach(() => {
-    importer = new Importer();
-  });
-
-  it("should parse login records", async () => {
-    const result = await importer.parse(loginData);
-
-    expect(result).not.toBeNull();
-    expect(result.success).toBe(true);
-    expect(result.ciphers.length).toBe(1);
-    const cipher = result.ciphers[0];
-    expectLogin(cipher);
-  });
-
-  it("should parse credit card records", async () => {
-    const result = await importer.parse(creditCardData);
-
-    expect(result).not.toBeNull();
-    expect(result.success).toBe(true);
-    expect(result.ciphers.length).toBe(1);
-    const cipher = result.ciphers[0];
-    expectCreditCard(cipher);
-  });
-
-  it("should parse identity records", async () => {
-    const result = await importer.parse(
-      identityData.replace("#fullName", "MyFirstName MyMiddleName MyLastName")
-    );
-
-    expect(result).not.toBeNull();
-    expect(result.success).toBe(true);
-    expect(result.ciphers.length).toBe(1);
-    const cipher = result.ciphers[0];
-    expectIdentity(cipher);
-  });
-
-  namesTestData.forEach((data) => {
-    it(data.title.replace("#fullName", data.fullName), async () => {
-      const result = await importer.parse(identityData.replace("#fullName", data.fullName));
-
-      expect(result).not.toBeNull();
-      expect(result.success).toBe(true);
-      expect(result.ciphers.length).toBe(1);
-      const cipher = result.ciphers[0];
-      expect(cipher.identity.firstName).toBe(data.expected.firstName);
-      expect(cipher.identity.middleName).toBe(data.expected.middleName);
-      expect(cipher.identity.lastName).toBe(data.expected.lastName);
-    });
-  });
-
-  it("should parse secureNote records", async () => {
-    const result = await importer.parse(secureNoteData);
-
-    expect(result).not.toBeNull();
-    expect(result.success).toBe(true);
-    expect(result.ciphers.length).toBe(1);
-    const cipher = result.ciphers[0];
-    expectSecureNote(cipher);
-  });
-
-  it("should parse an item and create a folder", async () => {
-    const result = await importer.parse(secureNoteData);
-
-    expect(result).not.toBeNull();
-    expect(result.success).toBe(true);
-    expect(result.folders.length).toBe(1);
-    const folder = result.folders[0];
-    expect(folder.name).toBe("notesFolder");
-  });
-});

jslib/common/spec/importers/onepassword1PifImporter.spec.ts

@@ -1,527 +0,0 @@
-import { FieldType } from "jslib-common/enums/fieldType";
-import { OnePassword1PifImporter as Importer } from "jslib-common/importers/onepasswordImporters/onepassword1PifImporter";
-
-const TestData: string =
-  "***aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee***\n" +
-  JSON.stringify({
-    uuid: "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
-    updatedAt: 1486071244,
-    securityLevel: "SL5",
-    contentsHash: "aaaaaaaa",
-    title: "Imported Entry",
-    location: "https://www.google.com",
-    secureContents: {
-      fields: [
-        {
-          value: "user@test.net",
-          id: "email-input",
-          name: "email",
-          type: "T",
-          designation: "username",
-        },
-        {
-          value: "myservicepassword",
-          id: "password-input",
-          name: "password",
-          type: "P",
-          designation: "password",
-        },
-      ],
-      sections: [
-        {
-          fields: [
-            {
-              k: "concealed",
-              n: "AAAAAAAAAAAABBBBBBBBBBBCCCCCCCCC",
-              v: "console-password-123",
-              t: "console password",
-            },
-          ],
-          title: "Admin Console",
-          name: "admin_console",
-        },
-      ],
-      passwordHistory: [
-        {
-          value: "old-password",
-          time: 1447791421,
-        },
-      ],
-    },
-    URLs: [
-      {
-        label: "website",
-        url: "https://www.google.com",
-      },
-    ],
-    txTimestamp: 1508941334,
-    createdAt: 1390426636,
-    typeName: "webforms.WebForm",
-  });
-
-const WindowsOpVaultTestData = JSON.stringify({
-  category: "001",
-  created: 1544823719,
-  hmac: "NtyBmTTPOb88HV3JUKPx1xl/vcMhac9kvCfe/NtszY0=",
-  k: "**REMOVED LONG LINE FOR LINTER** -Kyle",
-  tx: 1553395669,
-  updated: 1553395669,
-  uuid: "528AB076FB5F4FBF960884B8E01619AC",
-  overview: {
-    title: "Google",
-    URLs: [
-      {
-        u: "google.com",
-      },
-    ],
-    url: "google.com",
-    ps: 26,
-    ainfo: "googluser",
-  },
-  details: {
-    passwordHistory: [
-      {
-        value: "oldpass1",
-        time: 1553394449,
-      },
-      {
-        value: "oldpass2",
-        time: 1553394457,
-      },
-      {
-        value: "oldpass3",
-        time: 1553394458,
-      },
-      {
-        value: "oldpass4",
-        time: 1553394459,
-      },
-      {
-        value: "oldpass5",
-        time: 1553394460,
-      },
-      {
-        value: "oldpass6",
-        time: 1553394461,
-      },
-    ],
-    fields: [
-      {
-        type: "T",
-        id: "username",
-        name: "username",
-        value: "googluser",
-        designation: "username",
-      },
-      {
-        type: "P",
-        id: "password",
-        name: "password",
-        value: "12345678901",
-        designation: "password",
-      },
-    ],
-    notesPlain: "This is a note\r\n\r\nline1\r\nline2",
-    sections: [
-      {
-        title: "test",
-        name: "1214FD88CD30405D9EED14BEB4D61B60",
-        fields: [
-          {
-            k: "string",
-            n: "6CC3BD77482D4559A4B8BB2D360F821B",
-            v: "fgfg",
-            t: "fgggf",
-          },
-          {
-            k: "concealed",
-            n: "5CFE7BCAA1DF4578BBF7EB508959BFF3",
-            v: "dfgdfgfdg",
-            t: "pwfield",
-          },
-        ],
-      },
-    ],
-  },
-});
-
-const IdentityTestData = JSON.stringify({
-  uuid: "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
-  updatedAt: 1553365894,
-  securityLevel: "SL5",
-  contentsHash: "eeeeeeee",
-  title: "Test Identity",
-  secureContents: {
-    lastname: "Fritzenberger",
-    zip: "223344",
-    birthdate_dd: "11",
-    homephone: "+49 333 222 111",
-    company: "Web Inc.",
-    firstname: "Frank",
-    birthdate_mm: "3",
-    country: "de",
-    sex: "male",
-    sections: [
-      {
-        fields: [
-          {
-            k: "string",
-            inputTraits: {
-              autocapitalization: "Words",
-            },
-            n: "firstname",
-            v: "Frank",
-            a: {
-              guarded: "yes",
-            },
-            t: "first name",
-          },
-          {
-            k: "string",
-            inputTraits: {
-              autocapitalization: "Words",
-            },
-            n: "initial",
-            v: "MD",
-            a: {
-              guarded: "yes",
-            },
-            t: "initial",
-          },
-          {
-            k: "string",
-            inputTraits: {
-              autocapitalization: "Words",
-            },
-            n: "lastname",
-            v: "Fritzenberger",
-            a: {
-              guarded: "yes",
-            },
-            t: "last name",
-          },
-          {
-            k: "menu",
-            v: "male",
-            n: "sex",
-            a: {
-              guarded: "yes",
-            },
-            t: "sex",
-          },
-          {
-            k: "date",
-            v: 1552305660,
-            n: "birthdate",
-            a: {
-              guarded: "yes",
-            },
-            t: "birth date",
-          },
-          {
-            k: "string",
-            inputTraits: {
-              autocapitalization: "Words",
-            },
-            n: "occupation",
-            v: "Engineer",
-            a: {
-              guarded: "yes",
-            },
-            t: "occupation",
-          },
-          {
-            k: "string",
-            inputTraits: {
-              autocapitalization: "Words",
-            },
-            n: "company",
-            v: "Web Inc.",
-            a: {
-              guarded: "yes",
-            },
-            t: "company",
-          },
-          {
-            k: "string",
-            inputTraits: {
-              autocapitalization: "Words",
-            },
-            n: "department",
-            v: "IT",
-            a: {
-              guarded: "yes",
-            },
-            t: "department",
-          },
-          {
-            k: "string",
-            inputTraits: {
-              autocapitalization: "Words",
-            },
-            n: "jobtitle",
-            v: "Developer",
-            a: {
-              guarded: "yes",
-            },
-            t: "job title",
-          },
-        ],
-        title: "Identification",
-        name: "name",
-      },
-      {
-        fields: [
-          {
-            k: "address",
-            inputTraits: {
-              autocapitalization: "Sentences",
-            },
-            n: "address",
-            v: {
-              street: "Mainstreet 1",
-              city: "Berlin",
-              country: "de",
-              zip: "223344",
-            },
-            a: {
-              guarded: "yes",
-            },
-            t: "address",
-          },
-          {
-            k: "phone",
-            v: "+49 001 222 333 44",
-            n: "defphone",
-            a: {
-              guarded: "yes",
-            },
-            t: "default phone",
-          },
-          {
-            k: "phone",
-            v: "+49 333 222 111",
-            n: "homephone",
-            a: {
-              guarded: "yes",
-            },
-            t: "home",
-          },
-          {
-            k: "phone",
-            n: "cellphone",
-            a: {
-              guarded: "yes",
-            },
-            t: "mobile",
-          },
-          {
-            k: "phone",
-            n: "busphone",
-            a: {
-              guarded: "yes",
-            },
-            t: "business",
-          },
-        ],
-        title: "Address",
-        name: "address",
-      },
-      {
-        fields: [
-          {
-            k: "string",
-            n: "username",
-            a: {
-              guarded: "yes",
-            },
-            t: "username",
-          },
-          {
-            k: "string",
-            n: "reminderq",
-            t: "reminder question",
-          },
-          {
-            k: "string",
-            n: "remindera",
-            t: "reminder answer",
-          },
-          {
-            k: "string",
-            inputTraits: {
-              keyboard: "EmailAddress",
-            },
-            n: "email",
-            v: "test@web.de",
-            a: {
-              guarded: "yes",
-            },
-            t: "email",
-          },
-          {
-            k: "string",
-            n: "website",
-            inputTraits: {
-              keyboard: "URL",
-            },
-            t: "website",
-          },
-          {
-            k: "string",
-            n: "icq",
-            t: "ICQ",
-          },
-          {
-            k: "string",
-            n: "skype",
-            t: "skype",
-          },
-          {
-            k: "string",
-            n: "aim",
-            t: "AOL/AIM",
-          },
-          {
-            k: "string",
-            n: "yahoo",
-            t: "Yahoo",
-          },
-          {
-            k: "string",
-            n: "msn",
-            t: "MSN",
-          },
-          {
-            k: "string",
-            n: "forumsig",
-            t: "forum signature",
-          },
-        ],
-        title: "Internet Details",
-        name: "internet",
-      },
-      {
-        title: "Related Items",
-        name: "linked items",
-      },
-    ],
-    initial: "MD",
-    address1: "Mainstreet 1",
-    city: "Berlin",
-    jobtitle: "Developer",
-    occupation: "Engineer",
-    department: "IT",
-    email: "test@web.de",
-    birthdate_yy: "2019",
-    homephone_local: "+49 333 222 111",
-    defphone_local: "+49 001 222 333 44",
-    defphone: "+49 001 222 333 44",
-  },
-  txTimestamp: 1553365894,
-  createdAt: 1553364679,
-  typeName: "identities.Identity",
-});
-
-describe("1Password 1Pif Importer", () => {
-  it("should parse data", async () => {
-    const importer = new Importer();
-    const result = await importer.parse(TestData);
-    expect(result != null).toBe(true);
-
-    const cipher = result.ciphers.shift();
-    expect(cipher.login.username).toEqual("user@test.net");
-    expect(cipher.login.password).toEqual("myservicepassword");
-    expect(cipher.login.uris.length).toEqual(1);
-    const uriView = cipher.login.uris.shift();
-    expect(uriView.uri).toEqual("https://www.google.com");
-  });
-
-  it('should create concealed field as "hidden" type', async () => {
-    const importer = new Importer();
-    const result = await importer.parse(TestData);
-    expect(result != null).toBe(true);
-
-    const ciphers = result.ciphers;
-    expect(ciphers.length).toEqual(1);
-
-    const cipher = ciphers.shift();
-    const fields = cipher.fields;
-    expect(fields.length).toEqual(1);
-
-    const field = fields.shift();
-    expect(field.name).toEqual("console password");
-    expect(field.value).toEqual("console-password-123");
-    expect(field.type).toEqual(FieldType.Hidden);
-  });
-
-  it("should create identity records", async () => {
-    const importer = new Importer();
-    const result = await importer.parse(IdentityTestData);
-    expect(result != null).toBe(true);
-    const cipher = result.ciphers.shift();
-    expect(cipher.name).toEqual("Test Identity");
-
-    const identity = cipher.identity;
-    expect(identity.firstName).toEqual("Frank");
-    expect(identity.middleName).toEqual("MD");
-    expect(identity.lastName).toEqual("Fritzenberger");
-    expect(identity.company).toEqual("Web Inc.");
-    expect(identity.address1).toEqual("Mainstreet 1");
-    expect(identity.country).toEqual("DE");
-    expect(identity.city).toEqual("Berlin");
-    expect(identity.postalCode).toEqual("223344");
-    expect(identity.phone).toEqual("+49 001 222 333 44");
-    expect(identity.email).toEqual("test@web.de");
-
-    // remaining fields as custom fields
-    expect(cipher.fields.length).toEqual(6);
-    const fields = cipher.fields;
-    expect(fields[0].name).toEqual("sex");
-    expect(fields[0].value).toEqual("male");
-    expect(fields[1].name).toEqual("birth date");
-    expect(fields[1].value).toEqual("Mon, 11 Mar 2019 12:01:00 GMT");
-    expect(fields[2].name).toEqual("occupation");
-    expect(fields[2].value).toEqual("Engineer");
-    expect(fields[3].name).toEqual("department");
-    expect(fields[3].value).toEqual("IT");
-    expect(fields[4].name).toEqual("job title");
-    expect(fields[4].value).toEqual("Developer");
-    expect(fields[5].name).toEqual("home");
-    expect(fields[5].value).toEqual("+49 333 222 111");
-  });
-
-  it("should create password history", async () => {
-    const importer = new Importer();
-    const result = await importer.parse(TestData);
-    const cipher = result.ciphers.shift();
-
-    expect(cipher.passwordHistory.length).toEqual(1);
-    const ph = cipher.passwordHistory.shift();
-    expect(ph.password).toEqual("old-password");
-    expect(ph.lastUsedDate.toISOString()).toEqual("2015-11-17T20:17:01.000Z");
-  });
-
-  it("should create password history from windows opvault 1pif format", async () => {
-    const importer = new Importer();
-    const result = await importer.parse(WindowsOpVaultTestData);
-    const cipher = result.ciphers.shift();
-
-    expect(cipher.passwordHistory.length).toEqual(5);
-    let ph = cipher.passwordHistory.shift();
-    expect(ph.password).toEqual("oldpass6");
-    expect(ph.lastUsedDate.toISOString()).toEqual("2019-03-24T02:27:41.000Z");
-    ph = cipher.passwordHistory.shift();
-    expect(ph.password).toEqual("oldpass5");
-    expect(ph.lastUsedDate.toISOString()).toEqual("2019-03-24T02:27:40.000Z");
-    ph = cipher.passwordHistory.shift();
-    expect(ph.password).toEqual("oldpass4");
-    expect(ph.lastUsedDate.toISOString()).toEqual("2019-03-24T02:27:39.000Z");
-    ph = cipher.passwordHistory.shift();
-    expect(ph.password).toEqual("oldpass3");
-    expect(ph.lastUsedDate.toISOString()).toEqual("2019-03-24T02:27:38.000Z");
-    ph = cipher.passwordHistory.shift();
-    expect(ph.password).toEqual("oldpass2");
-    expect(ph.lastUsedDate.toISOString()).toEqual("2019-03-24T02:27:37.000Z");
-  });
-});

jslib/common/spec/importers/onepassword1PuxImporter.spec.ts

@@ -1,689 +0,0 @@
-import { CipherType } from "jslib-common/enums/cipherType";
-import { FieldType } from "jslib-common/enums/fieldType";
-import { SecureNoteType } from "jslib-common/enums/secureNoteType";
-import { OnePassword1PuxImporter as Importer } from "jslib-common/importers/onepasswordImporters/onepassword1PuxImporter";
-import { Utils } from "jslib-common/misc/utils";
-import { FieldView } from "jslib-common/models/view/fieldView";
-
-import { APICredentialsData } from "./testData/onePassword1Pux/APICredentials";
-import { BankAccountData } from "./testData/onePassword1Pux/BankAccount";
-import { CreditCardData } from "./testData/onePassword1Pux/CreditCard";
-import { DatabaseData } from "./testData/onePassword1Pux/Database";
-import { DriversLicenseData } from "./testData/onePassword1Pux/DriversLicense";
-import { EmailAccountData } from "./testData/onePassword1Pux/EmailAccount";
-import { EmailFieldData } from "./testData/onePassword1Pux/Emailfield";
-import { EmailFieldOnIdentityData } from "./testData/onePassword1Pux/EmailfieldOnIdentity";
-import { EmailFieldOnIdentityPrefilledData } from "./testData/onePassword1Pux/EmailfieldOnIdentity_Prefilled";
-import { IdentityData } from "./testData/onePassword1Pux/IdentityData";
-import { LoginData } from "./testData/onePassword1Pux/LoginData";
-import { MedicalRecordData } from "./testData/onePassword1Pux/MedicalRecord";
-import { MembershipData } from "./testData/onePassword1Pux/Membership";
-import { OnePuxExampleFile } from "./testData/onePassword1Pux/Onepux_example";
-import { OutdoorLicenseData } from "./testData/onePassword1Pux/OutdoorLicense";
-import { PassportData } from "./testData/onePassword1Pux/Passport";
-import { PasswordData } from "./testData/onePassword1Pux/Password";
-import { RewardsProgramData } from "./testData/onePassword1Pux/RewardsProgram";
-import { SSNData } from "./testData/onePassword1Pux/SSN";
-import { SanitizedExport } from "./testData/onePassword1Pux/SanitizedExport";
-import { SecureNoteData } from "./testData/onePassword1Pux/SecureNote";
-import { ServerData } from "./testData/onePassword1Pux/Server";
-import { SoftwareLicenseData } from "./testData/onePassword1Pux/SoftwareLicense";
-import { WirelessRouterData } from "./testData/onePassword1Pux/WirelessRouter";
-
-function validateCustomField(fields: FieldView[], fieldName: string, expectedValue: any) {
-  expect(fields).toBeDefined();
-  const customField = fields.find((f) => f.name === fieldName);
-  expect(customField).toBeDefined();
-
-  expect(customField.value).toEqual(expectedValue);
-}
-
-describe("1Password 1Pux Importer", () => {
-  const OnePuxExampleFileJson = JSON.stringify(OnePuxExampleFile);
-  const LoginDataJson = JSON.stringify(LoginData);
-  const CreditCardDataJson = JSON.stringify(CreditCardData);
-  const IdentityDataJson = JSON.stringify(IdentityData);
-  const SecureNoteDataJson = JSON.stringify(SecureNoteData);
-  const SanitizedExportJson = JSON.stringify(SanitizedExport);
-
-  it("should parse login data", async () => {
-    const importer = new Importer();
-    const result = await importer.parse(LoginDataJson);
-    expect(result != null).toBe(true);
-
-    const cipher = result.ciphers.shift();
-
-    expect(cipher.type).toEqual(CipherType.Login);
-    expect(cipher.name).toEqual("eToro");
-
-    expect(cipher.login.username).toEqual("username123123123@gmail.com");
-    expect(cipher.login.password).toEqual("password!");
-    expect(cipher.login.uris.length).toEqual(1);
-    expect(cipher.login.uri).toEqual("https://www.fakesite.com");
-    expect(cipher.login.totp).toEqual("otpseed777");
-
-    // remaining fields as custom fields
-    expect(cipher.fields.length).toEqual(3);
-    validateCustomField(cipher.fields, "terms", "false");
-    validateCustomField(cipher.fields, "policies", "true");
-    validateCustomField(cipher.fields, "cyqyggt2otns6tbbqtsl6w2ceu", "username123123");
-  });
-
-  it("should parse notes", async () => {
-    const importer = new Importer();
-    const result = await importer.parse(OnePuxExampleFileJson);
-    expect(result != null).toBe(true);
-
-    const cipher = result.ciphers.shift();
-    expect(cipher.notes).toEqual("This is a note. *bold*! _italic_!");
-  });
-
-  it("should set favourite if favIndex equals 1", async () => {
-    const importer = new Importer();
-    const result = await importer.parse(OnePuxExampleFileJson);
-    expect(result != null).toBe(true);
-
-    const cipher = result.ciphers.shift();
-    expect(cipher.favorite).toBe(true);
-  });
-
-  it("should handle custom boolean fields", async () => {
-    const importer = new Importer();
-    const result = await importer.parse(LoginDataJson);
-    expect(result != null).toBe(true);
-
-    const ciphers = result.ciphers;
-    expect(ciphers.length).toEqual(1);
-
-    const cipher = ciphers.shift();
-    expect(cipher.fields[0].name).toEqual("terms");
-    expect(cipher.fields[0].value).toEqual("false");
-    expect(cipher.fields[0].type).toBe(FieldType.Boolean);
-
-    expect(cipher.fields[1].name).toEqual("policies");
-    expect(cipher.fields[1].value).toEqual("true");
-    expect(cipher.fields[1].type).toBe(FieldType.Boolean);
-  });
-
-  it("should add fields of type email as custom fields", async () => {
-    const importer = new Importer();
-    const EmailFieldDataJson = JSON.stringify(EmailFieldData);
-    const result = await importer.parse(EmailFieldDataJson);
-    expect(result != null).toBe(true);
-
-    const ciphers = result.ciphers;
-    expect(ciphers.length).toEqual(1);
-    const cipher = ciphers.shift();
-
-    expect(cipher.fields[0].name).toEqual("reg_email");
-    expect(cipher.fields[0].value).toEqual("kriddler@nullvalue.test");
-    expect(cipher.fields[0].type).toBe(FieldType.Text);
-
-    expect(cipher.fields[1].name).toEqual("provider");
-    expect(cipher.fields[1].value).toEqual("myEmailProvider");
-    expect(cipher.fields[1].type).toBe(FieldType.Text);
-  });
-
-  it('should create concealed field as "hidden" type', async () => {
-    const importer = new Importer();
-    const result = await importer.parse(OnePuxExampleFileJson);
-    expect(result != null).toBe(true);
-
-    const ciphers = result.ciphers;
-    expect(ciphers.length).toEqual(1);
-
-    const cipher = ciphers.shift();
-    const fields = cipher.fields;
-    expect(fields.length).toEqual(1);
-
-    const field = fields.shift();
-    expect(field.name).toEqual("PIN");
-    expect(field.value).toEqual("12345");
-    expect(field.type).toEqual(FieldType.Hidden);
-  });
-
-  it("should create password history", async () => {
-    const importer = new Importer();
-    const result = await importer.parse(OnePuxExampleFileJson);
-    const cipher = result.ciphers.shift();
-
-    expect(cipher.passwordHistory.length).toEqual(1);
-    const ph = cipher.passwordHistory.shift();
-    expect(ph.password).toEqual("12345password");
-    expect(ph.lastUsedDate.toISOString()).toEqual("2016-03-18T17:32:35.000Z");
-  });
-
-  it("should create credit card records", async () => {
-    const importer = new Importer();
-    const result = await importer.parse(CreditCardDataJson);
-    expect(result != null).toBe(true);
-    const cipher = result.ciphers.shift();
-    expect(cipher.name).toEqual("Parent's Credit Card");
-    expect(cipher.notes).toEqual("My parents' credit card.");
-
-    const card = cipher.card;
-    expect(card.cardholderName).toEqual("Fred Engels");
-    expect(card.number).toEqual("6011111111111117");
-    expect(card.code).toEqual("1312");
-    expect(card.brand).toEqual("Discover");
-    expect(card.expMonth).toEqual("12");
-    expect(card.expYear).toEqual("2099");
-
-    // remaining fields as custom fields
-    expect(cipher.fields.length).toEqual(12);
-    validateCustomField(cipher.fields, "txbzvwzpck7ejhfres3733rbpm", "card");
-    validateCustomField(cipher.fields, "cashLimit", "$500");
-    validateCustomField(cipher.fields, "creditLimit", "$1312");
-    validateCustomField(cipher.fields, "validFrom", "200101");
-    validateCustomField(cipher.fields, "bank", "Some bank");
-    validateCustomField(cipher.fields, "phoneLocal", "123456");
-    validateCustomField(cipher.fields, "phoneTollFree", "0800123456");
-    validateCustomField(cipher.fields, "phoneIntl", "+49123456");
-    validateCustomField(cipher.fields, "website", "somebank.com");
-    validateCustomField(cipher.fields, "pin", "1234");
-    validateCustomField(cipher.fields, "interest", "1%");
-    validateCustomField(cipher.fields, "issuenumber", "123456");
-  });
-
-  it("should create identity records", async () => {
-    const importer = new Importer();
-    const result = await importer.parse(IdentityDataJson);
-    expect(result != null).toBe(true);
-    const cipher = result.ciphers.shift();
-    expect(cipher.name).toEqual("George Engels");
-
-    const identity = cipher.identity;
-    expect(identity.firstName).toEqual("George");
-    expect(identity.middleName).toEqual("S");
-    expect(identity.lastName).toEqual("Engels");
-    expect(identity.company).toEqual("Acme Inc.");
-    expect(identity.address1).toEqual("1312 Main St.");
-    expect(identity.country).toEqual("US");
-    expect(identity.state).toEqual("California");
-    expect(identity.city).toEqual("Atlantis");
-    expect(identity.postalCode).toEqual("90210");
-    expect(identity.phone).toEqual("4565555555");
-    expect(identity.email).toEqual("gengels@nullvalue.test");
-    expect(identity.username).toEqual("gengels");
-
-    // remaining fields as custom fields
-    expect(cipher.fields.length).toEqual(17);
-    validateCustomField(cipher.fields, "sex", "male");
-    validateCustomField(cipher.fields, "birthdate", "Thu, 01 Jan 1981 12:01:00 GMT");
-    validateCustomField(cipher.fields, "occupation", "Steel Worker");
-    validateCustomField(cipher.fields, "department", "QA");
-    validateCustomField(cipher.fields, "jobtitle", "Quality Assurance Manager");
-    validateCustomField(cipher.fields, "homephone", "4575555555");
-    validateCustomField(cipher.fields, "cellphone", "4585555555");
-    validateCustomField(cipher.fields, "busphone", "4595555555");
-    validateCustomField(cipher.fields, "reminderq", "Who's a super cool guy?");
-    validateCustomField(cipher.fields, "remindera", "Me, buddy.");
-    validateCustomField(cipher.fields, "website", "cv.gengels.nullvalue.test");
-    validateCustomField(cipher.fields, "icq", "12345678");
-    validateCustomField(cipher.fields, "skype", "skypeisbad1619");
-    validateCustomField(cipher.fields, "aim", "aollol@lololol.aol.com");
-    validateCustomField(cipher.fields, "yahoo", "sk8rboi13@yah00.com");
-    validateCustomField(cipher.fields, "msn", "msnothankyou@msn&m&m.com");
-    validateCustomField(cipher.fields, "forumsig", "super cool guy");
-  });
-
-  it("emails fields on identity types should be added to the identity email field", async () => {
-    const importer = new Importer();
-    const EmailFieldOnIdentityDataJson = JSON.stringify(EmailFieldOnIdentityData);
-    const result = await importer.parse(EmailFieldOnIdentityDataJson);
-    expect(result != null).toBe(true);
-
-    const ciphers = result.ciphers;
-    expect(ciphers.length).toEqual(1);
-    const cipher = ciphers.shift();
-
-    const identity = cipher.identity;
-    expect(identity.email).toEqual("gengels@nullvalue.test");
-
-    expect(cipher.fields[0].name).toEqual("provider");
-    expect(cipher.fields[0].value).toEqual("myEmailProvider");
-    expect(cipher.fields[0].type).toBe(FieldType.Text);
-  });
-
-  it("emails fields on identity types should be added to custom fields if identity.email has been filled", async () => {
-    const importer = new Importer();
-    const EmailFieldOnIdentityPrefilledDataJson = JSON.stringify(EmailFieldOnIdentityPrefilledData);
-    const result = await importer.parse(EmailFieldOnIdentityPrefilledDataJson);
-    expect(result != null).toBe(true);
-
-    const ciphers = result.ciphers;
-    expect(ciphers.length).toEqual(1);
-    const cipher = ciphers.shift();
-
-    const identity = cipher.identity;
-    expect(identity.email).toEqual("gengels@nullvalue.test");
-
-    expect(cipher.fields[0].name).toEqual("2nd_email");
-    expect(cipher.fields[0].value).toEqual("kriddler@nullvalue.test");
-    expect(cipher.fields[0].type).toBe(FieldType.Text);
-
-    expect(cipher.fields[1].name).toEqual("provider");
-    expect(cipher.fields[1].value).toEqual("myEmailProvider");
-    expect(cipher.fields[1].type).toBe(FieldType.Text);
-  });
-
-  it("should parse category 005 - Password (Legacy)", async () => {
-    const importer = new Importer();
-    const jsonString = JSON.stringify(PasswordData);
-    const result = await importer.parse(jsonString);
-    expect(result != null).toBe(true);
-    const cipher = result.ciphers.shift();
-    expect(cipher.type).toEqual(CipherType.Login);
-    expect(cipher.name).toEqual("SuperSecret Password");
-    expect(cipher.notes).toEqual("SuperSecret Password Notes");
-
-    expect(cipher.login.password).toEqual("GBq[AGb]4*Si3tjwuab^");
-    expect(cipher.login.uri).toEqual("https://n0t.y0ur.n0rm4l.w3bs1t3");
-  });
-
-  it("should parse category 100 - SoftwareLicense", async () => {
-    const importer = new Importer();
-    const jsonString = JSON.stringify(SoftwareLicenseData);
-    const result = await importer.parse(jsonString);
-    expect(result != null).toBe(true);
-    const cipher = result.ciphers.shift();
-    expect(cipher.type).toEqual(CipherType.SecureNote);
-    expect(cipher.name).toEqual("Limux Product Key");
-    expect(cipher.notes).toEqual("My Software License");
-
-    expect(cipher.fields.length).toEqual(13);
-    validateCustomField(cipher.fields, "product_version", "5.10.1000");
-    validateCustomField(cipher.fields, "reg_code", "265453-13457355-847327");
-    validateCustomField(cipher.fields, "reg_name", "Kay Riddler");
-    validateCustomField(cipher.fields, "reg_email", "kriddler@nullvalue.test");
-    validateCustomField(cipher.fields, "company", "Riddles and Jigsaw Puzzles GmbH");
-    validateCustomField(
-      cipher.fields,
-      "download_link",
-      "https://limuxcompany.nullvalue.test/5.10.1000/isos"
-    );
-    validateCustomField(cipher.fields, "publisher_name", "Limux Software and Hardware");
-    validateCustomField(cipher.fields, "publisher_website", "https://limuxcompany.nullvalue.test/");
-    validateCustomField(cipher.fields, "retail_price", "$999");
-    validateCustomField(cipher.fields, "support_email", "support@nullvalue.test");
-    validateCustomField(cipher.fields, "order_date", "Thu, 01 Apr 2021 12:01:00 GMT");
-    validateCustomField(cipher.fields, "order_number", "594839");
-    validateCustomField(cipher.fields, "order_total", "$1086.59");
-  });
-
-  it("should parse category 101 - BankAccount", async () => {
-    const importer = new Importer();
-    const jsonString = JSON.stringify(BankAccountData);
-    const result = await importer.parse(jsonString);
-    expect(result != null).toBe(true);
-    const cipher = result.ciphers.shift();
-    expect(cipher.type).toEqual(CipherType.Card);
-    expect(cipher.name).toEqual("Bank Account");
-    expect(cipher.notes).toEqual("My Bank Account");
-
-    expect(cipher.card.cardholderName).toEqual("Cool Guy");
-
-    expect(cipher.fields.length).toEqual(9);
-    validateCustomField(cipher.fields, "bankName", "Super Credit Union");
-    validateCustomField(cipher.fields, "accountType", "checking");
-    validateCustomField(cipher.fields, "routingNo", "111000999");
-    validateCustomField(cipher.fields, "accountNo", "192837465918273645");
-    validateCustomField(cipher.fields, "swift", "123456");
-    validateCustomField(cipher.fields, "iban", "DE12 123456");
-    validateCustomField(cipher.fields, "telephonePin", "5555");
-    validateCustomField(cipher.fields, "branchPhone", "9399399933");
-    validateCustomField(cipher.fields, "branchAddress", "1 Fifth Avenue");
-  });
-
-  it("should parse category 102 - Database", async () => {
-    const importer = new Importer();
-    const jsonString = JSON.stringify(DatabaseData);
-    const result = await importer.parse(jsonString);
-    expect(result != null).toBe(true);
-    const cipher = result.ciphers.shift();
-
-    expect(cipher.type).toEqual(CipherType.Login);
-    expect(cipher.name).toEqual("Database");
-    expect(cipher.notes).toEqual("My Database");
-
-    const login = cipher.login;
-    expect(login.username).toEqual("cooldbuser");
-    expect(login.password).toEqual("^+kTjhLaN7wVPAhGU)*J");
-
-    expect(cipher.fields.length).toEqual(7);
-    validateCustomField(cipher.fields, "database_type", "postgresql");
-    validateCustomField(cipher.fields, "hostname", "my.secret.db.server");
-    validateCustomField(cipher.fields, "port", "1337");
-    validateCustomField(cipher.fields, "database", "user_database");
-    validateCustomField(cipher.fields, "sid", "ASDIUFU-283234");
-    validateCustomField(cipher.fields, "alias", "cdbu");
-    validateCustomField(cipher.fields, "options", "ssh");
-  });
-
-  it("should parse category 103 - Drivers license", async () => {
-    const importer = new Importer();
-    const jsonString = JSON.stringify(DriversLicenseData);
-    const result = await importer.parse(jsonString);
-    expect(result != null).toBe(true);
-    const cipher = result.ciphers.shift();
-    expect(cipher.name).toEqual("Michael Scarn");
-    expect(cipher.subTitle).toEqual("Michael Scarn");
-    expect(cipher.notes).toEqual("My Driver's License");
-
-    const identity = cipher.identity;
-    expect(identity.firstName).toEqual("Michael");
-    expect(identity.middleName).toBeNull();
-    expect(identity.lastName).toEqual("Scarn");
-    expect(identity.address1).toEqual("2120 Mifflin Rd.");
-    expect(identity.state).toEqual("Pennsylvania");
-    expect(identity.country).toEqual("United States");
-    expect(identity.licenseNumber).toEqual("12345678901");
-
-    expect(cipher.fields.length).toEqual(6);
-    validateCustomField(cipher.fields, "birthdate", "Sun, 01 Jan 1978 12:01:00 GMT");
-    validateCustomField(cipher.fields, "sex", "male");
-    validateCustomField(cipher.fields, "height", "5'11\"");
-    validateCustomField(cipher.fields, "class", "C");
-    validateCustomField(cipher.fields, "conditions", "B");
-    validateCustomField(cipher.fields, "expiry_date", "203012");
-  });
-
-  it("should parse category 104 - Outdoor License", async () => {
-    const importer = new Importer();
-    const jsonString = JSON.stringify(OutdoorLicenseData);
-    const result = await importer.parse(jsonString);
-    expect(result != null).toBe(true);
-    const cipher = result.ciphers.shift();
-
-    expect(cipher.type).toEqual(CipherType.Identity);
-    expect(cipher.name).toEqual("Harvest License");
-    expect(cipher.subTitle).toEqual("Cash Bandit");
-    expect(cipher.notes).toEqual("My Outdoor License");
-
-    const identity = cipher.identity;
-    expect(identity.firstName).toEqual("Cash");
-    expect(identity.middleName).toBeNull();
-    expect(identity.lastName).toEqual("Bandit");
-    expect(identity.state).toEqual("Washington");
-    expect(identity.country).toEqual("United States of America");
-
-    expect(cipher.fields.length).toEqual(4);
-    validateCustomField(cipher.fields, "valid_from", "Thu, 01 Apr 2021 12:01:00 GMT");
-    validateCustomField(cipher.fields, "expires", "Fri, 01 Apr 2044 12:01:00 GMT");
-    validateCustomField(cipher.fields, "game", "Bananas,blueberries,corn");
-    validateCustomField(cipher.fields, "quota", "100/each");
-  });
-
-  it("should parse category 105 - Membership", async () => {
-    const importer = new Importer();
-    const jsonString = JSON.stringify(MembershipData);
-    const result = await importer.parse(jsonString);
-    expect(result != null).toBe(true);
-    const cipher = result.ciphers.shift();
-
-    expect(cipher.type).toEqual(CipherType.Identity);
-    expect(cipher.name).toEqual("Library Card");
-
-    const identity = cipher.identity;
-    expect(identity.firstName).toEqual("George");
-    expect(identity.middleName).toBeNull();
-    expect(identity.lastName).toEqual("Engels");
-    expect(identity.company).toEqual("National Public Library");
-    expect(identity.phone).toEqual("9995555555");
-
-    expect(cipher.fields.length).toEqual(5);
-    validateCustomField(cipher.fields, "website", "https://npl.nullvalue.gov.test");
-    validateCustomField(cipher.fields, "member_since", "199901");
-    validateCustomField(cipher.fields, "expiry_date", "203412");
-    validateCustomField(cipher.fields, "membership_no", "64783862");
-    validateCustomField(cipher.fields, "pin", "19191");
-  });
-
-  it("should parse category 106 - Passport", async () => {
-    const importer = new Importer();
-    const jsonString = JSON.stringify(PassportData);
-    const result = await importer.parse(jsonString);
-    expect(result != null).toBe(true);
-    const cipher = result.ciphers.shift();
-
-    expect(cipher.type).toEqual(CipherType.Identity);
-    expect(cipher.name).toEqual("Mr. Globewide");
-
-    const identity = cipher.identity;
-    expect(identity.firstName).toEqual("David");
-    expect(identity.middleName).toBeNull();
-    expect(identity.lastName).toEqual("Global");
-    expect(identity.passportNumber).toEqual("76436847");
-
-    expect(cipher.fields.length).toEqual(8);
-    validateCustomField(cipher.fields, "type", "US Passport");
-    validateCustomField(cipher.fields, "sex", "female");
-    validateCustomField(cipher.fields, "nationality", "International");
-    validateCustomField(cipher.fields, "issuing_authority", "Department of State");
-    validateCustomField(cipher.fields, "birthdate", "Fri, 01 Apr 1983 12:01:00 GMT");
-    validateCustomField(cipher.fields, "birthplace", "A cave somewhere in Maine");
-    validateCustomField(cipher.fields, "issue_date", "Wed, 01 Jan 2020 12:01:00 GMT");
-    validateCustomField(cipher.fields, "expiry_date", "Sat, 01 Jan 2050 12:01:00 GMT");
-  });
-
-  it("should parse category 107 - RewardsProgram", async () => {
-    const importer = new Importer();
-    const jsonString = JSON.stringify(RewardsProgramData);
-    const result = await importer.parse(jsonString);
-    expect(result != null).toBe(true);
-    const cipher = result.ciphers.shift();
-
-    expect(cipher.type).toEqual(CipherType.Identity);
-    expect(cipher.name).toEqual("Retail Reward Thing");
-
-    const identity = cipher.identity;
-    expect(identity.firstName).toEqual("Chef");
-    expect(identity.middleName).toBeNull();
-    expect(identity.lastName).toEqual("Coldroom");
-    expect(identity.company).toEqual("Super Cool Store Co.");
-
-    expect(cipher.fields.length).toEqual(7);
-    validateCustomField(cipher.fields, "membership_no", "member-29813569");
-    validateCustomField(cipher.fields, "pin", "99913");
-    validateCustomField(cipher.fields, "additional_no", "additional member id");
-    validateCustomField(cipher.fields, "member_since", "202101");
-    validateCustomField(cipher.fields, "customer_service_phone", "123456");
-    validateCustomField(cipher.fields, "reservations_phone", "123456");
-    validateCustomField(cipher.fields, "website", "supercoolstore.com");
-  });
-
-  it("should parse category 108 - SSN", async () => {
-    const importer = new Importer();
-    const jsonString = JSON.stringify(SSNData);
-    const result = await importer.parse(jsonString);
-    expect(result != null).toBe(true);
-    const cipher = result.ciphers.shift();
-    expect(cipher.name).toEqual("SSN");
-
-    const identity = cipher.identity;
-    expect(identity.firstName).toEqual("Jack");
-    expect(identity.middleName).toBeNull();
-    expect(identity.lastName).toEqual("Judd");
-    expect(identity.ssn).toEqual("131-216-1900");
-  });
-
-  it("should parse category 109 - WirelessRouter", async () => {
-    const importer = new Importer();
-    const jsonString = JSON.stringify(WirelessRouterData);
-    const result = await importer.parse(jsonString);
-    expect(result != null).toBe(true);
-    const cipher = result.ciphers.shift();
-
-    expect(cipher.type).toEqual(CipherType.Login);
-    expect(cipher.name).toEqual("Wireless Router");
-    expect(cipher.notes).toEqual("My Wifi Router Config");
-
-    expect(cipher.login.password).toEqual("BqatGTVQ9TCN72tLbjrsHqkb");
-
-    expect(cipher.fields.length).toEqual(7);
-    validateCustomField(cipher.fields, "name", "pixel 2Xl");
-    validateCustomField(cipher.fields, "server", "127.0.0.1");
-    validateCustomField(cipher.fields, "airport_id", "some airportId");
-    validateCustomField(cipher.fields, "network_name", "some network name");
-    validateCustomField(cipher.fields, "wireless_security", "WPA");
-    validateCustomField(cipher.fields, "wireless_password", "wifipassword");
-    validateCustomField(cipher.fields, "disk_password", "diskpassword");
-  });
-
-  it("should parse category 110 - Server", async () => {
-    const importer = new Importer();
-    const jsonString = JSON.stringify(ServerData);
-    const result = await importer.parse(jsonString);
-    expect(result != null).toBe(true);
-    const cipher = result.ciphers.shift();
-
-    expect(cipher.type).toEqual(CipherType.Login);
-    expect(cipher.name).toEqual("Super Cool Server");
-    expect(cipher.notes).toEqual("My Server");
-
-    expect(cipher.login.username).toEqual("frankly-notsure");
-    expect(cipher.login.password).toEqual("*&YHJI87yjy78u");
-    expect(cipher.login.uri).toEqual("https://coolserver.nullvalue.test");
-
-    expect(cipher.fields.length).toEqual(7);
-    validateCustomField(
-      cipher.fields,
-      "admin_console_url",
-      "https://coolserver.nullvalue.test/admin"
-    );
-    validateCustomField(cipher.fields, "admin_console_username", "frankly-idontknowwhatimdoing");
-    validateCustomField(cipher.fields, "admin_console_password", "^%RY&^YUiju8iUYHJI(U");
-    validateCustomField(cipher.fields, "name", "Private Hosting Provider Inc.");
-    validateCustomField(cipher.fields, "website", "https://phpi.nullvalue.test");
-    validateCustomField(
-      cipher.fields,
-      "support_contact_url",
-      "https://phpi.nullvalue.test/support"
-    );
-    validateCustomField(cipher.fields, "support_contact_phone", "8882569382");
-  });
-
-  it("should parse category 111 - EmailAccount", async () => {
-    const importer = new Importer();
-    const jsonString = JSON.stringify(EmailAccountData);
-    const result = await importer.parse(jsonString);
-    expect(result != null).toBe(true);
-    const cipher = result.ciphers.shift();
-
-    expect(cipher.type).toEqual(CipherType.SecureNote);
-    expect(cipher.name).toEqual("Email Config");
-    expect(cipher.notes).toEqual("My Email Config");
-
-    expect(cipher.fields.length).toEqual(17);
-    validateCustomField(cipher.fields, "pop_type", "either");
-    validateCustomField(cipher.fields, "pop_username", "someuser@nullvalue.test");
-    validateCustomField(cipher.fields, "pop_server", "mailserver.nullvalue.test");
-    validateCustomField(cipher.fields, "pop_port", "587");
-    validateCustomField(cipher.fields, "pop_password", "u1jsf<UI*&YU&^T");
-    validateCustomField(cipher.fields, "pop_security", "TLS");
-    validateCustomField(cipher.fields, "pop_authentication", "kerberos_v5");
-    validateCustomField(cipher.fields, "smtp_server", "mailserver.nullvalue.test");
-    validateCustomField(cipher.fields, "smtp_port", "589");
-    validateCustomField(cipher.fields, "smtp_username", "someuser@nullvalue.test");
-    validateCustomField(cipher.fields, "smtp_password", "(*1674%^UIUJ*UI(IUI8u98uyy");
-    validateCustomField(cipher.fields, "smtp_security", "TLS");
-    validateCustomField(cipher.fields, "smtp_authentication", "password");
-    validateCustomField(cipher.fields, "provider", "Telum");
-    validateCustomField(cipher.fields, "provider_website", "https://telum.nullvalue.test");
-    validateCustomField(cipher.fields, "phone_local", "2346666666");
-    validateCustomField(cipher.fields, "phone_tollfree", "18005557777");
-  });
-
-  it("should parse category 112 - API Credentials", async () => {
-    const importer = new Importer();
-    const jsonString = JSON.stringify(APICredentialsData);
-    const result = await importer.parse(jsonString);
-    expect(result != null).toBe(true);
-    const cipher = result.ciphers.shift();
-
-    expect(cipher.type).toEqual(CipherType.Login);
-    expect(cipher.name).toEqual("API Credential");
-    expect(cipher.notes).toEqual("My API Credential");
-
-    expect(cipher.login.username).toEqual("apiuser@nullvalue.test");
-    expect(cipher.login.password).toEqual("apiapiapiapiapiapiappy");
-    expect(cipher.login.uri).toEqual("http://not.your.everyday.hostname");
-
-    expect(cipher.fields.length).toEqual(4);
-    validateCustomField(cipher.fields, "type", "jwt");
-    validateCustomField(cipher.fields, "filename", "filename.jwt");
-    validateCustomField(cipher.fields, "validFrom", "Mon, 04 Apr 2011 12:01:00 GMT");
-    validateCustomField(cipher.fields, "expires", "Tue, 01 Apr 2031 12:01:00 GMT");
-  });
-
-  it("should create secure notes", async () => {
-    const importer = new Importer();
-    const result = await importer.parse(SecureNoteDataJson);
-    expect(result != null).toBe(true);
-    const cipher = result.ciphers.shift();
-
-    expect(cipher.name).toEqual("Secure Note #1");
-    expect(cipher.notes).toEqual(
-      "This is my secure note. \n\nLorem ipsum expecto patronum. \nThe quick brown fox jumped over the lazy dog."
-    );
-    expect(cipher.secureNote.type).toEqual(SecureNoteType.Generic);
-  });
-
-  it("should parse category 113 - Medical Record", async () => {
-    const importer = new Importer();
-    const jsonString = JSON.stringify(MedicalRecordData);
-    const result = await importer.parse(jsonString);
-    expect(result != null).toBe(true);
-    const cipher = result.ciphers.shift();
-    expect(cipher.type).toEqual(CipherType.SecureNote);
-    expect(cipher.name).toEqual("Some Health Record");
-    expect(cipher.notes).toEqual("Some notes about my medical history");
-    expect(cipher.secureNote.type).toEqual(SecureNoteType.Generic);
-
-    expect(cipher.fields.length).toEqual(8);
-    validateCustomField(cipher.fields, "date", "Sat, 01 Jan 2022 12:01:00 GMT");
-    validateCustomField(cipher.fields, "location", "some hospital/clinic");
-    validateCustomField(cipher.fields, "healthcareprofessional", "Some Doctor");
-    validateCustomField(cipher.fields, "patient", "Me");
-    validateCustomField(cipher.fields, "reason", "unwell");
-    validateCustomField(cipher.fields, "medication", "Insuline");
-    validateCustomField(cipher.fields, "dosage", "1");
-    validateCustomField(cipher.fields, "notes", "multiple times a day");
-  });
-
-  it("should create folders", async () => {
-    const importer = new Importer();
-    const result = await importer.parse(SanitizedExportJson);
-    expect(result != null).toBe(true);
-
-    const folders = result.folders;
-    expect(folders.length).toBe(5);
-    expect(folders[0].name).toBe("Movies");
-    expect(folders[1].name).toBe("Finance");
-    expect(folders[2].name).toBe("Travel");
-    expect(folders[3].name).toBe("Education");
-    expect(folders[4].name).toBe("Starter Kit");
-
-    // Check that ciphers have a folder assigned to them
-    expect(result.ciphers.filter((c) => c.folderId === folders[0].id).length).toBeGreaterThan(0);
-    expect(result.ciphers.filter((c) => c.folderId === folders[1].id).length).toBeGreaterThan(0);
-    expect(result.ciphers.filter((c) => c.folderId === folders[2].id).length).toBeGreaterThan(0);
-    expect(result.ciphers.filter((c) => c.folderId === folders[3].id).length).toBeGreaterThan(0);
-    expect(result.ciphers.filter((c) => c.folderId === folders[4].id).length).toBeGreaterThan(0);
-  });
-
-  it("should create collections if part of an organization", async () => {
-    const importer = new Importer();
-    importer.organizationId = Utils.newGuid();
-    const result = await importer.parse(SanitizedExportJson);
-    expect(result != null).toBe(true);
-
-    const collections = result.collections;
-    expect(collections.length).toBe(5);
-    expect(collections[0].name).toBe("Movies");
-    expect(collections[1].name).toBe("Finance");
-    expect(collections[2].name).toBe("Travel");
-    expect(collections[3].name).toBe("Education");
-    expect(collections[4].name).toBe("Starter Kit");
-  });
-});