plugin settings

# Conflicts:
#	app/scripts/comp/launcher/launcher-electron.js

.babelrc

@@ -0,0 +1,20 @@
+{
+    "presets": [
+        ["@babel/typescript", { "jsxPragma": "h" }]
+    ],
+    "plugins": [
+        ["@babel/transform-react-jsx", {
+            "runtime": "automatic",
+            "importSource": "preact"
+        }],
+        ["@babel/plugin-proposal-class-properties", { "loose": true }],
+        ["@babel/plugin-proposal-object-rest-spread", { "loose": true,
+            "useBuiltIns": true
+        }],
+        "@babel/plugin-proposal-optional-catch-binding",
+        "@babel/plugin-proposal-optional-chaining",
+        "@babel/plugin-proposal-nullish-coalescing-operator",
+        "@babel/plugin-proposal-logical-assignment-operators",
+        "@babel/plugin-external-helpers"
+    ]
+}

.editorconfig

@@ -10,17 +10,10 @@ insert_final_newline = true
 charset = utf-8
 indent_style = space
 indent_size = 4
-charset = utf-8
 trim_trailing_whitespace = true
 
 [*.md]
 trim_trailing_whitespace = false
 
-[*.json]
-indent_size = 2
-
-[.jshintrc]
-indent_size = 2
-
-[*.scss]
+[{*.nsh,*.yml,*.yaml,*.json}]
 indent_size = 2

.eslintrc.json

@@ -0,0 +1,243 @@
+{
+  "plugins": [
+    "prettier",
+    "import",
+    "babel",
+    "react",
+    "@typescript-eslint"
+  ],
+  "extends": [
+    "standard",
+    "eslint:recommended",
+    "plugin:prettier/recommended"
+  ],
+  "rules": {
+    "semi": [
+      "error",
+      "always"
+    ],
+    "one-var": "off",
+    "space-before-function-paren": "off",
+    "no-throw-literal": "off",
+    "camelcase": [
+      "error",
+      {
+        "properties": "always"
+      }
+    ],
+    "no-console": "error",
+    "no-alert": "error",
+    "no-debugger": "error",
+    "prefer-arrow-callback": "error",
+    "object-property-newline": "off",
+    "no-useless-escape": "off",
+    "no-var": "error",
+    "prefer-const": "error",
+    "no-unused-expressions": "off",
+    "strict": [
+      "error",
+      "never"
+    ],
+    "no-mixed-operators": "off",
+    "prefer-promise-reject-errors": "off",
+    "standard/no-callback-literal": "off",
+    "object-curly-spacing": "off",
+    "quote-props": "off",
+    "no-new-object": "error",
+    "object-shorthand": "error",
+    "no-array-constructor": "error",
+    "array-callback-return": "error",
+    "no-eval": "error",
+    "no-new-func": "error",
+    "prefer-rest-params": "error",
+    "prefer-spread": "error",
+    "no-useless-constructor": "error",
+    "no-dupe-class-members": "error",
+    "no-duplicate-imports": "error",
+    "eqeqeq": "error",
+    "no-unneeded-ternary": "error",
+    "curly": "error",
+    "prettier/prettier": "error",
+    "no-empty": "off",
+    "no-restricted-syntax": [
+      "error",
+      {
+        "selector": "ExportDefaultDeclaration",
+        "message": "Prefer named exports"
+      }
+    ],
+    "import/no-webpack-loader-syntax": "off",
+    "import/no-relative-parent-imports": "error",
+    "import/first": "error",
+    "import/no-default-export": "error",
+    "babel/no-unused-expressions": "error",
+    "node/no-callback-literal": "off"
+  },
+  "parserOptions": {
+    "sourceType": "module",
+    "ecmaFeatures": {
+      "impliedStrict": true
+    }
+  },
+  "parser": "babel-eslint",
+  "overrides": [
+    {
+      "files": [
+        "*.ts",
+        "*.tsx"
+      ],
+      "extends": [
+        "standard",
+        "eslint:recommended",
+        "preact",
+        "plugin:prettier/recommended",
+        "plugin:@typescript-eslint/recommended",
+        "plugin:@typescript-eslint/recommended-requiring-type-checking",
+        "plugin:import/typescript"
+      ],
+      "rules": {
+        "semi": [
+          "error",
+          "always"
+        ],
+        "one-var": "off",
+        "space-before-function-paren": "off",
+        "no-throw-literal": "error",
+        "camelcase": [
+          "error",
+          {
+            "properties": "always"
+          }
+        ],
+        "no-console": "error",
+        "no-alert": "error",
+        "no-debugger": "error",
+        "prefer-arrow-callback": "error",
+        "object-property-newline": "off",
+        "no-useless-escape": "off",
+        "no-var": "error",
+        "prefer-const": "error",
+        "no-unused-expressions": "off",
+        "strict": [
+          "error",
+          "never"
+        ],
+        "no-mixed-operators": "off",
+        "prefer-promise-reject-errors": "off",
+        "standard/no-callback-literal": "off",
+        "object-curly-spacing": "off",
+        "quote-props": "off",
+        "no-new-object": "error",
+        "object-shorthand": "error",
+        "no-array-constructor": "error",
+        "array-callback-return": "error",
+        "no-eval": "error",
+        "no-new-func": "error",
+        "prefer-rest-params": "error",
+        "prefer-spread": "error",
+        "no-useless-constructor": "error",
+        "no-dupe-class-members": "off",
+        "no-duplicate-imports": "error",
+        "eqeqeq": "error",
+        "no-unneeded-ternary": "error",
+        "curly": "error",
+        "prettier/prettier": "error",
+        "no-empty": "off",
+        "no-restricted-syntax": [
+          "error",
+          {
+            "selector": "ExportDefaultDeclaration",
+            "message": "Prefer named exports"
+          }
+        ],
+        "import/no-webpack-loader-syntax": "off",
+        "import/no-relative-parent-imports": "error",
+        "import/first": "error",
+        "import/no-default-export": "error",
+        "babel/no-unused-expressions": "error",
+        "node/no-callback-literal": "off",
+        "import/no-commonjs": "off",
+        "prefer-template": "off",
+        "no-else-return": "off",
+        "jest/valid-expect": "off",
+        "jest/expect-expect": "off",
+        "react-hooks/exhaustive-deps": "off",
+        "@typescript-eslint/no-explicit-any": "error",
+        "@typescript-eslint/no-unused-vars": "error",
+        "@typescript-eslint/explicit-module-boundary-types": "error",
+        "@typescript-eslint/no-non-null-assertion": "error",
+        "@typescript-eslint/no-var-requires": "off",
+        "@typescript-eslint/naming-convention": [
+          "error",
+          {
+            "selector": ["objectLiteralProperty", "classProperty", "typeProperty"],
+            "modifiers": ["private", "protected"],
+            "format": ["camelCase"],
+            "leadingUnderscore": "require",
+            "trailingUnderscore": "forbid"
+          },
+          {
+            "selector": ["classProperty", "typeProperty"],
+            "modifiers": ["public"],
+            "format": ["camelCase", "PascalCase", "UPPER_CASE", "snake_case"],
+            "leadingUnderscore": "forbid",
+            "trailingUnderscore": "forbid"
+          },
+          {
+            "selector": ["method"],
+            "format": ["camelCase"],
+            "leadingUnderscore": "forbid",
+            "trailingUnderscore": "forbid"
+          },
+          {
+            "selector": ["class", "enum"],
+            "format": ["PascalCase"],
+            "leadingUnderscore": "forbid",
+            "trailingUnderscore": "forbid"
+          },
+          {
+            "selector": ["enumMember"],
+            "format": ["PascalCase", "UPPER_CASE"],
+            "leadingUnderscore": "forbid",
+            "trailingUnderscore": "forbid"
+          },
+          {
+            "selector": ["variable"],
+            "format": ["camelCase", "PascalCase", "UPPER_CASE"],
+            "leadingUnderscore": "forbid",
+            "trailingUnderscore": "forbid"
+          }
+        ]
+      },
+      "parser": "@typescript-eslint/parser",
+      "parserOptions": {
+        "ecmaFeatures": {
+          "jsx": true
+        },
+        "ecmaVersion": 11,
+        "sourceType": "module",
+        "project": [
+          "tsconfig.json",
+          "jsconfig.json"
+        ]
+      }
+    }
+  ],
+  "settings": {
+    "import/parsers": {
+      "@typescript-eslint/parser": [
+        ".ts",
+        ".tsx"
+      ]
+    }
+  },
+  "globals": {
+    "_": true,
+    "$": true
+  },
+  "env": {
+    "browser": true,
+    "node": true,
+    "es2020": true
+  }
+}

.github/CODE_OF_CONDUCT.md

@@ -0,0 +1,46 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at antelle.net@gmail.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

.github/FUNDING.yml

@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: [keeweb, antelle]
+patreon: # Replace with a single Patreon username
+open_collective: keeweb
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # for example PayPal links

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,34 @@
+---
+name: Bug report
+about: Create a report to help us improve KeeWeb
+title: ''
+labels: 'bug'
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Environment**
+Please copy all version information from Settings/Help
+
+**Kdbx File**
+Does it happen on Demo or New database?  
+If you have a test db without your personal data, please attach it.
+
+**Logs**
+Please open dev tools in your browser and attach output log from Console tab. If you are using a desktop app, devtools can be opened from Settings/General/Advanced.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: true

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: 'enhancement'
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,15 @@
+Thanks for taking the time to contribute! :gift:
+
+Please follow these steps:
+
+1. work on the right branch: it must be `develop` for new features and `master` for hotfixes
+2. make sure the feature you add is not listed in [banned features](https://github.com/keeweb/keeweb/wiki/Unsupported-Features)
+3. check compatibility with [the project roadmap](https://github.com/keeweb/keeweb/wiki/TODO) and key features: you should not break anything
+4. if your feature is introducing a lot of new UI or changing any UX or design concept, please open an issue to discuss it first
+5. please respect existing style in code, styles, and markup (hint: install and enable [editorconfig](http://editorconfig.org/) in your editor)
+6. don't add any dependencies
+7. test your code: it must work in all browsers, Windows, OSX, and Linux
+8. if your code is platform-dependent, please add corresponding switches
+9. respect each platform: don't create a behaviour that breaks interface guidelines or user expectations 
+10. run `grunt` and make sure it's passing 
+11. replace this message with the actual description

.github/actions/linux-build/Dockerfile

@@ -0,0 +1,11 @@
+FROM snapcore/snapcraft:stable
+
+COPY entrypoint.sh /entrypoint.sh
+
+RUN apt-get update
+RUN apt-get install -y build-essential git-core unzip curl pkg-config rpm
+RUN curl -sL https://deb.nodesource.com/setup_15.x | sudo -E bash -
+RUN apt-get install -y nodejs
+RUN npm i -g grunt-cli
+
+ENTRYPOINT ["/entrypoint.sh"]

.github/actions/linux-build/action.yml

@@ -0,0 +1,5 @@
+name: 'Linux Build'
+description: 'Build KeeWeb on Linux in Docker'
+runs:
+  using: 'docker'
+  image: 'Dockerfile'

.github/actions/linux-build/entrypoint.sh

@@ -0,0 +1,5 @@
+#!/bin/bash -e
+
+cd /github/workspace
+npm ci
+grunt desktop-linux

.github/actions/scripts/git-restore-mtime.py

@@ -0,0 +1,404 @@
+#!/usr/bin/env python3
+#
+# git-restore-mtime - Change mtime of files based on commit date of last change
+#
+#    Copyright (C) 2012 Rodrigo Silva (MestreLion) <linux@rodrigosilva.com>
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program. See <http://www.gnu.org/licenses/gpl.html>
+#
+"""
+Change the modification time (mtime) of all files in work tree, based on the
+date of the most recent commit that modified the file.
+
+Useful prior to generating release tarballs, so each file is archived with a
+date that is similar to the date when the file was actually last modified,
+assuming the actual modification date and its commit date are close.
+
+By default ignores all ignored and untracked files, and also refuses to work
+on trees with uncommitted changes.
+"""
+
+# TODO:
+# - Add -z on git whatchanged/ls-files so we don't deal with filename decode/OS normalization
+# - When Python is bumped to 3.7, use text instead of universal_newlines on subprocess
+# - Update "Statistics for some large projects" with modern hardware and repositories.
+# - Create a README.md for git-restore-mtime alone. It deserves extensive documentation
+#   - Move Statistics there
+
+# FIXME:
+# - When current dir is outside the worktree, e.g. using --work-tree, `git ls-files`
+#   assume any relative pathspecs are to worktree root, not the current dir. As such,
+#   relative pathspecs may not work.
+# - Renames and mode changes should not change file mtime:
+#   - Must check on status 'R100' and mode changes with same blobs
+#   - Should require status to be (A, C, M, R<100, T). D will never be processed as
+#     filelist is a subset of lsfileslist.
+# - Check file (A, D) for directory mtime is not sufficient:
+#   - Renames also change dir mtime, unless rename was on a parent dir
+#   - If most recent change of all files in a dir was a [M]odification,
+#     dir might not be touched at all.
+#   - Dirs containing only subdirectories but no direct files will also
+#     not be touched. They're files' [grand]parent dir, but never their dirname().
+#   - Some solutions:
+#     - After files done, perform some dir processing for missing dirs, finding latest
+#       file (A, D, R)
+#     - Simple approach: dir mtime is most recent child (dir or file) mtime
+#     - Use a virtual concept of "created at most at" to fill missing info, bubble up
+#       to parents and grandparents
+#   - When handling [grand]parent dirs, stay inside <pathspec>
+# - Better handling of merge commits. `-m` is plain *wrong*. `-c/--cc` is perfect, but
+#   painfully slow. First pass without merge commits is not accurate. Maybe add a new
+#   `--accurate` mode for `--cc`?
+
+if __name__ != "__main__":
+    raise ImportError("{} should not be used as a module.".format(__name__))
+
+import subprocess, shlex
+import sys, os.path
+import logging
+import argparse
+import time
+
+
+# Update symlinks only if the OS supports not following them
+UPDATE_SYMLINKS = bool(os.utime in getattr(os, 'supports_follow_symlinks', []))
+STEPMISSING = 100
+
+
+# Command-line interface ######################################################
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="""Restore original modification time of files based on the date of the
+        most recent commit that modified them. Useful when generating release tarballs.""")
+
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument('--quiet', '-q', dest='loglevel',
+        action="store_const", const=logging.WARNING, default=logging.INFO,
+        help="Suppress informative messages and summary statistics.")
+    group.add_argument('--verbose', '-v', action="count",
+        help="Print additional information for each processed file.")
+
+    parser.add_argument('--force', '-f', action="store_true",
+        help="Force execution on trees with uncommitted changes.")
+
+    parser.add_argument('--merge', '-m', action="store_true",
+        help="""Include merge commits. Leads to more recent mtimes and more files per
+        commit, thus with the same mtime (which may or may not be what you want). Including
+        merge commits may lead to less commits being evaluated (all files are found sooner),
+        which improves performance, sometimes substantially. But since merge commits are
+        usually huge, processing them may also take longer, sometimes substantially.
+        By default merge logs are only used for files missing from regular commit logs.""")
+
+    parser.add_argument('--first-parent', action="store_true",
+        help="""Consider only the first parent, the "main branch", when parsing merge
+        commit logs. Only effective when merge commits are included in the log, either
+        by --merge or to find missing files after first log parse. See --skip-missing.""")
+
+    parser.add_argument('--skip-missing', '-s',
+        action="store_false", default=True, dest="missing",
+        help="""Do not try to find missing files. If some files were not found in regular
+        commit logs, by default it re-tries using merge commit logs for these files (if
+        --merge was not already used). This option disables this behavior, which may slightly
+        improve performance, but files found only in merge commits will not be updated.""")
+
+    parser.add_argument('--no-directories', '-D',
+        action="store_false", default=True, dest='dirs',
+        help="""Do not update directory mtime for files created, renamed or deleted in it.
+        Note: just modifying a file will not update its directory mtime.""")
+
+    parser.add_argument('--test', '-t', action="store_true", default=False,
+        help="Test run: do not actually update any file")
+
+    parser.add_argument('--commit-time', '-c',
+        action='store_true', default=False, dest='commit_time',
+        help="Use commit time instead of author time")
+
+    parser.add_argument('pathspec', nargs='*', metavar='PATH',
+        help="""Only modify paths matching PATH, directories or files, relative to current
+        directory. Default is to modify all files handled by git, ignoring untracked files
+        and submodules.""")
+
+    parser.add_argument('--work-tree', dest='workdir',
+        help="Path to the work tree, if not current directory or one of its parents.")
+
+    parser.add_argument('--git-dir', dest='gitdir',
+        help="Path to the git repository, if not the default <work-tree-root>/.git")
+
+    parser.add_argument('--skip-older-than', metavar='SECONDS', type=int,
+        help="""Do not modify files that are older than %(metavar)s.
+        It can significantly improve performance if fewer files are processed.
+        Useful on CI builds, which can eventually switch workspace to different branch,
+        but mostly performs builds on the same one (e.g. master).
+        """)
+
+    return parser.parse_args()
+
+
+# Helper functions ############################################################
+
+def setup_logging(args):
+    TRACE = logging.DEBUG // 2
+    logging.Logger.trace = lambda _, m, *a, **k: _.log(TRACE, m, *a, **k)
+    level = (args.verbose and max(TRACE, logging.DEBUG // args.verbose)) or args.loglevel
+    logging.basicConfig(level=level, format='%(message)s')
+    return logging.getLogger()
+
+
+def normalize(path):
+    """Normalize paths from git, handling non-ASCII characters.
+
+    Git for Windows, as of v1.7.10, stores paths as UTF-8 normalization form C. If path
+    contains non-ASCII or non-printable chars it outputs the UTF-8 in octal-escaped
+    notation, double-quoting the whole path. Double-quotes and backslashes are also escaped.
+
+    https://git-scm.com/docs/git-config#Documentation/git-config.txt-corequotePath
+    https://github.com/msysgit/msysgit/wiki/Git-for-Windows-Unicode-Support
+    https://github.com/git/git/blob/master/Documentation/i18n.txt
+
+    Example on git output, this function reverts this:
+    r'back\slash_double"quote_açaí' -> r'"back\\slash_double\"quote_a\303\247a\303\255"'
+    """
+    if path and path[0] == '"':
+        # Python 2: path = path[1:-1].decode("string-escape")
+        # Python 3: https://stackoverflow.com/a/46650050/624066
+        path = (path[1:-1]                 # Remove enclosing double quotes
+                .encode('latin1')          # Convert to bytes, required 'unicode-escape'
+                .decode('unicode-escape')  # Perform the actual octal-escaping decode
+                .encode('latin1')          # 1:1 mapping to bytes, forming UTF-8 encoding
+                .decode('utf8'))           # Decode from UTF-8
+    # Make sure the slash matches the OS; for Windows we need a backslash
+    return os.path.normpath(path)
+
+
+if UPDATE_SYMLINKS:
+    def touch(path, mtime, test=False):
+        """The actual mtime update"""
+        if test: return
+        os.utime(path, (mtime, mtime), follow_symlinks=False)
+else:
+    def touch(path, mtime, test=False):
+        """The actual mtime update"""
+        if test: return
+        os.utime(path, (mtime, mtime))
+
+
+def isodate(secs):
+    return time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(secs))
+
+
+# Git class and parselog(), the heart of the script ###########################
+
+class Git():
+    def __init__(self, workdir=None, gitdir=None):
+        self.gitcmd = ['git']
+        if workdir: self.gitcmd.extend(('--work-tree', workdir))
+        if gitdir : self.gitcmd.extend(('--git-dir',   gitdir))
+        self.workdir, self.gitdir = self._repodirs()
+
+    def ls_files(self, pathlist=None):
+        return (normalize(_) for _ in self._run('ls-files --full-name', pathlist))
+
+    def is_dirty(self):
+        return bool(self._run('diff --no-ext-diff --quiet', output=False))
+
+    def log(self, merge=False, first_parent=False, commit_time=False, pathlist=None):
+        cmd = 'whatchanged --pretty={}'.format('%ct' if commit_time else '%at')
+        if merge:        cmd += ' -m'
+        if first_parent: cmd += ' --first-parent'
+        return self._run(cmd, pathlist)
+
+    def _repodirs(self):
+        return (os.path.normpath(_) for _ in
+                self._run('rev-parse --show-toplevel --absolute-git-dir', check=True))
+
+    def _run(self, cmdstr, pathlist=None, output=True, check=False):
+        cmdlist = self.gitcmd + shlex.split(cmdstr)
+        if pathlist:
+            cmdlist.append('--')
+            cmdlist.extend(pathlist)
+        log.trace("Executing: %s", ' '.join(cmdlist))
+        if not output:
+            return subprocess.call(cmdlist)
+        if check:
+            try:
+                stdout = subprocess.check_output(cmdlist, universal_newlines=True)
+                return stdout.splitlines()
+            except subprocess.CalledProcessError as e:
+                raise self.Error(e.returncode, e.cmd, e.output, e.stderr)
+        self.proc = subprocess.Popen(cmdlist, stdout=subprocess.PIPE, universal_newlines=True)
+        return (_.strip() for _ in self.proc.stdout)
+
+    class Error(subprocess.CalledProcessError): pass
+
+
+def parselog(filelist, dirlist, stats, git, merge=False, filterlist=None):
+    mtime = 0
+    for line in git.log(merge, args.first_parent, args.commit_time, filterlist):
+        stats['loglines'] += 1
+
+        # Blank line between Date and list of files
+        if not line: continue
+
+        # File line
+        if line[0] == ':':  # Faster than line.startswith(':')
+            # If line describes a rename, linetok has three tokens, otherwise two
+            linetok = line.split('\t')
+            status = linetok[0]
+            file = linetok[-1]
+
+            # Handles non-ASCII chars and OS path separator
+            file = normalize(file)
+
+            if file in filelist:
+                stats['files'] -= 1
+                log.debug("%d\t%d\t%d\t%s\t%s",
+                             stats['loglines'], stats['commits'], stats['files'],
+                             isodate(mtime), file)
+                filelist.remove(file)
+                try:
+                    touch(os.path.join(git.workdir, file), mtime, args.test)
+                    stats['touches'] += 1
+                except Exception as e:
+                    log.error("ERROR: %s", e)
+                    stats['errors'] += 1
+
+            if args.dirs:
+                dirname = os.path.dirname(file)
+                if status[-1] in ('A', 'D') and dirname in dirlist:
+                    log.debug("%d\t%d\t-\t%s\t%s",
+                                 stats['loglines'], stats['commits'],
+                                 isodate(mtime), "{}/".format(dirname or '.'))
+                    dirlist.remove(dirname)
+                    try:
+                        touch(os.path.join(git.workdir, dirname), mtime, args.test)
+                        stats['dirtouches'] += 1
+                    except Exception as e:
+                        log.error("ERROR: %s", e)
+                        stats['direrrors'] += 1
+
+        # Date line
+        else:
+            stats['commits'] += 1
+            mtime = int(line)
+
+        # All files done?
+        if not stats['files']:
+            git.proc.terminate()  # hackish, but does the job. Not needed anyway
+            return
+
+
+# Main Logic ##################################################################
+
+def main():
+    start = time.time()  # yes, Wall time. CPU time is not realistic for users.
+    stats = {_: 0 for _ in ('loglines', 'commits', 'touches', 'errors', 'dirtouches', 'direrrors')}
+
+    # First things first: Where and Who are we?
+    try:
+        git = Git(args.workdir, args.gitdir)
+    except Git.Error as e:
+        # Not in a git repository, and git already informed user on stderr. So we just...
+        return e.returncode
+
+    # Do not work on dirty repositories, unless --force
+    if not args.force and git.is_dirty():
+        log.critical(
+         "ERROR: There are local changes in the working directory.\n"
+         "This could lead to undesirable results for modified files.\n"
+         "Please, commit your changes (or use --force) and try again.\n"
+         "Aborting")
+        return 1
+
+    # Get the files managed by git and build file and dir list to be processed
+    filelist = set()
+    dirlist  = set()
+    if UPDATE_SYMLINKS and not args.skip_older_than:
+        filelist = set(git.ls_files(args.pathspec))
+        dirlist  = set(os.path.dirname(_) for _ in filelist)
+    else:
+        for path in git.ls_files(args.pathspec):
+            fullpath = os.path.join(git.workdir, path)
+
+            # Symlink (to file, to dir or broken - git handles the same way)
+            if not UPDATE_SYMLINKS and os.path.islink(fullpath):
+                log.warning("WARNING: Skipping symlink, OS does not support update: %s", path)
+                continue
+
+            # skip files which are older than given threshold
+            if args.skip_older_than and start - os.path.getmtime(fullpath) > args.skip_older_than:
+                continue
+
+            # Always add them relative to worktree root
+            filelist.add(path)
+            dirlist.add(os.path.dirname(path))
+
+    stats['totalfiles'] = stats['files'] = len(filelist)
+    log.info("{0:,} files to be processed in work dir".format(stats['totalfiles']))
+
+    if not filelist:
+        # Nothing to do. Exit silently and without errors, just like git does
+        return
+
+    # Process the log until all files are 'touched'
+    log.debug("Line #\tLog #\tF.Left\tModification Time\tFile Name")
+    parselog(filelist, dirlist, stats, git, args.merge, args.pathspec)
+
+    # Missing files
+    if filelist:
+        # Try to find them in merge logs, if not done already
+        # (usually HUGE, thus MUCH slower!)
+        if args.missing and not args.merge:
+            filterlist = list(filelist)
+            for i in range(0, len(filterlist), STEPMISSING):
+                parselog(filelist, dirlist, stats, git,
+                         merge=True, filterlist=filterlist[i:i+STEPMISSING])
+
+        # Still missing some?
+        for file in filelist:
+            log.warning("WARNING: not found in log: %s", file)
+
+    # Final statistics
+    # Suggestion: use git-log --before=mtime to brag about skipped log entries
+    log.info(
+        "Statistics:\n"
+        "{:13,.2f} seconds\n"
+        "{:13,} log lines processed\n"
+        "{:13,} commits evaluated"
+        "".format(time.time()-start, stats['loglines'], stats['commits']))
+
+    if args.dirs:
+        if stats['direrrors']: log.info("{:13,} directory update errors".format(stats['direrrors']))
+        log.info("{:13,} directories updated".format(stats['dirtouches']))
+
+    if stats['touches'] != stats['totalfiles']: log.info("{:13,} files".format(stats['totalfiles']))
+    if stats['files']:                          log.info("{:13,} files missing".format(stats['files']))
+    if stats['errors']:                         log.info("{:13,} file update errors".format(stats['errors']))
+
+    log.info("{:13,} files updated".format(stats['touches']))
+
+    if args.test:
+        log.info("TEST RUN - No files modified!")
+
+
+args = parse_args()
+log = setup_logging(args)
+log.trace("Arguments: %s", args)
+
+# UI done, it's show time!
+try:
+    sys.exit(main())
+except KeyboardInterrupt:
+    log.info("Aborting")
+    sys.exit(-1)

.github/workflows/build.yaml

@@ -0,0 +1,424 @@
+name: Build
+on:
+  push:
+    tags: [ '*' ]
+jobs:
+
+  web:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get current git tag
+        id: get_tag
+        uses: keeweb/get-git-tag@v3.0.2
+        with:
+          tagRegex: "^v(\\d+\\.\\d+\\.\\d+)$"
+          tagRegexGroup: 1
+      - name: Checkout
+        uses: actions/checkout@v2
+        with:
+          repository: keeweb/keeweb
+          ref: ${{ github.repository == 'keeweb/keeweb' && github.sha || 'develop' }}
+      - name: Upgrade Node.js
+        uses: actions/setup-node@v2
+        with:
+          node-version: '16'
+          registry-url: 'https://registry.npmjs.org'
+      - name: Install npm modules
+        run: npm ci
+      - name: Lint
+        run: npm lint
+      - name: Test
+        run: npm test
+      - name: Build
+        run: npm start
+      - name: Upload artifact
+        uses: actions/upload-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.html
+          path: dist
+      - name: Write secrets
+        env:
+          VIRUS_TOTAL: ${{ secrets.VIRUS_TOTAL }}
+        run: |
+          mkdir keys
+          echo "$VIRUS_TOTAL" > keys/virus-total.json
+      - name: Check on VirusTotal
+        run: npm start virustotal
+        if: ${{ github.repository == 'keeweb/keeweb' }}
+
+  linux:
+    runs-on: ubuntu-latest
+    needs:
+      - web
+    steps:
+      - name: Get current git tag
+        id: get_tag
+        uses: keeweb/get-git-tag@v3.0.2
+        with:
+          tagRegex: "^v(\\d+\\.\\d+\\.\\d+)$"
+          tagRegexGroup: 1
+      - name: Checkout
+        uses: actions/checkout@v2
+        with:
+          repository: keeweb/keeweb
+          ref: ${{ github.repository == 'keeweb/keeweb' && github.sha || 'develop' }}
+      - name: Download artifact
+        uses: actions/download-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.html
+          path: dist
+      - name: Write secrets
+        env:
+          PRIVATE_KEY: ${{ secrets.PRIVATE_KEY }}
+          KEEWEB_SIGN: ${{ secrets.KEEWEB_SIGN }}
+        run: |
+          mkdir keys
+          echo "$PRIVATE_KEY" > keys/private-key.pem
+          echo "$KEEWEB_SIGN" > keys/keeweb-sign.json
+      - name: Build in Docker
+        uses: ./.github/actions/linux-build
+      - name: Upload AppImage artifact
+        uses: actions/upload-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.linux.AppImage
+          path: dist/desktop/KeeWeb-${{ steps.get_tag.outputs.tag }}.linux.AppImage
+      - name: Upload snap artifact
+        uses: actions/upload-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.linux.snap
+          path: dist/desktop/KeeWeb-${{ steps.get_tag.outputs.tag }}.linux.snap
+      - name: Upload deb artifact
+        uses: actions/upload-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.linux.x64.deb
+          path: dist/desktop/KeeWeb-${{ steps.get_tag.outputs.tag }}.linux.x64.deb
+      - name: Upload zip artifact
+        uses: actions/upload-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.linux.x64.zip
+          path: dist/desktop/KeeWeb-${{ steps.get_tag.outputs.tag }}.linux.x64.zip
+      - name: Upload rpm artifact
+        uses: actions/upload-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.linux.x86_64.rpm
+          path: dist/desktop/KeeWeb-${{ steps.get_tag.outputs.tag }}.linux.x86_64.rpm
+
+  darwin:
+    runs-on: macos-latest
+    needs:
+      - web
+    steps:
+      - name: Get current git tag
+        id: get_tag
+        uses: keeweb/get-git-tag@v3.0.2
+        with:
+          tagRegex: "^v(\\d+\\.\\d+\\.\\d+)$"
+          tagRegexGroup: 1
+      - name: Checkout
+        uses: actions/checkout@v2
+        with:
+          repository: keeweb/keeweb
+          ref: ${{ github.repository == 'keeweb/keeweb' && github.sha || 'develop' }}
+      - name: Download artifact
+        uses: actions/download-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.html
+          path: dist
+      - name: Upgrade Node.js
+        uses: actions/setup-node@v2
+        with:
+          node-version: '16'
+          registry-url: 'https://registry.npmjs.org'
+      - name: Install npm modules
+        run: npm ci
+      - name: Write secrets
+        env:
+          CODESIGN: ${{ secrets.CODESIGN }}
+          APPLE_DEPLOY_PASSWORD: ${{ secrets.APPLE_DEPLOY_PASSWORD }}
+          APPLE_ID_USERNAME: ${{ secrets.APPLE_ID_USERNAME }}
+          APPLE_PROVISIONING_PROFILE: ${{ secrets.APPLE_PROVISIONING_PROFILE }}
+        run: |
+          mkdir keys
+          echo "$CODESIGN" > keys/codesign.json
+          xcrun altool --store-password-in-keychain-item "AC_PASSWORD" -u "$APPLE_ID_USERNAME" -p "$APPLE_DEPLOY_PASSWORD"
+          echo "$APPLE_PROVISIONING_PROFILE" | base64 -d > keys/keeweb.provisionprofile
+      - name: Import certificates
+        uses: keeweb/import-codesign-certs@v1
+        with:
+          p12-file-base64: ${{ secrets.APPLE_CERTIFICATE }}
+          p12-password: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+      - name: Build
+        run: npm start -- --max-old-space-size=4096 desktop-darwin ${{ github.repository != 'keeweb/keeweb' && '--skip-sign' || '' }}
+      - name: Upload x64 dmg artifact
+        uses: actions/upload-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.mac.x64.dmg
+          path: dist/desktop/KeeWeb-${{ steps.get_tag.outputs.tag }}.mac.x64.dmg
+      - name: Upload arm64 dmg artifact
+        uses: actions/upload-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.mac.arm64.dmg
+          path: dist/desktop/KeeWeb-${{ steps.get_tag.outputs.tag }}.mac.arm64.dmg
+
+  win32:
+    runs-on: windows-latest
+    needs:
+      - web
+    steps:
+      - name: Get current git tag
+        id: get_tag
+        uses: keeweb/get-git-tag@v3.0.2
+        with:
+          tagRegex: "^v(\\d+\\.\\d+\\.\\d+)$"
+          tagRegexGroup: 1
+      - name: Checkout
+        uses: actions/checkout@v2
+        with:
+          repository: keeweb/keeweb
+          ref: ${{ github.repository == 'keeweb/keeweb' && github.sha || 'develop' }}
+      - name: Download artifact
+        uses: actions/download-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.html
+          path: dist
+      - name: Upgrade Node.js
+        uses: actions/setup-node@v2
+        with:
+          node-version: '16'
+          registry-url: 'https://registry.npmjs.org'
+      - name: Install npm modules
+        run: npm ci
+      - name: Write secrets
+        env:
+          CODESIGN: ${{ secrets.CODESIGN }}
+          MS_CODESIGN_PRIVATE_KEY_CLIENT: ${{ secrets.MS_CODESIGN_PRIVATE_KEY_CLIENT }}
+          MS_CODESIGN_PUBLIC_KEY_CLIENT: ${{ secrets.MS_CODESIGN_PUBLIC_KEY_CLIENT }}
+          MS_CODESIGN_PUBLIC_KEY_SERVER: ${{ secrets.MS_CODESIGN_PUBLIC_KEY_SERVER }}
+        run: |
+          mkdir keys
+          echo $Env:CODESIGN > keys/codesign.json
+          mkdir keys/code-signing
+          echo $Env:MS_CODESIGN_PRIVATE_KEY_CLIENT > keys/code-signing/private-key-client.pem
+          echo $Env:MS_CODESIGN_PUBLIC_KEY_CLIENT > keys/code-signing/public-key-client.pem
+          echo $Env:MS_CODESIGN_PUBLIC_KEY_SERVER > keys/code-signing/public-key-server.pem
+      - name: Build
+        run: npm start -- desktop-win32 ${{ github.repository != 'keeweb/keeweb' && '--skip-sign' || '' }}
+      - name: Upload ia32 exe artifact
+        uses: actions/upload-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.win.ia32.exe
+          path: dist/desktop/KeeWeb-${{ steps.get_tag.outputs.tag }}.win.ia32.exe
+      - name: Upload ia32 zip artifact
+        uses: actions/upload-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.win.ia32.zip
+          path: dist/desktop/KeeWeb-${{ steps.get_tag.outputs.tag }}.win.ia32.zip
+      - name: Upload x64 exe artifact
+        uses: actions/upload-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.win.x64.exe
+          path: dist/desktop/KeeWeb-${{ steps.get_tag.outputs.tag }}.win.x64.exe
+      - name: Upload x64 zip artifact
+        uses: actions/upload-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.win.x64.zip
+          path: dist/desktop/KeeWeb-${{ steps.get_tag.outputs.tag }}.win.x64.zip
+      - name: Upload arm64 exe artifact
+        uses: actions/upload-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.win.arm64.exe
+          path: dist/desktop/KeeWeb-${{ steps.get_tag.outputs.tag }}.win.arm64.exe
+      - name: Upload arm64 zip artifact
+        uses: actions/upload-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.win.arm64.zip
+          path: dist/desktop/KeeWeb-${{ steps.get_tag.outputs.tag }}.win.arm64.zip
+
+  publish:
+    runs-on: ubuntu-latest
+    needs:
+      - linux
+      - darwin
+      - win32
+    steps:
+      - name: Get current git tag
+        id: get_tag
+        uses: keeweb/get-git-tag@v3.0.2
+        with:
+          tagRegex: "^v(\\d+\\.\\d+\\.\\d+)$"
+          tagRegexGroup: 1
+      - name: Setup GCloud
+        uses: google-github-actions/setup-gcloud@master
+        with:
+          version: '285.0.0'
+          service_account_key: ${{ secrets.GCP_SA_KEY }}
+          export_default_credentials: true
+      - name: Checkout
+        uses: actions/checkout@v2
+        with:
+          repository: keeweb/keeweb
+          path: keeweb
+          ref: ${{ github.repository == 'keeweb/keeweb' && github.sha || 'develop' }}
+      - name: Upgrade Node.js
+        uses: actions/setup-node@v2
+        with:
+          node-version: '16'
+          registry-url: 'https://registry.npmjs.org'
+      - name: Install npm modules
+        working-directory: keeweb
+        run: npm ci
+      - name: Download html artifact
+        uses: actions/download-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.html
+          path: html
+      - name: Download linux.AppImage artifact
+        uses: actions/download-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.linux.AppImage
+          path: assets
+      - name: Download linux.snap artifact
+        uses: actions/download-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.linux.snap
+          path: assets
+      - name: Download linux.deb artifact
+        uses: actions/download-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.linux.x64.deb
+          path: assets
+      - name: Download linux.zip artifact
+        uses: actions/download-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.linux.x64.zip
+          path: assets
+      - name: Download linux.rpm artifact
+        uses: actions/download-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.linux.x86_64.rpm
+          path: assets
+      - name: Download darwin.x64.dmg artifact
+        uses: actions/download-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.mac.x64.dmg
+          path: assets
+      - name: Download darwin.arm64.dmg artifact
+        uses: actions/download-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.mac.arm64.dmg
+          path: assets
+      - name: Download win32.ia32.exe artifact
+        uses: actions/download-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.win.ia32.exe
+          path: assets
+      - name: Download win32.ia32.zip artifact
+        uses: actions/download-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.win.ia32.zip
+          path: assets
+      - name: Download win32.x64.exe artifact
+        uses: actions/download-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.win.x64.exe
+          path: assets
+      - name: Download win32.x64.zip artifact
+        uses: actions/download-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.win.x64.zip
+          path: assets
+      - name: Download win32.arm64.exe artifact
+        uses: actions/download-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.win.arm64.exe
+          path: assets
+      - name: Download win32.arm64.zip artifact
+        uses: actions/download-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.win.arm64.zip
+          path: assets
+      - name: Zip html
+        working-directory: html
+        run: zip -vr ../assets/KeeWeb-${{ steps.get_tag.outputs.tag }}.html.zip .
+      - name: Copy assets to dist
+        run: mkdir -p keeweb/dist/desktop && cp assets/* keeweb/dist/desktop
+      - name: Write secrets
+        env:
+          PRIVATE_KEY: ${{ secrets.PRIVATE_KEY }}
+          KEEWEB_SIGN: ${{ secrets.KEEWEB_SIGN }}
+        working-directory: keeweb
+        run: |
+          mkdir keys
+          echo "$PRIVATE_KEY" > keys/private-key.pem
+          echo "$KEEWEB_SIGN" > keys/keeweb-sign.json
+      - name: Build
+        working-directory: keeweb
+        run: npm start finish-release
+      - name: Copy signatures to assets
+        run: cp keeweb/dist/desktop/Verify.sign.sha256 assets
+      - name: Copy checksums to assets
+        run: cp keeweb/dist/desktop/Verify.sha256 assets
+      - name: Login to DockerHub Registry
+        env:
+          DOCKERHUB_ACCESS_TOKEN: ${{ secrets.DOCKERHUB_ACCESS_TOKEN }}
+          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+        run: echo $DOCKERHUB_ACCESS_TOKEN | docker login -u $DOCKERHUB_USERNAME --password-stdin
+      - name: Copy dist to the Docker context
+        run: cp -r html keeweb/package/docker/dist
+      - name: Build the Docker image
+        working-directory: keeweb
+        run: docker build -t antelle/keeweb:latest -t antelle/keeweb:${{ steps.get_tag.outputs.tag }} package/docker
+      - name: Push the Docker image to dockerhub
+        if: ${{ github.repository == 'keeweb/keeweb' }}
+        run: docker push --all-tags antelle/keeweb
+      - name: Extract release notes
+        run: node util/extract-release-notes.js --version=${{ steps.get_tag.outputs.tag }} --output=tmp/release-body.md
+        working-directory: keeweb
+      - name: Publish GitHub release
+        uses: softprops/action-gh-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: v${{ steps.get_tag.outputs.tag }}
+          name: Desktop apps v${{ steps.get_tag.outputs.tag }}
+          files: assets/*
+          body_path: keeweb/tmp/release-body.md
+      - name: Checkout gh-pages
+        uses: actions/checkout@v2
+        with:
+          ref: gh-pages
+          path: gh-pages
+          fetch-depth: 0
+      - name: Commit dist to gh-pages
+        working-directory: gh-pages
+        run: |
+          git rm -r '*'
+          cp -r ../html/* .
+          mkdir -p .github/workflows
+          echo $GITHUB_SHA > build.txt
+          date >> build.txt
+          git add .
+          git config --local user.email "action@github.com"
+          git config --local user.name "GitHub Action"
+          git commit -am v${{ steps.get_tag.outputs.tag }}
+      - name: Push gh-pages
+        uses: keeweb/github-push-action@master
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          branch: gh-pages
+          directory: gh-pages
+      - name: Restore git mtime
+        working-directory: gh-pages
+        run: python3 ../keeweb/.github/actions/scripts/git-restore-mtime.py
+      - name: Sync the website
+        if: ${{ github.repository == 'keeweb/keeweb' }}
+        run: gsutil -m rsync -r -d -x "^\." gh-pages gs://app.keeweb.info/
+      - name: Purge CloudFlare cache
+        if: ${{ github.repository == 'keeweb/keeweb' }}
+        env:
+          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+        run: |
+          curl -sS -X POST "https://api.cloudflare.com/client/v4/zones/dbda8e7e454d23edb08d4bc3b3f6f872/purge_cache" \
+            -H "Authorization: Bearer $CLOUDFLARE_API_TOKEN" \
+            -H "Content-Type: application/json" \
+            --data '{"purge_everything":true}'

.gitignore

@@ -2,9 +2,18 @@ workspace.xml
 misc.xml
 .DS_Store
 node_modules/
-bower_components/
 *.log
-dist/
+/dist/
 tmp/
-build/
 coverage/
+keys
+*.user
+bin/
+obj/
+*.xcworkspace/
+xcuserdata/
+*.suo
+.idea/
+.vscode/
+*.iml
+test/dist/

.idea/.name

@@ -1 +0,0 @@
-keeweb

.idea/codeStyleSettings.xml

@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectCodeStyleSettingsManager">
-    <option name="PER_PROJECT_SETTINGS">
-      <value>
-        <XML>
-          <option name="XML_LEGACY_SETTINGS_IMPORTED" value="true" />
-        </XML>
-      </value>
-    </option>
-    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default (1)" />
-  </component>
-</project>

.idea/compiler.xml

@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="CompilerConfiguration">
-    <resourceExtensions />
-    <wildcardResourcePatterns>
-      <entry name="!?*.java" />
-      <entry name="!?*.form" />
-      <entry name="!?*.class" />
-      <entry name="!?*.groovy" />
-      <entry name="!?*.scala" />
-      <entry name="!?*.flex" />
-      <entry name="!?*.kt" />
-      <entry name="!?*.clj" />
-      <entry name="!?*.aj" />
-    </wildcardResourcePatterns>
-    <annotationProcessing>
-      <profile default="true" name="Default" enabled="false">
-        <processorPath useClasspath="true" />
-      </profile>
-    </annotationProcessing>
-  </component>
-</project>

.idea/copyright/profiles_settings.xml

@@ -1,3 +0,0 @@
-<component name="CopyrightManager">
-  <settings default="" />
-</component>

.idea/encodings.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="Encoding">
-    <file url="PROJECT" charset="UTF-8" />
-  </component>
-</project>

.idea/inspectionProfiles/Project_Default.xml

@@ -1,6 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <profile version="1.0">
-    <option name="myName" value="Project Default" />
-    <inspection_tool class="JSHint" enabled="true" level="ERROR" enabled_by_default="true" />
-  </profile>
-</component>

.idea/inspectionProfiles/profiles_settings.xml

@@ -1,7 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <settings>
-    <option name="PROJECT_PROFILE" value="Project Default" />
-    <option name="USE_PROJECT_PROFILE" value="true" />
-    <version value="1.0" />
-  </settings>
-</component>

.idea/jsLibraryMappings.xml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4" />

.idea/jsLinters/jshint.xml

@@ -1,70 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="JSHintConfiguration" version="2.6.3" use-config-file="true">
-    <option asi="false" />
-    <option bitwise="true" />
-    <option boss="false" />
-    <option browser="true" />
-    <option camelcase="false" />
-    <option couch="false" />
-    <option curly="true" />
-    <option debug="false" />
-    <option devel="false" />
-    <option dojo="false" />
-    <option eqeqeq="true" />
-    <option eqnull="false" />
-    <option es3="false" />
-    <option esnext="false" />
-    <option evil="false" />
-    <option expr="false" />
-    <option forin="true" />
-    <option freeze="false" />
-    <option funcscope="false" />
-    <option gcl="false" />
-    <option globalstrict="false" />
-    <option immed="false" />
-    <option iterator="false" />
-    <option jquery="false" />
-    <option lastsemic="false" />
-    <option latedef="false" />
-    <option laxbreak="false" />
-    <option laxcomma="false" />
-    <option loopfunc="false" />
-    <option maxerr="50" />
-    <option mootools="false" />
-    <option moz="false" />
-    <option multistr="false" />
-    <option newcap="false" />
-    <option noarg="true" />
-    <option node="false" />
-    <option noempty="true" />
-    <option nomen="false" />
-    <option nonbsp="false" />
-    <option nonew="true" />
-    <option nonstandard="false" />
-    <option notypeof="false" />
-    <option noyield="false" />
-    <option onevar="false" />
-    <option passfail="false" />
-    <option phantom="false" />
-    <option plusplus="false" />
-    <option proto="false" />
-    <option prototypejs="false" />
-    <option quotmark="false" />
-    <option rhino="false" />
-    <option scripturl="false" />
-    <option shadow="false" />
-    <option smarttabs="false" />
-    <option strict="true" />
-    <option sub="false" />
-    <option supernew="false" />
-    <option trailing="false" />
-    <option undef="true" />
-    <option unused="false" />
-    <option validthis="false" />
-    <option white="false" />
-    <option worker="false" />
-    <option wsh="false" />
-    <option yui="false" />
-  </component>
-</project>

.idea/libraries/keeweb_node_modules.xml

@@ -1,15 +0,0 @@
-<component name="libraryTable">
-  <library name="keeweb node_modules" type="javaScript">
-    <properties>
-      <option name="frameworkName" value="node_modules" />
-      <sourceFilesUrls>
-        <item url="file://$PROJECT_DIR$/node_modules" />
-      </sourceFilesUrls>
-    </properties>
-    <CLASSES>
-      <root url="file://$PROJECT_DIR$/node_modules" />
-    </CLASSES>
-    <JAVADOC />
-    <SOURCES />
-  </library>
-</component>

.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/keeweb.iml" filepath="$PROJECT_DIR$/keeweb.iml" />
-    </modules>
-  </component>
-</project>

.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
-  </component>
-</project>

.jshintrc

@@ -1,94 +0,0 @@
-{
-  "maxerr"        : 50,       // {int} Maximum error before stopping
-
-  // Enforcing
-  "bitwise"       : false,     // true: Prohibit bitwise operators (&, |, ^, etc.)
-  "camelcase"     : true,     // true: Identifiers must be in camelCase
-  "curly"         : true,     // true: Require {} for every new block or scope
-  "eqeqeq"        : true,     // true: Require triple equals (===) for comparison
-  "forin"         : true,     // true: Require filtering for..in loops with obj.hasOwnProperty()
-  "freeze"        : true,     // true: prohibits overwriting prototypes of native objects such as Array, Date etc.
-  "immed"         : false,    // true: Require immediate invocations to be wrapped in parens e.g. `(function () { } ());`
-  "indent"        : 4,        // {int} Number of spaces to use for indentation
-  "latedef"       : false,    // true: Require variables/functions to be defined before being used
-  "newcap"        : true,     // true: Require capitalization of all constructor functions e.g. `new F()`
-  "noarg"         : true,     // true: Prohibit use of `arguments.caller` and `arguments.callee`
-  "noempty"       : true,     // true: Prohibit use of empty blocks
-  "nonbsp"        : true,     // true: Prohibit "non-breaking whitespace" characters.
-  "nonew"         : false,    // true: Prohibit use of constructors for side-effects (without assignment)
-  "plusplus"      : false,    // true: Prohibit use of `++` & `--`
-  "quotmark"      : "single",    // Quotation mark consistency:
-  //   false    : do nothing (default)
-  //   true     : ensure whatever is used is consistent
-  //   "single" : require single quotes
-  //   "double" : require double quotes
-  "undef"         : true,     // true: Require all non-global variables to be declared (prevents global leaks)
-  "unused"        : true,     // Unused variables:
-  //   true     : all variables, last function parameter
-  //   "vars"   : all variables only
-  //   "strict" : all variables, all function parameters
-  "strict"        : true,     // true: Requires all functions run in ES5 Strict Mode
-  "maxparams"     : false,    // {int} Max number of formal params allowed per function
-  "maxdepth"      : false,    // {int} Max depth of nested blocks (within functions)
-  "maxstatements" : false,    // {int} Max number statements per function
-  "maxcomplexity" : false,    // {int} Max cyclomatic complexity per function
-  "maxlen"        : 160,      // {int} Max number of characters per line
-  "varstmt"       : false,    // true: Disallow any var statements. Only `let` and `const` are allowed.
-
-  // Relaxing
-  "asi"           : false,     // true: Tolerate Automatic Semicolon Insertion (no semicolons)
-  "boss"          : false,     // true: Tolerate assignments where comparisons would be expected
-  "debug"         : false,     // true: Allow debugger statements e.g. browser breakpoints.
-  "eqnull"        : false,     // true: Tolerate use of `== null`
-  "esnext"        : true,      // true: Allow ES.next (ES6) syntax (ex: `const`)
-  "moz"           : false,     // true: Allow Mozilla specific syntax (extends and overrides esnext features)
-  // (ex: `for each`, multiple try/catch, function expression…)
-  "evil"          : false,     // true: Tolerate use of `eval` and `new Function()`
-  "expr"          : false,     // true: Tolerate `ExpressionStatement` as Programs
-  "funcscope"     : false,     // true: Tolerate defining variables inside control statements
-  "globalstrict"  : true,     // true: Allow global "use strict" (also enables 'strict')
-  "iterator"      : false,     // true: Tolerate using the `__iterator__` property
-  "lastsemic"     : false,     // true: Tolerate omitting a semicolon for the last statement of a 1-line block
-  "laxbreak"      : false,     // true: Tolerate possibly unsafe line breakings
-  "laxcomma"      : false,     // true: Tolerate comma-first style coding
-  "loopfunc"      : false,     // true: Tolerate functions being defined in loops
-  "multistr"      : false,     // true: Tolerate multi-line strings
-  "noyield"       : false,     // true: Tolerate generator functions with no yield statement in them.
-  "notypeof"      : false,     // true: Tolerate invalid typeof operator values
-  "proto"         : false,     // true: Tolerate using the `__proto__` property
-  "scripturl"     : false,     // true: Tolerate script-targeted URLs
-  "shadow"        : false,     // true: Allows re-define variables later in code e.g. `var x=1; x=2;`
-  "sub"           : false,     // true: Tolerate using `[]` notation when it can still be expressed in dot notation
-  "supernew"      : false,     // true: Tolerate `new function () { ... };` and `new Object;`
-  "validthis"     : false,     // true: Tolerate using this in a non-constructor function
-
-  // Environments
-  "browser"       : true,     // Web Browser (window, document, etc)
-  "browserify"    : false,    // Browserify (node.js code in the browser)
-  "couch"         : false,    // CouchDB
-  "devel"         : false,    // Development/debugging (alert, confirm, etc)
-  "dojo"          : false,    // Dojo Toolkit
-  "jasmine"       : true,     // Jasmine
-  "jquery"        : false,    // jQuery
-  "mocha"         : true,     // Mocha
-  "mootools"      : false,    // MooTools
-  "node"          : false,    // Node.js
-  "nonstandard"   : false,    // Widely adopted globals (escape, unescape, etc)
-  "phantom"       : false,    // PhantomJS
-  "prototypejs"   : false,    // Prototype and Scriptaculous
-  "qunit"         : false,    // QUnit
-  "rhino"         : false,    // Rhino
-  "shelljs"       : false,    // ShellJS
-  "typed"         : false,    // Globals for typed array constructions
-  "worker"        : false,    // Web Workers
-  "wsh"           : false,    // Windows Scripting Host
-  "yui"           : false,    // Yahoo User Interface
-
-  // Custom Globals
-  "globals"       : {
-    "require": true,
-    "module": true,
-    "$": true,
-    "_": true
-  }
-}

.prettierrc

@@ -0,0 +1,8 @@
+{
+    "tabWidth": 4,
+    "singleQuote": true,
+    "printWidth": 100,
+    "trailingComma": "none",
+    "quoteProps": "preserve",
+    "endOfLine": "auto"
+}

CONTRIBUTING.md

@@ -1,28 +1,66 @@
 # Contributing to KeeWeb
 
-:+1: Thanks for taking the time to contribute! :gift:
+Thanks for taking the time to contribute! :gift:
+
+There are different ways to help the project, you will find a summary here.
+
+## Code of conduct
+
+This project and everyone participating in it is governed by the [KeeWeb Code of Conduct](https://github.com/keeweb/keeweb/blob/master/.github/CODE_OF_CONDUCT.md#readme). 
+By participating, you are expected to uphold this code. Please report unacceptable behavior to antelle.net@gmail.com.
 
 ## Issues
 
-If you have found an bug, please [open an issue](https://github.com/antelle/keeweb/issues/new) and fill in the app version and your user-agent 
-(you can find these details in Settings/Help section). Please check [FAQ](https://github.com/antelle/keeweb/wiki/FAQ) before submitting a new issue 
-and [TODO](https://github.com/antelle/keeweb/wiki/TODO) before creating a feature request.
+First, let's check if it's [already there](https://github.com/keeweb/keeweb/issues).
+Perhaps, someone has already reported it?
 
-Please, describe the issue in details: what were your actions? What has happened? 
-Does it happen on Demo or New database? If no, how to reproduce this? If you are using a test db without your personal data, please attach it. 
-If it's possible, please, open dev tools in your browser and attach output log from it (Console tab). If you are using desktop app, 
-devtools can be opened from Settings/General/Advanced.
+[Click here](https://github.com/keeweb/keeweb/issues/new/choose) to create a new issue.
+When creating issues, please answer some questions asked on that page.
+They will help to understand, reproduce, and fix your issue.
 
-## Pull Requests
+## Vulnerabilities
 
-Plugins are not supported for now. So, if you want to add a feature, please, follow these steps:
+We would appreciate [responsible disclosure](https://en.wikipedia.org/wiki/Responsible_disclosure).
+If you would like to report a vulnerability, the preferred way to do so is [contacting the developer directly](mailto:antelle.net@gmail.com).
 
-1. make sure it's not listed in [banned features](https://github.com/antelle/keeweb/wiki/Unsupported-Features)
-2. check compatibility with [the project roadmap](https://github.com/antelle/keeweb/wiki/TODO) and key features: you should not break anything
-3. if your feature is introducing a lot of new UI, or is changing any UX or design concept, please, open an issue to discuss it first
-4. please, respect existing style in code, styles and markup (hint: install and enable [editorconfig](http://editorconfig.org/) in your editor)
-5. don't add any dependencies
-6. test your code: it must work in browser, Windows, OSX and Linux
-7. if your code is platform-dependent, please add corresponding switches
-8. respect each platform: don't create behaviour which breaks interface guidelines or user expectations 
-9. run `grunt` and make sure it's passing 
+## Questions, great ideas, etc...
+
+You can [create an issue](https://github.com/keeweb/keeweb/issues/new/choose) to discuss any topic.
+Indeed, questions on that page are not applicable in this case.
+
+## Development
+
+We don't accept (and in foreseeable future, we won't accept) anyone as a project collaborator directly. 
+Instead, the code should be contributed via pull requests. To get started with development, take a look at these pages:
+- [Architecture](https://github.com/keeweb/keeweb/wiki/Architecture)
+- [Engineering](https://github.com/keeweb/keeweb/wiki/Engineering)
+- [Unsupported Features](https://github.com/keeweb/keeweb/wiki/Unsupported%20Features)
+- [Pull Request Guidelines](https://github.com/keeweb/keeweb/blob/master/.github/PULL_REQUEST_TEMPLATE.md#readme)
+
+## Pull requests
+
+Please follow [this guide](https://github.com/keeweb/keeweb/blob/master/.github/PULL_REQUEST_TEMPLATE.md#readme).
+
+## Docs (Wiki pages)
+
+KeeWeb has [Wiki pages](https://github.com/keeweb/keeweb/wiki), however it's not possible to contribute with pull requests.
+If you would like to improve it, please [open an issue](https://github.com/keeweb/keeweb/issues/new/choose) and submit your changes in Markdown format.
+
+## Donations
+
+There are two ways of donating:  
+- join as backer on [OpenCollective](https://opencollective.com/keeweb#support);
+- sponsor the developer directly on [GitHub](https://github.com/sponsors/antelle).
+
+Please note: donation does not imply any type of service contract.  
+
+## Translations
+
+All KeeWeb translations are contributed by the community. To improve a translation or add a missing one,
+join us on [OneSky](https://keeweb.oneskyapp.com).
+
+## PR
+
+We would be happy to support you if you decide to post, blog, or review the project, 
+or provide any other kind of PR. Please [contact the developer](mailto:antelle.net@gmail.com) 
+if you have anything to share. You can also poke us on [Twitter](https://twitter.com/kee_web).

DEPS-LICENSE

@@ -0,0 +1,211 @@
+======================================================================================
+
+                              Dependencies Licenses
+
+======================================================================================
+
+jsqrcode license: Apache-2.0
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+================================================================================

LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) 2021 Antelle https://antelle.net
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+Licences of dependencies can be found here:
+https://raw.githubusercontent.com/keeweb/keeweb/master/DEPS-LICENSE

MIT-LICENSE.txt

@@ -1,20 +0,0 @@
-Copyright (C) 2015 Antelle
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -1,53 +1,100 @@
-# KeePass web app (unofficial)
+# Free cross-platform password manager compatible with KeePass
 
 This webapp is a browser and desktop password manager compatible with KeePass databases. It doesn't require any server or additional resources.
 The app can run either in browser, or as a desktop app.
 
-![screenshot](https://habrastorage.org/files/ec9/108/3de/ec91083de3e64574a504bc438d038dec.png)
+![screenshot](img/screenshot.png)
 
-# Quick Links
+## Quick Links
 
-Apps: [Web](https://app.keeweb.info/) [Desktop](https://github.com/antelle/keeweb/releases/latest)  
-Timeline: [Release Notes](release-notes.md) [TODO](https://github.com/antelle/keeweb/wiki/TODO)  
-On one page: [Features](https://keeweb.info/#features) [FAQ](https://github.com/antelle/keeweb/wiki/FAQ)  
+Apps: [Web](https://app.keeweb.info/), [Desktop](https://github.com/keeweb/keeweb/releases/latest)  
+Timeline: [Release Notes](release-notes.md), [TODO](https://github.com/keeweb/keeweb/wiki/TODO)  
+On one page: [Features](https://keeweb.info/#features), [FAQ](https://github.com/keeweb/keeweb/wiki/FAQ)  
 Website: [keeweb.info](https://keeweb.info)  
 Twitter: [kee_web](https://twitter.com/kee_web)  
+Donate: [OpenCollective](https://opencollective.com/keeweb#support), [GitHub](https://github.com/sponsors/antelle)  
 
-# Status
+## Status
 
-Project roadmap with planned features and approximate schedule is on [TODO](https://github.com/antelle/keeweb/wiki/TODO) page.  
+The app is quite stable now. Basic stuff, as well as more advanced operations, should be rather reliable.
 
-# Self-hosting
+## Self-hosting
 
-Everything you need to host this app on your server is any static file server. The app is a single HTML file + cache manifest (optionally; for offline access).
-You can download the latest distribution files from [gh-pages](https://github.com/antelle/keeweb/tree/gh-pages) branch.
-To make Dropbox work in your self-hosted app:
+Everything you need to host this app on your server is any static file server. The app is a single HTML file + a service worker (optionally; for offline access).
+You can download the latest distribution files from [gh-pages](https://github.com/keeweb/keeweb/archive/gh-pages.zip) branch.  
 
-1. [create](https://www.dropbox.com/developers/apps/create) a Dropbox app
-2. find your app key (in Dropbox App page, go to Settings/App key)
-3. change Dropbox app key in index.html file: `sed -i.bak s/qp7ctun6qt5n9d6/your_app_key/g index.html`
-    (or, if you are building from source, change it [here](app/scripts/comp/dropbox-link.js#L12))
+If you are using Docker:
 
-# Building
-
-The app can be built with grunt: `grunt` (html file will be in `dist/`).    
-Desktop apps are built with `grunt desktop`. This works only in mac osx as it builds dmg; requires wine.  
-To run Electron app without building installer, install electron package (`npm install electron-prebuilt -g`), build the app with `grunt` and start in this way:
+1. put your dh.pem, cert.pem, key.pem to /etc/nginx/external/ 
+2. run this script:
 ```bash
-$ grunt
-$ electron electron --htmlpath=tmp
+docker run --name keeweb -d -p 443:443 -p 80:80 -v $EXT_DIR:/etc/nginx/external/ antelle/keeweb
+```
+
+To make Dropbox work in your self-hosted app, [go to this Wiki page](https://github.com/keeweb/keeweb/wiki/Dropbox-and-GDrive).
+
+## Building
+
+The easiest way to clone all KeeWeb repos is:
+```bash
+curl https://raw.githubusercontent.com/keeweb/keeweb/develop/dev-env.sh | bash -
+```
+
+The app can be built with grunt: `grunt` (html files will be in `dist/`).  
+Desktop apps are built with `grunt desktop`. This requires some magic and currently works only on CI, 
+you can find more details in [the GitHub Actions workflow](.github/workflows/build.yaml).  
+
+To run the desktop (electron) app in development mode, start it this way:
+```bash
+npm run dev
+npm run electron
 ```
 
 For debug build:
 
-1. run `grunt`
-2. run `grunt watch`
-3. open `tmp/index.html`
+1. run `npm run dev`
+2. open `http://localhost:8085`
 
-# Contributing
+To build desktop apps, use these goals, the result can be found in `tmp`:
 
-Please, read [contribution guidelines](CONTRIBUTING.md).
+```
+npm run dev-desktop-macos
+npm run dev-desktop-windows
+npm run dev-desktop-linux
+```
 
-# License
+## Contributing
 
-[MIT](https://github.com/antelle/keeweb/blob/master/MIT-LICENSE.txt)
+Please read contribution guidelines [for pull requests](.github/PULL_REQUEST_TEMPLATE.md).  
+Here's a [list of issues](https://github.com/keeweb/keeweb/labels/help%20wanted) where your help would be very welcome.
+Also you can help by [translating KeeWeb](https://keeweb.oneskyapp.com) to your language.  
+
+Other ways of contribution can be found [on this page](CONTRIBUTING.md).
+
+#### Important notes for pull requests
+
+- please branch from `develop`, not `master`
+- don't edit translation files except base.json, they will be replaced
+
+## Donations
+
+KeeWeb is not free to develop. It takes time, requires paid code signing certificates and domains.  
+You can help the project or say "thank you" with this button:  
+[<img src="https://opencollective.com/keeweb/tiers/backer.svg?avatarHeight=42&width=880" alt="OpenCollective">](https://opencollective.com/keeweb#support)
+
+You can also sponsor the developer directly [on GitHub](https://github.com/sponsors/antelle).  
+
+Please note: donation does not imply any type of service contract.  
+
+## Thank you
+
+Notable contributions to KeeWeb:
+
+- Florian Reuschel ([@Loilo](https://github.com/Loilo)): [German translation](https://keeweb.oneskyapp.com/collaboration/translate/project/project/173183/language/550)
+- Dennis Ploeger ([@dploeger](https://github.com/dploeger)): [auto-type improvements](https://github.com/keeweb/keeweb/pulls?q=is%3Apr+is%3Aclosed+author%3Adploeger)
+- Hackmanit ([hackmanit.de](https://www.hackmanit.de)): [penetration test](https://www.hackmanit.de/en/blog-en/104-pro-bono-penetration-test-keeweb)
+- Peter Bittner ([@bittner](https://github.com/bittner)): [Wikipedia article](https://en.wikipedia.org/wiki/KeeWeb)
+
+## License
+
+[MIT](https://github.com/keeweb/keeweb/blob/master/LICENSE)

SECURITY.md

@@ -0,0 +1,11 @@
+# Security Policy
+
+## Supported Versions
+
+Only the latest version of the product is supported. This version can be accessed at https://app.keeweb.info 
+and downloaded from https://keeweb.info or GitHub releases ([latest release link](https://github.com/keeweb/keeweb/releases/latest)).
+
+## Reporting a Vulnerability
+
+We would appreciate [responsible disclosure](https://en.wikipedia.org/wiki/Responsible_disclosure).
+If you would like to report a vulnerability, the preferred way to do so is [contacting the developer directly](mailto:antelle.net@gmail.com).

app/content/404.html

@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <title>Not Found</title>
+        <style>
+            body {
+                font-family: -apple-system, 'BlinkMacSystemFont', 'Raleway', 'Helvetica Neue',
+                    'Helvetica', 'Arial', sans-serif;
+                font-feature-settings: 'liga' 0;
+                text-align: center;
+                background: #f5f5f5;
+                font-weight: 300;
+            }
+            h1 {
+                font-size: 3em;
+                margin-top: 10vh;
+            }
+            p {
+                line-height: 1.5em;
+            }
+        </style>
+    </head>
+    <body>
+        <h1>404 Not Found</h1>
+        <p>Sorry, the page you're looking for was not found.</p>
+    </body>
+</html>

app/content/oauth-result/dropbox.html

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <title>KeeWeb</title>
+    </head>
+    <body>
+        <script>
+            window.opener.postMessage(
+                { storage: 'dropbox', search: location.search },
+                window.location.origin
+            );
+            window.close();
+        </script>
+    </body>
+</html>

app/content/oauth-result/gdrive.html

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <title>KeeWeb</title>
+    </head>
+    <body>
+        <script>
+            window.opener.postMessage(
+                { storage: 'gdrive', search: location.search },
+                window.location.origin
+            );
+            window.close();
+        </script>
+    </body>
+</html>

app/content/oauth-result/onedrive.html

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <title>KeeWeb</title>
+    </head>
+    <body>
+        <script>
+            window.opener.postMessage(
+                { storage: 'onedrive', search: location.search },
+                window.location.origin
+            );
+            window.close();
+        </script>
+    </body>
+</html>

app/icons/safari-pinned-tab.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="-64 -64 640 640"><path d="M136.736 512c-4.892-.008-10.322-2.061-15.92-4.997-11.941-6.265-20.13-14.185-13.293-27.218l166.101-316.638c-1.972-1.022-3.619-1.88-4.743-2.469-59.892-31.418-86.463-77.87-64.952-118.877 24.726-47.135 101.304-55.69 171.042-19.107 69.738 36.584 106.227 104.451 81.501 151.586-21.264 40.536-76.784 44.151-132.61 14.866-1.538-.807-4.033-2.103-6.857-3.567L150.768 502.471c-3.632 6.924-8.488 9.538-14.032 9.529zm-30.582-67.835l-3.144-1.649-.7-.366-42.546-22.32v-.001l-10.256-5.38c-1.738-.911-2.407-3.057-1.496-4.794l13.465-25.667c.906-1.728 3.036-2.399 4.768-1.509l.028.013 20.513 10.761c1.736.911 3.883.241 4.794-1.496l13.466-25.667c.911-1.737.24-3.883-1.497-4.794l-10.256-5.382-10.256-5.38c-1.737-.911-2.406-3.057-1.495-4.794l13.464-25.669c.911-1.737 3.058-2.406 4.794-1.494l10.258 5.38 26.697 14.005 16.548 8.681c.007.003.014.007.021.011l3.125 1.639-14.142 26.957-.973 1.855c0 .001-.001.003-.002.004l-20.063 38.245-2.041 3.888-11.424 21.779c-.002.004-.005.009-.008.014zm67.232-128.162l-3.145-1.651-14.938-7.837-11.794-6.187c-1.737-.911-2.408-3.057-1.497-4.794l13.466-25.667c.911-1.737 3.058-2.408 4.794-1.497l11.795 6.188 14.939 7.837c.007.003.014.007.021.01l3.125 1.64-1.651 3.145-6.731 12.834-6.733 12.833c-.003.005-.006.008-.009.013zm219.778-151.914c8.857.016 15.784-3.552 20.386-12.326 14.027-26.737-11.92-67.987-57.953-92.135-46.032-24.148-94.719-22.049-108.746 4.688-14.026 26.737 24.987 44.293 71.02 68.441 30.928 16.224 57.156 31.296 75.293 31.332z"/></svg>

app/index.html

@@ -1,19 +1,84 @@
 <!DOCTYPE html>
 <html>
-<head lang="en">
-    <meta charset="UTF-8">
-    <title>KeeWeb</title>
-    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
-    <link rel="shortcut icon" href="favicon.png?__inline=true" />
-    <link rel="apple-touch-icon" sizes="192x192" href="touchicon.png?__inline=true">
-    <link rel="stylesheet" href="css/main.css?__inline=true" />
-    <script src="js/vendor.js?__inline=true"></script>
-    <script src="js/app.js?__inline=true"></script>
-</head>
-<body class="th-d">
-    <noscript>
-        <h1>KeeWeb</h1>
-        <p>This app is written entirely in JavaScript. Please, enable JavaScript to run it.</p>
-    </noscript>
-</body>
+    <head lang="en">
+        <meta charset="UTF-8" />
+        <title>KeeWeb</title>
+        <meta
+            http-equiv="Content-Security-Policy"
+            content="
+                            default-src 'self';
+                            font-src data:;
+                            script-src 'self' 'unsafe-eval';
+                            style-src 'self' blob:;
+                            connect-src 'self' ws: https:;
+                            child-src 'self' blob:;
+                            worker-src 'self' blob:;
+                            img-src 'self' data: blob: https://services.keeweb.info/;
+                            object-src 'none';
+                            form-action 'none';
+            "
+        />
+        <meta name="application-name" content="KeeWeb" />
+        <meta name="kw-config" content="(no-config)" />
+        <meta
+            name="viewport"
+            content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no"
+        />
+        <meta name="apple-mobile-web-app-capable" content="yes" />
+        <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
+        <meta name="apple-mobile-web-app-title" content="KeeWeb" />
+        <meta name="theme-color" content="#6386ec" />
+        <meta name="msapplication-config" content="browserconfig.xml" />
+        <meta name="msapplication-TileColor" content="#6386ec" />
+        <link rel="apple-touch-icon" sizes="180x180" href="icons/apple-touch-icon.png" />
+        <link rel="icon" type="image/png" sizes="32x32" href="icons/favicon-32x32.png" />
+        <link rel="icon" type="image/png" sizes="16x16" href="icons/favicon-16x16.png" />
+        <link rel="mask-icon" href="icons/safari-pinned-tab.svg" color="#6386ec" />
+        <link
+            rel="apple-touch-startup-image"
+            href="icons/splash-640x1136.png"
+            media="(device-width: 320px) and (device-height: 568px) and (-webkit-device-pixel-ratio: 2) and (orientation: portrait)"
+        />
+        <link
+            rel="apple-touch-startup-image"
+            href="icons/splash-750x1294.png"
+            media="(device-width: 375px) and (device-height: 667px) and (-webkit-device-pixel-ratio: 2) and (orientation: portrait)"
+        />
+        <link
+            rel="apple-touch-startup-image"
+            href="icons/splash-1242x2148.png"
+            media="(device-width: 414px) and (device-height: 736px) and (-webkit-device-pixel-ratio: 3) and (orientation: portrait)"
+        />
+        <link
+            rel="apple-touch-startup-image"
+            href="icons/splash-1125x2436.png"
+            media="(device-width: 375px) and (device-height: 812px) and (-webkit-device-pixel-ratio: 3) and (orientation: portrait)"
+        />
+        <link
+            rel="apple-touch-startup-image"
+            href="icons/splash-1536x2048.png"
+            media="(min-device-width: 768px) and (max-device-width: 1024px) and (-webkit-min-device-pixel-ratio: 2) and (orientation: portrait)"
+        />
+        <link
+            rel="apple-touch-startup-image"
+            href="icons/splash-1668x2224.png"
+            media="(min-device-width: 834px) and (max-device-width: 834px) and (-webkit-min-device-pixel-ratio: 2) and (orientation: portrait)"
+        />
+        <link
+            rel="apple-touch-startup-image"
+            href="icons/splash-2048x2732.png"
+            media="(min-device-width: 1024px) and (max-device-width: 1024px) and (-webkit-min-device-pixel-ratio: 2) and (orientation: portrait)"
+        />
+        <link rel="manifest" href="manifest.json" />
+        <link rel="stylesheet" href="css/app.css?__inline=true" />
+        <script src="js/app.js?__inline=true"></script>
+    </head>
+    <body class="th-dark">
+        <div class="app">
+            <noscript>
+                <h1>KeeWeb</h1>
+                <p>KeeWeb is a password manager written in JavaScript. Please enable JavaScript to run it.</p>
+            </noscript>
+        </div>
+    </body>
 </html>

app/lib/babel-helpers.js

@@ -0,0 +1,71 @@
+(function (global) {
+  var babelHelpers = global.babelHelpers = {};
+  babelHelpers.typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  };
+
+  babelHelpers.defineProperty = function (obj, key, value) {
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+
+    return obj;
+  };
+
+  babelHelpers.slicedToArray = function () {
+    function sliceIterator(arr, i) {
+      var _arr = [];
+      var _n = true;
+      var _d = false;
+      var _e = undefined;
+
+      try {
+        for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+          _arr.push(_s.value);
+
+          if (i && _arr.length === i) break;
+        }
+      } catch (err) {
+        _d = true;
+        _e = err;
+      } finally {
+        try {
+          if (!_n && _i["return"]) _i["return"]();
+        } finally {
+          if (_d) throw _e;
+        }
+      }
+
+      return _arr;
+    }
+
+    return function (arr, i) {
+      if (Array.isArray(arr)) {
+        return arr;
+      } else if (Symbol.iterator in Object(arr)) {
+        return sliceIterator(arr, i);
+      } else {
+        throw new TypeError("Invalid attempt to destructure non-iterable instance");
+      }
+    };
+  }();
+
+  babelHelpers.toConsumableArray = function (arr) {
+    if (Array.isArray(arr)) {
+      for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
+
+      return arr2;
+    } else {
+      return Array.from(arr);
+    }
+  };
+})(typeof global === "undefined" ? self : global);

app/locales/base.json

@@ -0,0 +1,778 @@
+{
+  "retToApp": "return to app",
+  "name": "name",
+  "icon": "icon",
+  "title": "title",
+  "password": "password",
+  "user": "user",
+  "website": "website",
+  "tags": "tags",
+  "notes": "notes",
+  "entry": "entry",
+  "group": "group",
+  "noTitle": "no title",
+  "or": "or",
+  "history": "history",
+  "template": "template",
+  "templates": "templates",
+  "notImplemented": "Not Implemented",
+  "saveChanges": "Save changes",
+  "discardChanges": "Discard changes",
+  "advanced": "Advanced",
+  "shortcuts": "Shortcuts",
+  "help": "Help",
+  "settings": "Settings",
+  "plugins": "Plugins",
+  "ctrlKey": "ctrl",
+  "shiftKey": "shift",
+  "altKey": "alt",
+  "error": "error",
+  "oneMinute": "one minute",
+  "minutes": "{} minutes",
+  "oneHour": "one hour",
+  "hours": "{} hours",
+  "oneDay": "one day",
+  "days": "{} days",
+  "oneWeek": "one week",
+  "oneMonth": "one month",
+  "oneYear": "one year",
+  "cache": "cache",
+  "file": "file",
+  "device": "device",
+  "webdav": "WebDAV",
+  "dropbox": "Dropbox",
+  "gdrive": "Google Drive",
+  "onedrive": "OneDrive",
+  "menuAllItems": "All Items",
+  "menuColors": "Colors",
+  "menuTrash": "Trash",
+  "menuSetGeneral": "General",
+  "menuSetBrowser": "Browser",
+  "menuSetAbout": "About",
+  "menuSetDevices": "Devices",
+  "menuAlertNoTags": "No tags",
+  "menuAlertNoTagsBody": "You can add new tags while editing fields, in the Tags section.",
+  "menuEmptyTrash": "Empty Trash",
+  "menuEmptyTrashAlert": "Empty Trash?",
+  "menuEmptyTrashAlertBody": "You will not be able to put items back",
+  "menuItemCollapsed": "Double-click to expand",
+  "menuRestoreApp": "Open {}",
+  "menuQuitApp": "Quit {}",
+  "sysMenuAboutKeeWeb": "About {}",
+  "sysMenuServices": "Services",
+  "sysMenuHide": "Hide {}",
+  "sysMenuHideOthers": "Hide Others",
+  "sysMenuUnhide": "Show All",
+  "sysMenuQuit": "Quit {}",
+  "sysMenuEdit": "Edit",
+  "sysMenuUndo": "Undo",
+  "sysMenuRedo": "Redo",
+  "sysMenuCut": "Cut",
+  "sysMenuCopy": "Copy",
+  "sysMenuPaste": "Paste",
+  "sysMenuSelectAll": "Select All",
+  "sysMenuWindow": "Window",
+  "sysMenuMinimize": "Minimize",
+  "sysMenuClose": "Close Window",
+  "alertYes": "Yes",
+  "alertNo": "No",
+  "alertOk": "OK",
+  "alertCancel": "Cancel",
+  "alertSignIn": "Sign In",
+  "alertCopy": "Copy",
+  "alertClose": "Close",
+  "alertDoNotAsk": "Don't ask me anymore",
+  "alertAllow": "Allow",
+  "alertDeny": "Deny",
+  "appBeta": "WARNING: beta version, only for preview",
+  "footerOpen": "Open / New",
+  "footerSyncError": "Sync error",
+  "footerTitleGen": "Generate",
+  "footerTitleLock": "Lock",
+  "genLen": "Length",
+  "genNewPass": "New password",
+  "genPresetDefault": "default preset",
+  "genPresetDerived": "like old password",
+  "genPresetPronounceable": "pronounceable",
+  "genPresetMed": "medium length",
+  "genPresetLong": "long",
+  "genPresetPin4": "4-digit PIN",
+  "genPresetMac": "MAC address",
+  "genPresetHash128": "128-bit hash",
+  "genPresetHash256": "256-bit hash",
+  "genHidePass": "Hide password",
+  "genShowPass": "Show password",
+  "grpTitle": "Group",
+  "grpSearch": "Enable searching entries in this group",
+  "grpAutoType": "Enable auto-type",
+  "grpAutoTypeSeq": "Auto-type sequence",
+  "grpAutoTypeSeqDefault": "Use default auto-type sequence",
+  "grpTrash": "Delete group with all entries",
+  "tagTitle": "Tag",
+  "tagTrash": "Remove tag from all entries",
+  "tagRename": "Rename",
+  "tagTrashQuestion": "Remove tag from all entries?",
+  "tagTrashQuestionBody": "This tag will be removed from all entries. There will be no easy way to put it back.",
+  "tagExists": "Tag already exists",
+  "tagExistsBody": "Tag with this name already exists. Please choose another name.",
+  "tagBadName": "Bad name",
+  "tagBadNameBody": "Tag name cannot contain characters {}. Please remove them.",
+  "genPsTitle": "Generator Presets",
+  "genPsCreate": "New preset",
+  "genPsDelete": "Delete preset",
+  "genPsNew": "preset",
+  "genPsEnabled": "Show in presets list",
+  "genPsDefault": "Selected by default",
+  "genPsDefaultLength": "Default length",
+  "genPsUpper": "Uppercase latin letters",
+  "genPsLower": "Lowercase latin letters",
+  "genPsDigits": "Digits",
+  "genPsSpecial": "Special symbols",
+  "genPsBrackets": "Brackets",
+  "genPsHigh": "High ASCII characters",
+  "genPsAmbiguous": "Ambiguous symbols",
+  "genPsInclude": "Additional symbols to include",
+  "genPsExample": "Example of generated password",
+  "genPsPattern": "Pattern",
+  "genPsPatternHelp": "Patterns can be used to specify custom rules for selecting characters. For example, 1-AA will generate passwords starting with a digit, followed by a dash and two letters. You can use these symbols:",
+  "genPsAllRanges": "All symbols",
+  "genPsIncluded": "Additional symbols added above",
+  "keyChangeTitleRemote": "Master Key Changed",
+  "keyChangeMessageRemote": "Master key was changed for this database. Please enter a new key",
+  "keyChangeTitleExpired": "Master Key Expired",
+  "keyChangeMessageExpired": "Master key for this database is expired. Please enter a new key",
+  "keyChangeRepeatPassword": "Password, once again",
+  "keyEnter": "Enter",
+  "keyEsc": "Esc",
+  "iconFavTitle": "Download and use website favicon",
+  "iconSelCustom": "Select a custom icon",
+  "listEmptyTitle": "Empty",
+  "listEmptyAdd": "add with {} button above",
+  "listGroup": "Group",
+  "listNoWebsite": "no website",
+  "listNoUser": "no user",
+  "listNoAttachments": "no attachments",
+  "listAddTemplateHeader": "Templates",
+  "listAddTemplateBody1": "Templates allow you to create entries with one click. Add something to template entry and then click {} again to use this template.",
+  "listAddTemplateBody2": "You can always find your templates in {} group.",
+  "searchAddNew": "Add New",
+  "searchSort": "Sort",
+  "searchCreated": "Created",
+  "searchUpdated": "Updated",
+  "searchAttachments": "Attachments",
+  "searchAZ": "A {} Z",
+  "searchZA": "Z {} A",
+  "searchON": "Old {} New",
+  "searchNO": "New {} Old",
+  "searchShiftClickOr": "shift-click or",
+  "searchAdvTitle": "Toggle advanced search",
+  "searchSearchIn": "Search in",
+  "searchOther": "Other fields",
+  "searchProtect": "Secure fields",
+  "searchOptions": "Options",
+  "searchCase": "Match case",
+  "searchRegex": "RegEx",
+  "searchRank": "Auto",
+  "searchExact": "Exact",
+  "openOpen": "Open",
+  "openNew": "New",
+  "openNewFile": "New",
+  "openMore": "More",
+  "openDemo": "Demo",
+  "openGenerate": "Generate",
+  "openXml": "Import XML",
+  "openCaps": "Caps Lock is on",
+  "openClickToOpen": "Click to open a file",
+  "openKeyFile": "key file",
+  "openKeyFileDropbox": "(from dropbox)",
+  "openDropHere": "drop files here",
+  "openFailedRead": "Failed to read file",
+  "openNothingFound": "Nothing found",
+  "openNothingFoundBody": "We haven't found any suitable files.",
+  "openSelectFile": "Select a file",
+  "openSelectFileBody": "Select a file you would like to open",
+  "openPassFor": "Password for",
+  "openRemoveLastQuestion": "Delete local file?",
+  "openRemoveLastQuestionBody": "The file you are deleting is stored only inside the app. Delete it permanently?",
+  "openRemoveLastQuestionModBody": "The file you are deleting has local modifications. Delete it and discard these modifications?",
+  "openLocalFile": "Local file",
+  "openLocalFileBody": "You are going to open a file that will be stored inside the app. Changes you make will not be saved back to file system. To get the file with your data, export it from settings.",
+  "openLocalFileDontShow": "Don't show this again",
+  "openWrongFile": "Bad file",
+  "openWrongFileBody": "This file format is not supported. This app works with KeePass database format files (kdbx).",
+  "openKdbFileBody": "You are opening an old version format file (KDB). This app supports only new format (kdbx), please use KeePass v2 to convert between them.",
+  "openConfigHeader": "{} Settings",
+  "openUrl": "URL",
+  "openUrlDesc": "https://server/path/file.kdbx, or just file.kdbx",
+  "openUser": "User",
+  "openUserDesc": "WebDAV server user (if required)",
+  "openUserPlaceholder": "no user",
+  "openPass": "Password",
+  "openPassDesc": "WebDAV server password (this is not your file password)",
+  "openPassPlaceholder": "no password",
+  "openConfigError": "Error: {}",
+  "openConfigErrorNotFound": "File not found",
+  "openError": "Error",
+  "openErrorDescription": "There was an error opening file",
+  "openErrorDescriptionMaybeTouchIdChanged": "The error looks similar to what usually happens when Touch ID setup is changed, for example, you added or removed an additional finger. If it's the case, go to Settings, disable Touch ID, and re-enable it again.",
+  "openErrorFileNotFound": "File not found",
+  "openListErrorBody": "There was an error loading file list",
+  "openShowAllFiles": "Show all files",
+  "openFileNoCacheError": "File not found in the cache storage. This can happen because browser storage was cleaned up. To open the file, remove it from KeeWeb and add it again.",
+  "openChalRespHeader": "Challenge-Response",
+  "openChalRespLoading": "Loading the list of YubiKeys",
+  "openChalRespSelectYubiKey": "Select a YubiKey that you would like to use",
+  "openChalRespErrorEmpty": "No YubiKeys found.",
+  "openChalRespErrorEmptyMac": "First time using this feature on macOS? KeeWeb must be added to the Input Monitoring section of security settings.",
+  "detAttDownload": "Shift-click the attachment button to download it or",
+  "detAttDelToRemove": "Delete to remove",
+  "detAttSave": "Save as …",
+  "detEmpty": "Your passwords will be displayed here",
+  "detGroupRestore": "To restore this group, please drag it to any group outside trash",
+  "detHistoryClickPoint": "Click entry history timeline point to view state",
+  "detHistoryReturn": "return to entry",
+  "detHistoryRevert": "Revert to state",
+  "detHistoryDel": "Delete state",
+  "detHistoryEmpty": "empty",
+  "detHistoryModified": "modified",
+  "detHistoryRec": "record",
+  "detHistoryRecs": "records",
+  "detHistoryVersion": "Version",
+  "detHistorySaved": "Saved",
+  "detHistoryNoTitle": "no title",
+  "detHistoryCurState": "current state",
+  "detHistoryCurUnsavedState": "current unsaved state",
+  "detHistoryRevertAlert": "Revert to this history state?",
+  "detHistoryRevertAlertBody": "Your current state will be saved to history.",
+  "detHistoryDeleteAlert": "Delete this history state?",
+  "detHistoryDeleteAlertBody": "You will not be able to restore it.",
+  "detHistoryDiscardChangesAlert": "Discard changes made to entry?",
+  "detHistoryDiscardChangesAlertBody": "Unsaved changes will be lost, there will be no way back.",
+  "detBackToList": "back to list",
+  "detSetIconColor": "Change color",
+  "detSetIcon": "Change icon",
+  "detDropAttachments": "drop attachments here",
+  "detDelEntry": "Delete",
+  "detDelEntryPerm": "Delete permanently",
+  "detExpires": "Expires",
+  "detExpired": "expired",
+  "detGroup": "Group",
+  "detCreated": "Created",
+  "detUpdated": "Updated",
+  "detNetField": "New Field",
+  "detAttachments": "Attachments",
+  "detDelFromTrash": "Delete from trash?",
+  "detDelFromTrashBody": "You will not be able to put it back.",
+  "detDelFromTrashBodyHint": "To quickly remove all items from trash, click Empty icon in Trash menu.",
+  "detDelToTrash": "Delete the entry?",
+  "detDelToTrashBody": "The entry will be moved to the trash folder.",
+  "detFieldCopied": "Copied",
+  "detFieldCopiedTime": "Copied for {} seconds",
+  "detCopyHint": "You can copy field value by clicking its title",
+  "detMore": "more",
+  "detClickToAddField": "click to add a new field",
+  "detMenuAddNewField": "Add a new field",
+  "detMenuAddNewWebsite": "Add another website",
+  "detMenuShowEmpty": "Show empty fields",
+  "detMenuHideEmpty": "Hide empty fields",
+  "detMenuAddField": "Add {}",
+  "detMenuCopyPassword": "Copy password",
+  "detMenuCopyUser": "Copy user",
+  "detMenuCopyOtp": "Copy one-time code",
+  "detSetupOtp": "One-time codes",
+  "detClone": "Make a copy",
+  "detCopyEntryToClipboard": "Copy all fields",
+  "detClonedName": "Copy",
+  "detAutoType": "Auto-type",
+  "detAutoTypeSettings": "Auto-type settings",
+  "detAutoTypeEnabled": "Enable auto-type for this entry",
+  "detAutoTypeSequence": "Keystrokes",
+  "detAutoTypeInput": "Input",
+  "detAutoTypeShortcutsDesc": "{} or {} while the app is inactive",
+  "detAutoTypeObfuscation": "Mix real keystrokes with random",
+  "detAutoTypeWindow": "Window",
+  "detAutoTypeInputWindow": "Window title",
+  "detSetupOtpAlert": "Scan the QR code",
+  "detSetupOtpAlertBody": "Please copy the QR code which is displayed on the authorization page.",
+  "detSetupOtpAlertBody1": "1. go to the authorization page",
+  "detSetupOtpAlertBody2": "2. make a screenshot of the QR code {}",
+  "detSetupOtpAlertBody3": "3. paste it here {}",
+  "detSetupOtpAlertBody3Mobile": "3. select it or scan with your camera using Select/Scan button below",
+  "detSetupOtpAlertBody4": "If you can't scan the code, click Enter code manually",
+  "detSetupOtpManualButton": "Enter code manually",
+  "detSetupOtpScanButton": "Select/Scan",
+  "detSetupOtpAlertBodyWith": "with {}",
+  "detOtpImageError": "Error reading image",
+  "detOtpImageErrorBody": "Sorry, we could not read the image format, please contact the app authors with error details.",
+  "detOtpImageReading": "Reading QR code...",
+  "detOtpQrError": "QR code scan error",
+  "detOtpQrErrorBody": "Sorry, we could not read the QR code, please try once again or contact the app authors with error details.",
+  "detOtpQrWrong": "Wrong QR code",
+  "detOtpQrWrongBody": "Your QR code was successfully scanned but it doesn't contain one-time code data.",
+  "detOtpField": "One-time code",
+  "detOtpClickToTouch": "Click to generate",
+  "detOtpGenerating": "Generating...",
+  "detOtpTouch": "Touch your {}",
+  "detLockField": "Lock this field, so its content isn't searchable and visible. Displaying the content requires explicitly clicking it.",
+  "detUnlockField": "Unlock this field, making its content searchable and visible immediately",
+  "detRevealField": "Reveal",
+  "detHideField": "Hide",
+  "detAutoTypeField": "Auto type",
+  "detIssuesHideTooltip": "Hide this warning",
+  "detIssueWeakPassword": "The password is weak, it's recommended to change it.",
+  "detIssuePoorPassword": "The password is very weak, it's strongly recommended to change it.",
+  "detIssuePwnedPassword": "This password has been exposed in a data breach according to {}, it's recommended to change it.",
+  "detIssuePasswordCheckError": "There was an error checking password strength online.",
+  "detIssueOldPassword": "The password is old.",
+  "detIssueCloseAlertHeader": "Hide password issues",
+  "detIssueCloseAlertBody": "There are different ways you can hide this warning:",
+  "detIssueCloseAlertEntry": "Don't show for this entry",
+  "detIssueCloseAlertSettings": "Adjust global settings",
+  "autoTypeEntryFields": "Entry fields",
+  "autoTypeModifiers": "Modifier keys",
+  "autoTypeKeys": "Keys",
+  "autoTypeLink": "more...",
+  "autoTypeError": "Auto-type error",
+  "autoTypeErrorGeneric": "There was an error performing auto-type: {}",
+  "autoTypeErrorAccessibilityMacOS": "We tried to send keystrokes to the application, but it doesn't seem to work. This may happen because of missing permissions, click here to read more about it:",
+  "autoTypeErrorGlobal": "To use a system-wide shortcut, please focus the app where you want to type your password",
+  "autoTypeErrorNotInstalled": "{} is not installed",
+  "autoTypeHeader": "Auto-Type: Select",
+  "autoTypeMsgNoWindow": "We were unable to get active window title, start typing to search",
+  "autoTypeMsgMatchedByWindow": "Select a password for {}",
+  "autoTypeNoMatches": "no matches",
+  "autoTypeSelectionHint": "Type the autotype sequence",
+  "autoTypeSelectionHintAction": "Only type the password",
+  "autoTypeSelectionHintOpt": "Only type the username",
+  "autoTypeSelectionHintShift": "Other fields",
+  "autoTypeSelectionOtp": "One-time code",
+  "autoTypeUnlockMessage": "Unlock to auto-type",
+  "appSecWarn": "Not Secure!",
+  "appSecWarnBody1": "You have loaded this app with an insecure connection. Someone may be watching you and stealing your passwords. We strongly advise you to stop, unless you clearly understand what you're doing.",
+  "appSecWarnBody2": "Yes, your database is encrypted but no one can guarantee that the app has not been modified on the way to you.",
+  "appSecWarnBtn": "I understand the risks, continue",
+  "appUnsavedWarn": "Unsaved changes!",
+  "appUnsavedWarnBody": "You have unsaved files, if you close the app, changes will be lost.",
+  "appDontExitBtn": "Don't exit",
+  "appCannotLockAutoInit": "The app cannot be locked because autosave is disabled.",
+  "appCannotLock": "You have unsaved changes that will be lost. Continue?",
+  "appAutoSave": "Save changes automatically",
+  "appSaveError": "Save Error",
+  "appSaveErrorBody": "Failed to auto-save file",
+  "appSaveErrorBodyMul": "Failed to auto-save files:",
+  "appSaveErrorExitLoseChanges": "Quit and lose all changes",
+  "appSaveErrorExitLoseChangesBody": "You can either quit the app and lose all changes, or go file settings to export data",
+  "appSettingsError": "Error loading app",
+  "appSettingsErrorBody": "There was an error loading app settings. Please double check the app URL or contact your administrator.",
+  "appNotSupportedError": "Your browser doesn't support some important features we're using.",
+  "appTabWarn": "Too many tabs",
+  "appTabWarnBody": "KeeWeb cannot be used in two browser tabs simultaneously, please close this tab.",
+  "appRightsAlert": "Locking KeeWeb app",
+  "appRightsAlertBody1": "Your KeeWeb app is currently not guarded against unauthorized changes. We're asking you for permissions to make the app writable only for administrators.",
+  "appRightsAlertBody2": "Don't want to give permissions? You can do it yourself in Terminal",
+  "appBrowserAuthComplete": "Authentication is complete, you may close this tab now.",
+  "setGenTitle": "General Settings",
+  "setGenUpdate": "Update",
+  "setGenNewVersion": "New app version was released and downloaded",
+  "setGenReleaseNotes": "View release notes",
+  "setGenReloadToUpdate": "Reload to update",
+  "setGenUpdateManual": "A new version has been released. It will check for updates and install them automatically, but auto-upgrading from your version is not possible.",
+  "setGenDownloadUpdate": "Download update",
+  "setGenUpdateAuto": "Download and install automatically",
+  "setGenUpdateCheck": "Check but don't install",
+  "setGenNoUpdate": "Never check for updates",
+  "setGenUpdateChecking": "Checking for updates",
+  "setGenCheckUpdate": "Check for updates",
+  "setGenErrorChecking": "Error checking for updates",
+  "setGenLastCheckSuccess": "Last successful check was at {}",
+  "setGenLastCheckVer": "the latest version was {}",
+  "setGenCheckedAt": "Checked at",
+  "setGenLatestVer": "you are using the latest version",
+  "setGenNewVer": "new version {} available, released",
+  "setGenDownloadingUpdate": "Downloading update...",
+  "setGenExtractingUpdate": "Extracting update...",
+  "setGenCheckErr": "There was an error downloading new version",
+  "setGenNeverChecked": "Never checked for updates",
+  "setGenRestartToUpdate": "Restart KeeWeb to update",
+  "setGenDownloadAndRestart": "Download update and restart",
+  "setGenAppearance": "Appearance",
+  "setGenTheme": "Theme",
+  "setGenThemeDefault": "Default",
+  "setGenThemeDark": "Dark",
+  "setGenThemeLight": "Light",
+  "setGenThemeBlue": "Flat blue",
+  "setGenThemeFb": "Dark blue",
+  "setGenThemeBl": "Light blue",
+  "setGenThemeBrown": "Brownie",
+  "setGenThemeDb": "Dark brown",
+  "setGenThemeLb": "Light brown",
+  "setGenThemeTerminal": "Terminal",
+  "setGenThemeTe": "Terminal",
+  "setGenThemeLt": "Terminal light",
+  "setGenThemeHighContrast": "High contrast",
+  "setGenThemeHc": "High contrast",
+  "setGenThemeDc": "Dark contrast",
+  "setGenThemeSol": "Solarized",
+  "setGenThemeSd": "Solarized dark",
+  "setGenThemeSl": "Solarized light",
+  "setGenMoreThemes": "More themes",
+  "setGenAutoSwitchTheme": "Automatically switch between light and dark theme when possible",
+  "setGenLocale": "Language",
+  "setGenLocOther": "other languages are available as plugins",
+  "setGenFontSize": "Font size",
+  "setGenFontSizeNormal": "Normal",
+  "setGenFontSizeLarge": "Large",
+  "setGenFontSizeLargest": "Largest",
+  "setGenTitlebarStyle": "Window style (requires restart)",
+  "setGenTitlebarStyleDefault": "Default",
+  "setGenTitlebarStyleHidden": "Custom title",
+  "setGenTitlebarStyleHiddenInset": "Custom title, draggable window",
+  "setGenShowSubgroups": "Show entries from all subgroups",
+  "setGenTableView": "Entries list table view",
+  "setGenColorfulIcons": "Colorful custom icons in the list",
+  "setGenUseMarkdown": "Markdown in notes",
+  "setGenUseGroupIconForEntries": "Automatically use group icon for new entries",
+  "setGenDirectAutotype": "If only one matching entry is found, select that one automatically for auto-type",
+  "setGenAutoTypeTitleFilterEnabled": "Filter entries by title in auto-type",
+  "setGenFunction": "Function",
+  "setGenAutoSyncOnClose": "Automatically save and sync on close",
+  "setGenAutoSyncTimer": "Automatically save and sync periodically",
+  "setGenAutoSyncTimerOff": "Disabled",
+  "setGenAutoSyncTimerOnChange": "On every change",
+  "setGenAutoSyncTimerInterval": "Every {} minute(s)",
+  "setGenRememberKeyFiles": "Remember key files",
+  "setGenNoRememberKeyFiles": "Don't remember",
+  "setGenRememberKeyFilesData": "Store in the internal app storage",
+  "setGenRememberKeyFilesPath": "Remember only path to key files",
+  "setGenLockInactive": "If the app is inactive",
+  "setGenNoAutoLock": "Don't auto-lock",
+  "setGenLockMinutes": "In {} minutes",
+  "setGenLockHour": "In an hour",
+  "setGenLockHours": "In {} hours",
+  "setGenLockDay": "In a day",
+  "setGenClearClip": "Clear clipboard after copy",
+  "setGenNoClear": "Don't clear",
+  "setGenClearSeconds": "In {} seconds",
+  "setGenClearMinute": "In a minute",
+  "setGenMinInstead": "Minimize the app instead of close",
+  "setGenMinOnFieldCopy": "Minimize on field copy",
+  "setGenLock": "Auto lock",
+  "setGenLockMinimize": "When the app is minimized",
+  "setGenLockCopy": "On password copy",
+  "setGenLockAutoType": "On auto-type",
+  "setGenLockOrSleep": "When the computer is locked or put to sleep",
+  "setGenStorage": "Storage",
+  "setGenDisableOfflineStorage": "Don't cache loaded files in offline storage",
+  "setGenShortLivedStorageToken": "Use short-lived sessions in cloud storage providers",
+  "setGenStorageLogout": "Log out",
+  "setGenShowAdvanced": "Show advanced settings",
+  "setGenDevTools": "Show dev tools",
+  "setGenTryBeta": "Try beta version until restart",
+  "setGenTryBetaWarning": "Unsaved files",
+  "setGenTryBetaWarningBody": "Please save all files and click this button again",
+  "setGenShowAppLogs": "Show app logs",
+  "setGenReloadApp": "Reload the app",
+  "setGenFieldLabelDblClickAutoType": "Auto-type on double-clicking field labels",
+  "setGenTouchId": "Touch ID",
+  "setGenTouchIdDisabled": "Don't use Touch ID",
+  "setGenTouchIdMemory": "Unlock with Touch ID only while KeeWeb is running",
+  "setGenTouchIdFile": "Always use Touch ID instead of master password",
+  "setGenTouchIdPass": "Require master password after",
+  "setGenAudit": "Audit",
+  "setGenAuditPasswords": "Show warnings about password strength",
+  "setGenAuditPasswordEntropy": "Check password length and randomness",
+  "setGenExcludePinsFromAudit": "Never check short numeric PIN codes, such as 123456",
+  "setGenCheckPasswordsOnHIBP": "Check passwords using an online service {}",
+  "setGenHelpHIBP": "KeeWeb can check if your passwords have been previously exposed in a data breach using an online service. Your password cannot be recovered based on data sent online, however, the number of passwords checked this way may be exposed. More about your privacy when using this service can be found {}. If this option is enabled, KeeWeb will automatically check your passwords there.",
+  "setGenHelpHIBPLink": "here",
+  "setGenAuditPasswordAge": "Old passwords",
+  "setGenAuditPasswordAgeOff": "Don't show warnings about old passwords",
+  "setGenAuditPasswordAgeOneYear": "Show warnings for passwords older than one year",
+  "setGenAuditPasswordAgeYears": "Show warnings for passwords older than {} years",
+  "setFilePath": "File path",
+  "setFileStorage": "This file is loaded from {}.",
+  "setFileIntl": "This file is stored in the internal app storage",
+  "setFileLocalHint": "Want to work seamlessly with local files?",
+  "setFileDownloadApp": "Download a desktop app",
+  "setFileSave": "Save",
+  "setFileSaveTo": "Save to …",
+  "setFileClose": "Close",
+  "setFileSync": "Sync",
+  "setFileSyncVerb": "Sync",
+  "setFileSaveToXml": "XML",
+  "setFileSaveToHtml": "HTML",
+  "setFileLastSync": "Last sync",
+  "setFileLastSyncUnknown": "unknown",
+  "setFileSyncInProgress": "sync in progress",
+  "setFileSyncError": "Sync error",
+  "setFilePass": "Master password",
+  "setFileConfirmPass": "Confirm Master password",
+  "setFilePassChange": "to change your password, please type it in the Confirm field",
+  "setFilePassChanged": "your password was changed; leave the field blank to use the old password",
+  "setFilePassNotMatch": "passwords don't match, please type it again",
+  "setFileKeyFile": "Key file",
+  "setFileSelKeyFile": "Select a key file",
+  "setFileNames": "Names",
+  "setFileDefUser": "Default user",
+  "setFileEnableTrash": "Enable trash",
+  "setFileHistMode": "Entry history",
+  "setFileHistLimited": "Delete old history records automatically",
+  "setFileHistDisabled": "Don't save history",
+  "setFileHistUnlimited": "Keep history records forever",
+  "setFileHistLen": "History length, keep last records per entry",
+  "setFileHistSize": "History size, total MB per file",
+  "setFileBackups": "Backups",
+  "setFileBackupEnable": "Backup this file",
+  "setFileBackupPath": "Backup path",
+  "setFileBackupTime": "Make backups",
+  "setFileBackupNow": "Backup now",
+  "setFileBackupNowWorking": "Working...",
+  "setFileBackupError": "Backup error",
+  "setFileBackupErrorDescription": "Error writing backup file",
+  "setFileBackupErrorIsDir": "Backup path invalid",
+  "setFileBackupErrorIsDirDescription": "The backup path seems to point to a directory. Please specify a filename inside a directory instead.",
+  "setFileBackupOnSave": "Every time I save the file",
+  "setFileBackupDaily": "Daily",
+  "setFileBackupWeekly": "Weekly",
+  "setFileBackupMonthly": "Monthly",
+  "setFileBackupManually": "Manually, no auto-backups",
+  "setFileRounds": "Key encryption rounds",
+  "setFileKdfParams": "Key derivation function",
+  "setFileKdfParamsIter": "Iterations",
+  "setFileKdfParamsMem": "Memory, KB",
+  "setFileKdfParamsPar": "Parallelism",
+  "setFileKeyChangeForce": "Ask to change key after (days)",
+  "setFileUseKeyFile": "Use key file",
+  "setFileUseGenKeyFile": "Use the generated key file",
+  "setFileUseOldKeyFile": "Use the old key file",
+  "setFileGenKeyFile": "Generate a new key file",
+  "setFileDontUseKeyFile": "Don't use a key file",
+  "setFileEmptyPass": "Empty password",
+  "setFileEmptyPassBody": "Saving database with an empty password makes it completely unprotected. Do you really want to do it?",
+  "setFileSaveError": "Save error",
+  "setFileSaveErrorBody": "Error saving to file",
+  "setFileAlreadyExists": "Already exists",
+  "setFileAlreadyExistsBody": "File {} already exists. Overwrite it?",
+  "setFileUnsaved": "Unsaved changes",
+  "setFileUnsavedBody": "There are unsaved changes in this file",
+  "setFileCloseNoSave": "Close and lose changes",
+  "setFileDontClose": "Don't close",
+  "setFileFormatVersion": "File format",
+  "setFileExportRaw": "Exporting your passwords",
+  "setFileExportRawBody": "The exported file will contain your passwords, they will not be encrypted there. Would you like to proceed?",
+  "setFileDeviceIntro": "One-time codes from this {} will be displayed in the app.",
+  "setFileDeviceSettings": "Settings",
+  "setFileYubiKey": "YubiKey",
+  "setFileDontUseYubiKey": "Don't use a YubiKey",
+  "setFileRefreshYubiKeyList": "Refresh the list",
+  "setFileYubiKeyHeader": "YubiKey",
+  "setFileYubiKeyBody": "Using a YubiKey as a part of master key is dangerous and you may lose access to your passwords if something goes wrong. Have you made a backup of your file before changing this setting?",
+  "setFileYubiKeyErrorEmptyMac": "Looks like there's a YubiKey plugged in, but it's not visible. KeeWeb must be added to the Input Monitoring section of security settings to access YubiKeys.",
+  "setShTitle": "Shortcuts",
+  "setShShowAll": "show all items",
+  "setShColors": "show items with colors",
+  "setShTrash": "go to Trash",
+  "setShFind": "search, or just start typing",
+  "setShClearSearch": "clear search",
+  "setShCopyPass": "copy password or selected field",
+  "setShCopyUser": "copy user",
+  "setShCopyUrl": "copy website",
+  "setShAutoType": "auto-type selected entry",
+  "setShPrev": "go to previous item",
+  "setShNext": "go to next item",
+  "setShCreateEntry": "create entry",
+  "setShOpen": "open / new",
+  "setShSave": "save all files",
+  "setShGen": "generate password",
+  "setShSet": "app settings",
+  "setShCopyPassGlobal": "copy password",
+  "setShCopyOtp": "copy OTP",
+  "setShAutoTypeGlobal": "auto-type",
+  "setShCopyPassOnly": "copy password",
+  "setShRestoreApp": "open {}",
+  "setShGlobal": "These system-wide shortcuts work when the app is running in background. You can click them to select your own shortcut.",
+  "setShLock": "lock database",
+  "setShEdit": "Press a new key combination to set it as shortcut",
+  "setPlInstallTitle": "Install new plugins",
+  "setPlInstallDesc": "KeeWeb plugins add features, themes, and languages to KeeWeb. Plugins run with the same privileges as KeeWeb, they can access and manage all your passwords. Never install plugins you don't trust.",
+  "setPlInstallLabel": "Plugin URL",
+  "setPlInstallBtn": "Install",
+  "setPlInstallBtnProgress": "Installing",
+  "setPlUninstallBtn": "Uninstall",
+  "setPlDisableBtn": "Disable",
+  "setPlEnableBtn": "Enable",
+  "setPlUpdateBtn": "Update",
+  "setPlLocaleBtn": "Switch to this language",
+  "setPlThemeBtn": "Switch to this theme",
+  "setPlJs": "code",
+  "setPlCss": "styles",
+  "setPlLoc": "language",
+  "setPlCreatedBy": "Created by {}",
+  "setPlLoadTime": "took {} to load",
+  "setPlLastUpdate": "Last check for updates",
+  "setPlLoadError": "error loading plugin",
+  "setPlGalleryLoading": "Loading plugins, please wait a bit",
+  "setPlGalleryLoadError": "Error loading plugins",
+  "setPlInstallUrlTitle": "Add plugin from URL",
+  "setPlInstallUrlDesc": "If the plugin is not in the gallery, you can install it manually from URL",
+  "setPlOfficial": "Official KeeWeb plugin",
+  "setPlSearch": "Search for plugins",
+  "setPlDevelop": "Want to develop your own plugins?",
+  "setPlDevelopStart": "Start here",
+  "setPlTranslate": "Or you can {}",
+  "setPlTranslateLink": "translate the app to your language",
+  "setPlAutoUpdate": "Update automatically",
+  "setPlLoadGallery": "Load plugin gallery",
+  "setBrowserTitle": "Browser",
+  "setBrowserIntroDesktop": "KeeWeb can enter passwords using auto-type, however, a browser extension may be a more convenient way of doing it. KeeWeb supports two browser extensions:",
+  "setBrowserIntroKeeWebConnect": "the official KeeWeb extension, it's built with features of KeeWeb in mind, but you may miss some advanced capabilities that can be found in the other extension.",
+  "setBrowserIntroKeePassXcBrowser": "this extension was developed for KeePassXC, it's been on the market for a while and it is quite solid. The extension is not a part of KeeWeb and there may be compatibility issues.",
+  "setBrowserIntroWeb": "Install our browser extension to auto-fill passwords from KeeWeb on different pages. The browser extension will connect to a KeeWeb tab in your browser to fetch passwords. Click here to download the extension:",
+  "setBrowserNotEnabled": "Browser integration is not enabled, extensions won't be able to connect to KeeWeb. Use the checkboxes below to enable it:",
+  "setBrowserEnablePerBrowser": "Enable browser integration using the checkboxes below:",
+  "setBrowserFocusIfLocked": "Open KeeWeb if a browser extension tries to connect while there's no open file",
+  "setBrowserFocusIfEmpty": "Show the entry selection screen if there's no match found by URL",
+  "setBrowserOtherBrowsers": "Other browsers",
+  "setBrowserExtensionFor": "for {}",
+  "setBrowserExtensionNotSupported": "Not supported",
+  "setBrowserExtensionHelp": "How to install?",
+  "setBrowserExtensionInstall": "Install the extension",
+  "setBrowserExtensionKPXCWarnHeader": "{} will stop working",
+  "setBrowserExtensionKPXCWarnBody1": "Unfortunately it's not possible to connect one extension to several apps. If you connect the extension to KeeWeb, we'll overwrite its app association, which means that integration with {} will stop working. Even if you uncheck this checkbox, the association with {} won't be restored. To make it work again, configure browser integration in {} settings.",
+  "setBrowserExtensionKPXCWarnBody2": "Configure the extension to use KeeWeb?",
+  "setBrowserSessions": "Sessions",
+  "setBrowserSessionsEmpty": "No connected sessions.",
+  "setBrowserSessionsIntro": "These extensions are now connected to KeeWeb.",
+  "setBrowserSessionsActiveTooltip": "Active session",
+  "setBrowserSessionsActiveText": "This session is active. It can exchange data with KeeWeb based on the following permissions:",
+  "setBrowserSessionsInactiveTooltip": "Inactive session",
+  "setBrowserSessionsInactiveText": "This session is inactive. The extension is connected to KeeWeb, however, it hasn't tried to exchange data. When the extension requests anything, you will be able to choose what you want to share.",
+  "setBrowserSessionsDeniedTooltip": "Access denied",
+  "setBrowserSessionsDeniedText": "This session is inactive. The extension is connected to KeeWeb, however, you denied access to data.",
+  "setBrowserSessionsConnectedDate": "Connected",
+  "setBrowserSessionsTerminate": "Terminate this session",
+  "setBrowserSessionsAccessToFiles": "Allow access to files",
+  "setBrowserSessionsNoFileAccess": "The extension doesn't have access to any file, it won't be able to fetch passwords from KeeWeb.",
+  "setBrowserSessionsPasswordsRead": "Passwords read",
+  "setBrowserSessionsPasswordsWritten": "Passwords saved",
+  "setDevicesTitle": "Devices",
+  "setDevicesEnableUsb": "Enable interaction with USB devices",
+  "setDevicesYubiKeyIntro": "It's recommended to read {} before using a YubiKey.",
+  "setDevicesYubiKeyIntroLink": "this document",
+  "setDevicesYubiKeyToolsDesc": "To be able to use YubiKey in this mode, you need to install a tool called {}.",
+  "setDevicesYubiKeyToolsDesc2": "{} to get more information about this tool.",
+  "setDevicesYubiKeyToolsDescLink": "Click here",
+  "setDevicesYubiKeyToolsStatusChecking": "Checking if {} is installed",
+  "setDevicesYubiKeyToolsStatusOk": "{} is installed",
+  "setDevicesYubiKeyToolsStatusError": "{} is not installed or not working",
+  "setDevicesYubiKeyOtpTitle": "One-time codes",
+  "setDevicesYubiKeyOtpDesc": "YubiKey can be used to generate one-time codes for different services.",
+  "setDevicesYubiKeyOtpShowIcon": "Show the icon on the start screen",
+  "setDevicesYubiKeyOtpAutoOpen": "Automatically load one-time codes when there are open files",
+  "setDevicesYubiKeyOtpMatchEntries": "Show matching one-time codes in entries",
+  "setDevicesYubiKeyChalRespTitle": "Challenge-Response",
+  "setDevicesYubiKeyChalRespDesc": "It's also possible to use a YubiKey in challenge-response mode, so that a piece of private key used to encrypt files resides on a YubiKey.",
+  "setDevicesYubiKeyChalRespShow": "Show the option to use a YubiKey when opening files",
+  "setDevicesYubiKeyStuckWorkaround": "Reconnect the YubiKey if it seems to be stuck during loading",
+  "setDevicesYubiKeyRememberChalResp": "Remember challenge-response while the app is open",
+  "setAboutTitle": "About",
+  "setAboutBuilt": "This app is built with these awesome tools",
+  "setAboutLic": "License",
+  "setAboutLicComment": "The app itself and all included components are licensed under MIT license, unless otherwise specified",
+  "setAboutFirst": "This is an open-source app created by {}",
+  "setAboutSecond": "and licensed under {}.",
+  "setAboutSource": "The source code and issues are on {}.",
+  "setHelpFormat": "File Format",
+  "setHelpFormatBody": "This is a port of {} app built with web technologies. It understands files in KeePass format (kdbx). You can create such files (password databases) either in KeePass or in this app. The file format is 100% compatible and should be understood by both apps.",
+  "setHelpProblems": "Need some help?",
+  "setHelpProblems1": "If something goes wrong, please {}",
+  "setHelpProblems2": "or {}",
+  "setHelpOpenIssue": "open an issue on GitHub",
+  "setHelpContactLink": "contact the developer directly",
+  "setHelpAppInfo": "App information",
+  "setHelpOtherPlatforms": "Other platforms",
+  "setHelpDesktopApps": "Desktop apps",
+  "setHelpWebApp": "Web app",
+  "setHelpUpdates": "Updates",
+  "setHelpTwitter": "App twitter",
+  "dropboxSetupDesc": "Some configuration is required to use Dropbox in a self-hosted app. Please create your own Dropbox app and fill in its key below.",
+  "dropboxAppKey": "Dropbox app key",
+  "dropboxAppKeyDesc": "Copy the key from your Dropbox app (Developer settings)",
+  "dropboxAppKeyHint": "your app key",
+  "dropboxAppSecret": "Dropbox app secret",
+  "dropboxAppSecretDesc": "The secret can be found next to the app key",
+  "dropboxFolder": "App folder",
+  "dropboxFolderDesc": "If your app is linked to entire Dropbox (not app folder), set the folder with your kdbx files here",
+  "dropboxFolderSettingsDesc": "Select any folder in your Dropbox where files will be stored (root folder by default)",
+  "dropboxFolderPlaceholder": "default folder",
+  "dropboxLink": "Link the app to",
+  "dropboxLinkApp": "App folder (Apps/KeeWeb)",
+  "dropboxLinkFull": "Full Dropbox or any folder",
+  "dropboxLinkCustom": "Own Dropbox app",
+  "gdriveSharedWithMe": "Shared with me",
+  "gdriveSharedDrives": "Shared drives",
+  "webdavSaveMethod": "Save method",
+  "webdavSaveMove": "Upload a temporary file and move",
+  "webdavSavePut": "Overwrite the kdbx file with PUT",
+  "webdavNoLastModified": "Last-Modified HTTP header is absent",
+  "webdavStatReload": "Always reload the file instead of relying on Last-Modified HTTP header",
+  "launcherSave": "Save Passwords Database",
+  "launcherFileFilter": "KeePass files",
+  "authPopupRequired": "Pop-ups are blocked",
+  "authPopupRequiredBody": "Please allow pop-ups in your browser or try again.",
+  "exportFileInfo": "File information",
+  "exportHtmlName": "Name",
+  "exportHtmlDate": "Export date",
+  "exportGenerator": "Software",
+  "exportDescription": "This file is generated with {}.",
+  "exportEntries": "Entries",
+  "importCsvTitle": "Import from CSV",
+  "importCsvRun": "Import",
+  "importIgnoreField": "Ignore",
+  "importTo": "Entries will be imported to",
+  "importNewFile": "New file",
+  "yubiKeyStuckError": "The YubiKey seems to be stuck, auto-repair can be enabled in app settings.",
+  "yubiKeyNoKeyHeader": "YubiKey required",
+  "yubiKeyNoKeyBody": "Please insert your YubiKey with serial number {}",
+  "yubiKeySlot": "slot",
+  "yubiKeyTouchRequestedHeader": "Touch your YubiKey",
+  "yubiKeyTouchRequestedBody": "Please touch your YubiKey with serial number {}",
+  "yubiKeyDisabledErrorHeader": "USB is disabled",
+  "yubiKeyDisabledErrorBody": "YubiKey is required to open this file, please enable USB devices in settings.",
+  "yubiKeyErrorWithCode": "YubiKey error, code {}.",
+  "bioOpenAuthPrompt": "open \"{}\"",
+  "extensionErrorNoOpenFiles": "No open files",
+  "extensionErrorUserRejected": "The request was denied",
+  "extensionErrorNoMatches": "No matching logins",
+  "extensionErrorAlertDisplayed": "Cannot ask a question now because there's another dialog displayed, please try again",
+  "extensionConnectHeader": "Extension data exchange",
+  "extensionConnectIntro": "A browser extension that identifies itself as {} tries to exchange data with KeeWeb.",
+  "extensionConnectUnknownActivity": "KeeWeb doesn't verify that the connected application is what it pretends to be. Approve the request only if you recognize this activity.",
+  "extensionConnectFiles": "In this session, allow access to:",
+  "extensionConnectAllOtherFiles": "All other files",
+  "extensionConnectAllFiles": "All files",
+  "extensionConnectAskGet": "Ask before returning passwords to the extension:",
+  "extensionConnectAskGetMultiple": "if there's more than one match",
+  "extensionConnectAskGetAlways": "always",
+  "extensionConnectAskSave": "Ask before saving new passwords to KeeWeb:",
+  "extensionConnectAskSaveAlways": "always",
+  "extensionConnectAskSaveAuto": "when it's not possible to save automatically",
+  "extensionConnectSettingsAreForSession": "Settings you select here are valid only for the active session. You can view and manage sessions in KeeWeb settings.",
+  "extensionUnlockMessage": "Unlock to connect a browser extension",
+  "extensionNewGroupHeader": "New group",
+  "extensionNewGroupBody": "{} is trying to create a new group. Allow this?",
+  "extensionNewGroupPath": "Group path",
+  "extensionNewGroupFile": "This group will be created in:",
+  "extensionSaveEntryHeader": "Save password",
+  "extensionSaveEntryBody": "{} is trying to save a password. Allow this?",
+  "extensionSaveEntryAuto": "Save other passwords automatically in this session",
+  "extensionSaveEntryNewGroup": "new group",
+  "extensionSelectPasswordFor": "Select a password for {}",
+  "selectEntryHeader": "Select entry",
+  "selectEntryEnterHint": "use the highlighted entry",
+  "selectEntryTypingHint": "Start typing to filter",
+  "selectEntryContains": "Contains text",
+  "selectEntrySubdomains": "Subdomains",
+  "selectEntryFieldHeader": "Select field",
+  "selectEntryFieldTouch": "Press the button on your device to generate a one-time code."
+}

app/locales/de-DE.json

@@ -0,0 +1,695 @@
+{
+  "retToApp": "zurück zur App",
+  "name": "Name",
+  "icon": "Icon",
+  "title": "Titel",
+  "password": "Passwort",
+  "user": "Benutzer",
+  "website": "Website",
+  "tags": "Tags",
+  "notes": "Notizen",
+  "entry": "Eintrag",
+  "group": "Gruppe",
+  "noTitle": "Kein Titel",
+  "or": "oder",
+  "history": "Verlauf",
+  "template": "Vorlage",
+  "templates": "Vorlagen",
+  "notImplemented": "Nicht implementiert",
+  "saveChanges": "Änderungen speichern",
+  "discardChanges": "Änderungen verwerfen",
+  "advanced": "Erweiterte Einstellungen",
+  "shortcuts": "Tastenkürzel",
+  "help": "Hilfe",
+  "settings": "Einstellungen",
+  "plugins": "Plugins",
+  "ctrlKey": "Strg",
+  "shiftKey": "Umschalt",
+  "altKey": "Alt",
+  "error": "Fehler",
+  "oneMinute": "Eine Minute",
+  "minutes": "{} Minuten",
+  "oneHour": "Eine Stunde",
+  "hours": "{} Stunden",
+  "oneDay": "Ein Tag",
+  "days": "{} Tage",
+  "oneWeek": "Eine Woche",
+  "oneMonth": "Ein Monat",
+  "oneYear": "Ein Jahr",
+  "cache": "Cache",
+  "file": "Datei",
+  "device": "Gerät",
+  "webdav": "WebDAV",
+  "dropbox": "Dropbox",
+  "gdrive": "Google Drive",
+  "onedrive": "OneDrive",
+  "menuAllItems": "Alle Einträge",
+  "menuColors": "Farben",
+  "menuTrash": "Papierkorb",
+  "menuSetGeneral": "Allgemein",
+  "menuSetAbout": "Info",
+  "menuSetDevices": "Geräte",
+  "menuAlertNoTags": "Keine Tags",
+  "menuAlertNoTagsBody": "Neue Tags können durch das Bearbeiten von Einträgen (Abschnitt „Tags“) hinzugefügt werden.",
+  "menuEmptyTrash": "Papierkorb leeren",
+  "menuEmptyTrashAlert": "Papierkorb leeren?",
+  "menuEmptyTrashAlertBody": "Die Einträge können nicht wiederhergestellt werden",
+  "menuItemCollapsed": "Doppelklick zum Aufklappen",
+  "menuRestoreApp": "{} öffnen",
+  "menuQuitApp": "{} beenden",
+  "sysMenuAboutKeeWeb": "Über {}",
+  "sysMenuServices": "Dienste",
+  "sysMenuHide": "{} ausblenden",
+  "sysMenuHideOthers": "Andere ausblenden",
+  "sysMenuUnhide": "Alle anzeigen",
+  "sysMenuQuit": "{} beenden",
+  "sysMenuEdit": "Bearbeiten",
+  "sysMenuUndo": "Rückgängig",
+  "sysMenuRedo": "Wiederherstellen",
+  "sysMenuCut": "Ausschneiden",
+  "sysMenuCopy": "Kopieren",
+  "sysMenuPaste": "Einfügen",
+  "sysMenuSelectAll": "Alles auswählen",
+  "sysMenuWindow": "Fenster",
+  "sysMenuMinimize": "Minimieren",
+  "sysMenuClose": "Fenster schließen",
+  "alertYes": "Ja",
+  "alertNo": "Nein",
+  "alertOk": "OK",
+  "alertCancel": "Abbrechen",
+  "alertSignIn": "Anmelden",
+  "alertCopy": "Kopieren",
+  "alertClose": "Schließen",
+  "alertDoNotAsk": "Nicht mehr nachfragen",
+  "appBeta": "ACHTUNG: Beta-Version, nur für Vorschau-Zwecke",
+  "footerOpen": "Öffnen / Neu",
+  "footerSyncError": "Synchronisierungsfehler",
+  "footerTitleGen": "Generieren",
+  "footerTitleLock": "Sperren",
+  "genLen": "Länge",
+  "genNewPass": "Neues Passwort",
+  "genPresetDefault": "Standardeinstellung",
+  "genPresetDerived": "Wie das alte Passwort",
+  "genPresetPronounceable": "aussprechbar",
+  "genPresetMed": "Durchschnittliche Länge",
+  "genPresetLong": "lang",
+  "genPresetPin4": "4-stellige PIN",
+  "genPresetMac": "MAC-Adresse",
+  "genPresetHash128": "128-Bit-Hash",
+  "genPresetHash256": "256-Bit-Hash",
+  "genHidePass": "Passwort ausblenden",
+  "genShowPass": "Passwort einblenden",
+  "grpTitle": "Gruppe",
+  "grpSearch": "Suche für Einträge in dieser Gruppe aktivieren",
+  "grpAutoType": "Auto-Type aktivieren",
+  "grpAutoTypeSeq": "Auto-Type-Sequenz",
+  "grpAutoTypeSeqDefault": "Standard-Auto-Type-Sequenz verwenden",
+  "grpTrash": "Gruppe und alle enthaltenen Einträge löschen",
+  "tagTitle": "Tag",
+  "tagTrash": "Diesen Tag von allen Einträgen entfernen",
+  "tagRename": "Umbenennen",
+  "tagTrashQuestion": "Diesen Tag von allen Einträgen entfernen?",
+  "tagTrashQuestionBody": "Der Tag wird von allen Einträgen entfernt. Diese Aktion kann nicht rückgängig gemacht werden.",
+  "tagExists": "Tag existiert bereits",
+  "tagExistsBody": "Ein Tag mit diesem Namen ist bereits vorhanden. Bitte einen anderen Namen wählen.",
+  "tagBadName": "Ungültiger Name",
+  "tagBadNameBody": "Der Tag-Name darf folgende Zeichen nicht enthalten: {}. Bitte diese entfernen.",
+  "genPsTitle": "Generator-Voreinstellungen",
+  "genPsCreate": "Neue Voreinstellung",
+  "genPsDelete": "Voreinstellung löschen",
+  "genPsNew": "Voreinstellung",
+  "genPsEnabled": "In Voreinstellungsliste anzeigen",
+  "genPsDefault": "Standardmäßig ausgewählt",
+  "genPsDefaultLength": "Standardlänge",
+  "genPsUpper": "Lateinische Großbuchstaben",
+  "genPsLower": "Lateinische Kleinbuchstaben",
+  "genPsDigits": "Ziffern",
+  "genPsSpecial": "Sonderzeichen",
+  "genPsBrackets": "Klammern",
+  "genPsHigh": "Erweiterte ASCII-Zeichen",
+  "genPsAmbiguous": "Ähnliche Zeichen",
+  "genPsInclude": "Zusätzliche Symbole angeben",
+  "genPsExample": "Beispiel für ein generiertes Passwort",
+  "genPsPattern": "Muster",
+  "genPsPatternHelp": "Mit Mustern können eigene Regeln zur Auswahl von Zeichen festgelegt werden. Beispielsweise werden mit 1-AA Passwörter generiert, die mit einer Ziffer starten, gefolgt von einem Bindestrich und zwei Großbuchstaben. Folgende Symbole stehen zur Verfügung:",
+  "genPsAllRanges": "Alle Zeichen",
+  "genPsIncluded": "Zusätzliche oben hinzugefügte Zeichen",
+  "keyChangeTitleRemote": "Hauptschlüssel geändert",
+  "keyChangeMessageRemote": "Der Hauptschlüssel für diese Datenbank wurde geändert. Bitte das neue Passwort eingeben.",
+  "keyChangeTitleExpired": "Hauptschlüssel abgelaufen",
+  "keyChangeMessageExpired": "Der Hauptschlüssel für diese Datenkbank ist abgelaufen. Bitte geben Sie einen neuen Schlüssel ein.",
+  "keyChangeRepeatPassword": "Passwort (Wiederholung)",
+  "keyEnter": "Enter",
+  "iconFavTitle": "Website-Symbol herunterladen und verwenden",
+  "iconSelCustom": "Eigenes Icon auswählen",
+  "listEmptyTitle": "Leer",
+  "listEmptyAdd": "Zum Anlegen neuer Einträge den obigen {} Button benutzen",
+  "listGroup": "Gruppe",
+  "listNoWebsite": "keine Website",
+  "listNoUser": "kein Benutzer",
+  "listNoAttachments": "keine Anhänge",
+  "listAddTemplateHeader": "Vorlagen",
+  "listAddTemplateBody1": "Vorlagen ermöglichen es, Einträge mit nur einem Klick zu erstellen. Fügen Sie etwas zum Vorlage-Eintrag hinzu und klicken Sie auf {}, um diese Vorlage zu verwenden.",
+  "listAddTemplateBody2": "Sie können Ihre Vorlagen in der Gruppe “{}” finden.",
+  "searchAddNew": "Hinzufügen",
+  "searchSort": "Sortierung",
+  "searchCreated": "Erstelldatum",
+  "searchUpdated": "Änderungsdatum",
+  "searchAttachments": "Anhänge",
+  "searchAZ": "A {} Z",
+  "searchZA": "Z {} A",
+  "searchON": "Alt {} Neu",
+  "searchNO": "Neu {} Alt",
+  "searchShiftClickOr": "Umschalt-Klick oder",
+  "searchAdvTitle": "Erweiterte Suche",
+  "searchSearchIn": "Durchsuchen",
+  "searchOther": "Andere Felder",
+  "searchProtect": "Geschützte Felder",
+  "searchOptions": "Suchoptionen",
+  "searchCase": "Groß/klein",
+  "searchRegex": "RegEx",
+  "searchRank": "Automatisch",
+  "searchExact": "Exakt",
+  "openOpen": "Öffnen",
+  "openNew": "Neu",
+  "openNewFile": "Neu",
+  "openMore": "Mehr",
+  "openDemo": "Demo",
+  "openGenerate": "Generieren",
+  "openXml": "XML importieren",
+  "openCaps": "Feststelltaste ist aktiviert",
+  "openClickToOpen": "Hier klicken, um eine Datei zu öffnen",
+  "openKeyFile": "Schlüsseldatei",
+  "openKeyFileDropbox": "(von Dropbox)",
+  "openDropHere": "Dateien hier ablegen",
+  "openFailedRead": "Datei konnte nicht gelesen werden",
+  "openNothingFound": "Nichts gefunden",
+  "openNothingFoundBody": "Es konnten keine kompatiblen Dateien gefunden werden.",
+  "openSelectFile": "Datei auswählen",
+  "openSelectFileBody": "Wählen Sie eine Datei zum Öffnen aus",
+  "openPassFor": "Passwort für",
+  "openRemoveLastQuestion": "Lokale Datei löschen?",
+  "openRemoveLastQuestionBody": "Die Datei, die Sie löschen möchten, ist nur innerhalb der App gespeichert. Möchten Sie diese unwiederbringlich löschen?",
+  "openRemoveLastQuestionModBody": "Die Datei, die Sie löschen möchten, beinhaltet lokale Änderungen. Möchten Sie diese Änderungen verwerfen und die Datei löschen?",
+  "openLocalFile": "Lokale Datei",
+  "openLocalFileBody": "Sie sind dabei, eine Datei zu öffnen, die innerhalb der App gespeichert wird. Wenn Sie an dieser Datei Änderungen vornehmen, werden diese nicht im Dateisystem gespeichert. Um die Datei mit den Änderungen zu erhalten, können Sie diese aus den Einstellungen heraus exportieren.",
+  "openLocalFileDontShow": "Nicht wieder anzeigen",
+  "openWrongFile": "Inkompatibles Dateiformat",
+  "openWrongFileBody": "Dieses Dateiformat ist nicht kompatibel. Die App unterstützt KeePass-Datenbanken im kdbx-Format.",
+  "openKdbFileBody": "Sie versuchen, eine alte KeePass-Datenbank im kdb-Format zu öffnen. Diese App unterstützt nur das neuere kdbx-Format. Bitte verwenden Sie KeePass v2, um diese Datei umzuwandeln.",
+  "openConfigHeader": "{} Einstellungen",
+  "openUrl": "URL",
+  "openUrlDesc": "https://server/pfad/datei.kdbx, oder einfach datei.kdbx",
+  "openUser": "Benutzername",
+  "openUserDesc": "WebDAV-Server-Benutzername (falls erforderlich)",
+  "openUserPlaceholder": "kein Benutzername",
+  "openPass": "Passwort",
+  "openPassDesc": "WebDAV-Server-Passwort (nicht das KDBX-Datei-Passwort)",
+  "openPassPlaceholder": "kein Passwort",
+  "openConfigError": "Fehler: {}",
+  "openConfigErrorNotFound": "Datei nicht gefunden",
+  "openError": "Fehler",
+  "openErrorDescription": "Beim Öffnen der Datei ist ein Fehler aufgetreten",
+  "openErrorFileNotFound": "Datei nicht gefunden",
+  "openListErrorBody": "Dateien konnten nicht geladen werden",
+  "openShowAllFiles": "Alle Dateien anzeigen",
+  "openFileNoCacheError": "Die Datei wurde im Cache-Speicher nicht gefunden. Möglicherweise wurde Ihr Browser-Speicher geleert. Um die Datei zu öffnen, entfernen Sie sie aus KeeWeb und fügen Sie sie erneut hinzu",
+  "openChalRespHeader": "Challenge-Response",
+  "openChalRespLoading": "Liste mit YubiKeys wird geladen",
+  "openChalRespSelectYubiKey": "Wählen Sie den YubiKey aus, den Sie benutzen wollen",
+  "openChalRespErrorEmpty": "Keine YubiKeys gefunden.",
+  "openChalRespErrorEmptyMac": "Verwenden Sie dieses Feature zum ersten Mal auf MacOS? KeeWeb muss in Ihren Sicherheitseinstellung im Input-Monitoring-Abschnitt hinzugefügt werden.",
+  "detAttDownload": "Umschalttaste + Klick auf den Anhang-Button zum Herunterladen oder",
+  "detAttDelToRemove": "Backspace zum Entfernen",
+  "detAttSave": "Speichern unter …",
+  "detEmpty": "Ihre Passwörter werden hier angezeigt",
+  "detGroupRestore": "Ziehen Sie diese Gruppe in eine andere Gruppe als den Papierkorb, um sie wiederherzustellen.",
+  "detHistoryClickPoint": "Klicken Sie auf einen der Punkte im Verlauf, um den entsprechenden Zustand des Eintrags anzuzeigen",
+  "detHistoryReturn": "zurück zum Eintrag",
+  "detHistoryRevert": "Auf diese Version zurücksetzen",
+  "detHistoryDel": "Version löschen",
+  "detHistoryEmpty": "leer",
+  "detHistoryModified": "geändert",
+  "detHistoryRec": "Version",
+  "detHistoryRecs": "Versionen",
+  "detHistoryVersion": "Version",
+  "detHistorySaved": "Gespeichert",
+  "detHistoryNoTitle": "keine Bezeichnung",
+  "detHistoryCurState": "aktuelle Version",
+  "detHistoryCurUnsavedState": "aktuelle ungespeicherte Version",
+  "detHistoryRevertAlert": "Zu diesem Stand zurückkehren?",
+  "detHistoryRevertAlertBody": "Ihr aktueller Stand wird in der Historie gesichert.",
+  "detHistoryDeleteAlert": "Diesen Stand löschen?",
+  "detHistoryDeleteAlertBody": "Sie können ihn nicht wiederherstellen.",
+  "detHistoryDiscardChangesAlert": "Änderungen an diesem Eintrag verwerfen?",
+  "detHistoryDiscardChangesAlertBody": "Ungespeicherte Änderungen gehen dabei unwiderruflich verloren.",
+  "detBackToList": "zurück zur Liste",
+  "detSetIconColor": "Farbe ändern",
+  "detSetIcon": "Symbol ändern",
+  "detDropAttachments": "Anhänge hier ablegen",
+  "detDelEntry": "Löschen",
+  "detDelEntryPerm": "Dauerhaft löschen",
+  "detExpires": "Ablaufdatum",
+  "detExpired": "abgelaufen",
+  "detGroup": "Gruppe",
+  "detCreated": "Erstellt",
+  "detUpdated": "Geändert",
+  "detNetField": "Neues Feld",
+  "detAttachments": "Anhänge",
+  "detDelFromTrash": "Aus dem Papierkorb löschen?",
+  "detDelFromTrashBody": "Es wird keine Möglichkeit zur Wiederherstellung geben.",
+  "detDelFromTrashBodyHint": "Um alle Dateien aus dem Papierkorb zu entfernen, klicken Sie auf das „Papierkorb leeren“-Symbol im Papierkorb-Menüpunkt.",
+  "detDelToTrash": "Diesen Eintrag löschen?",
+  "detDelToTrashBody": "Der Eintrag wird in den Papierkorb verschoben.",
+  "detFieldCopied": "Kopiert",
+  "detFieldCopiedTime": "Kopiert für {} Sekunden",
+  "detCopyHint": "Sie können den Inhalt eines Feldes kopieren, indem Sie auf seine Beschriftung klicken",
+  "detMore": "mehr",
+  "detClickToAddField": "Klicken, um ein neues Feld hinzuzufügen",
+  "detMenuAddNewField": "Neues Feld hinzufügen",
+  "detMenuShowEmpty": "Leere Felder anzeigen",
+  "detMenuHideEmpty": "Leere Felder ausblenden",
+  "detMenuAddField": "{} hinzufügen",
+  "detMenuCopyPassword": "Passwort kopieren",
+  "detMenuCopyUser": "Benutzer kopieren",
+  "detMenuCopyOtp": "Einmal-Code kopieren",
+  "detSetupOtp": "Einmal-Codes",
+  "detClone": "Kopie erstellen",
+  "detCopyEntryToClipboard": "Alle Felder kopieren",
+  "detClonedName": "Kopie",
+  "detAutoType": "Auto-Type",
+  "detAutoTypeSettings": "Auto-Type Einstellungen",
+  "detAutoTypeEnabled": "Auto-Type für diesen Eintrag aktivieren",
+  "detAutoTypeSequence": "Tastenfolge",
+  "detAutoTypeInput": "Eingabe",
+  "detAutoTypeShortcutsDesc": "{} oder {} während die App inaktiv ist",
+  "detAutoTypeObfuscation": "Echte Tastenanschläge mit zufälligen mischen",
+  "detAutoTypeWindow": "Fenster",
+  "detAutoTypeInputWindow": "Fenstertitel",
+  "detSetupOtpAlert": "QR-Code einscannen",
+  "detSetupOtpAlertBody": "Bitte kopieren Sie den QR-Code, der auf der Autorisierungsseite angezeigt wird.",
+  "detSetupOtpAlertBody1": "1. Gehen Sie zur Autorisierungsseite",
+  "detSetupOtpAlertBody2": "2. Erstellen Sie einen Screenshot des QR-Codes {}",
+  "detSetupOtpAlertBody3": "3. Fügen Sie ihn hier ein {}",
+  "detSetupOtpAlertBody3Mobile": "3. Markieren Sie ihn oder scannen Sie ihn mit Ihrer Kamera mit dem untenstehenden Markieren/Scannen-Button",
+  "detSetupOtpAlertBody4": "Wenn Sie den Code nicht einscannen können, klicken Sie bitte auf “Code manuell eingeben”",
+  "detSetupOtpManualButton": "Code manuell eingeben",
+  "detSetupOtpScanButton": "Markieren/Scannen",
+  "detSetupOtpAlertBodyWith": "mit {}",
+  "detOtpImageError": "Fehler beim Einlesen des Bildes",
+  "detOtpImageErrorBody": "Entschuldigung, wir konnten das Bildformat nicht lesen. Bitte kontaktieren Sie den Hersteller mit Einzelheiten zu diesem Fehler.",
+  "detOtpImageReading": "QR-Code wird eingelesen …",
+  "detOtpQrError": "QR-Code Lesefehler",
+  "detOtpQrErrorBody": "Der QR-Code konnte leider nicht eingelesen werden. Bitte versuchen Sie es noch einmal oder kontaktieren Sie den Hersteller mit Einzelheiten zum aufgetretenen Fehler.",
+  "detOtpQrWrong": "Fehlerhafter QR-Code",
+  "detOtpQrWrongBody": "Ihr QR-Code wurde erfolgreich eingelesen, enthält jedoch keinen Einmal-Code.",
+  "detOtpField": "Einmal-Code",
+  "detOtpClickToTouch": "Zum Erzeugen hier klicken",
+  "detOtpGenerating": "Wird erzeugt …",
+  "detOtpTouch": "Berühren Sie Ihren {}",
+  "detLockField": "Dieses Feld sperren, damit der Inhalt nicht durchsuchbar ist und angezeigt wird. Um ihn anzuzeigen, muss er angeklickt werden.",
+  "detUnlockField": "Dieses Feld entsperren. Dies führt dazu, dass der Inhalt direkt angezeigt wird und durchsuchbar ist.",
+  "detRevealField": "Anzeigen",
+  "detHideField": "Verbergen",
+  "detAutoTypeField": "Auto-Type",
+  "detIssuesHideTooltip": "Diese Warnung verstecken",
+  "detIssueWeakPassword": "Das Passwort ist schwach, es wird empfohlen es zu ändern.",
+  "detIssuePoorPassword": "Das Passwort ist schwach, es wird dringend empfohlen es zu ändern.",
+  "detIssuePwnedPassword": "Dieses Passwort wurde laut {} in einem Datenleck gefunden, es wird empfohlen das Passwort zu ändern.",
+  "detIssuePasswordCheckError": "Es gab einen Fehler bei der online-überprüfung des Passwort.",
+  "detIssueOldPassword": "Das Passwort ist alt.",
+  "detIssueCloseAlertHeader": "Verstecke Passwortmeldungen",
+  "detIssueCloseAlertBody": "Es gibt verschiedene Möglichkeiten diese Warnung zu verstecken:",
+  "detIssueCloseAlertEntry": "Nicht für diesen Eintrag anzeigen.",
+  "detIssueCloseAlertSettings": "Globale Einstellungen anpassen",
+  "autoTypeEntryFields": "Feld-Platzhalter",
+  "autoTypeModifiers": "Hilfstasten",
+  "autoTypeKeys": "Tasten",
+  "autoTypeLink": "mehr …",
+  "autoTypeError": "Auto-Type-Fehler",
+  "autoTypeErrorGeneric": "Während der Ausführung von Auto-Type ist ein Fehler aufgetreten: {}",
+  "autoTypeErrorGlobal": "Um globale Tastenkürzel zu nutzen, wechseln Sie bitte zu der Anwendung, in der Sie das Passwort eingeben wollen.",
+  "autoTypeErrorNotInstalled": "{} ist nicht installiert",
+  "autoTypeHeader": "Auto-Type: Auswählen",
+  "autoTypeMsgNoWindow": "Wir konnten den Titel des aktiven Fensters leider nicht auslesen. Fangen Sie einfach an zu tippen, um nach dem richtigen Eintrag zu suchen.",
+  "autoTypeMsgMatchedByWindow": "Passwort auswählen für {}",
+  "autoTypeNoMatches": "keine passenden Einträge",
+  "autoTypeSelectionHint": "Die Auto-Type-Sequenz eintippen",
+  "autoTypeSelectionHintAction": "Nur das Passwort eintippen",
+  "autoTypeSelectionHintOpt": "Nur den Benutzernamen eintippen",
+  "autoTypeSelectionHintShift": "Andere Felder",
+  "autoTypeSelectionOtp": "Einmal-Code",
+  "appSecWarn": "Unsichere Verbindung!",
+  "appSecWarnBody1": "Sie haben diese App über eine ungesicherte Verbindung geöffnet, Sie könnten beobachtet und Ihre Passwörter könnten gestohlen werden. Wir empfehlen Ihnen dringend, die App hier nicht weiter zu nutzen, wenn Sie nicht genau wissen, was Sie tun.",
+  "appSecWarnBody2": "Ihre Datenbank ist zwar verschlüsselt, aber es kann nicht sichergestellt werden, dass die App nicht auf dem Web vom Server zu Ihrem Browser manipuliert wurde.",
+  "appSecWarnBtn": "Ich habe das Risiko verstanden, trotzdem fortfahren",
+  "appUnsavedWarn": "Ungespeicherte Änderungen!",
+  "appUnsavedWarnBody": "Sie haben ungespeicherte Änderungen. Wenn Sie die App schließen, gehen diese verloren.",
+  "appDontExitBtn": "App nicht verlassen",
+  "appCannotLockAutoInit": "Die App kann nicht gesperrt werden, da automatisches Speichern deaktiviert ist.",
+  "appCannotLock": "Sie haben ungespeicherte Änderungen, die verloren gehen. Fortfahren?",
+  "appAutoSave": "Änderungen automatisch speichern",
+  "appSaveError": "Fehler beim Speichern",
+  "appSaveErrorBody": "Automatisches Speichern fehlgeschlagen",
+  "appSaveErrorBodyMul": "Automatisches Speichern fehlgeschlagen:",
+  "appSaveErrorExitLoseChanges": "Schließen und alle Änderungen verlieren",
+  "appSaveErrorExitLoseChangesBody": "Du kannst entweder die App schließen und alle Änderungen verlieren, oder gehe in die Dateieinstellungen und exportiere die Daten",
+  "appSettingsError": "Fehler beim Laden der App",
+  "appSettingsErrorBody": "Es gab einen Fehler beim Laden der App-Einstellungen. Bitte überprüfen Sie die App-URL oder kontaktieren Sie Ihren Systemadministrator.",
+  "appNotSupportedError": "Ihr Browser unterstützt einige wichtige Funktionen nicht, die für diese App benötigt werden.",
+  "appTabWarn": "Zu viele Tabs",
+  "appTabWarnBody": "KeeWeb kann nicht in mehreren Browser-Tabs gleichzeitig genutzt werden, bitte schließen Sie diesen Tab.",
+  "appRightsAlert": "Schreibschutz für KeeWeb wird eingerichtet",
+  "appRightsAlertBody1": "Ihre KeeWeb-Anwendung ist nicht gegen Änderungen von außen gesichert. Um diesen Schreibschutz einzurichten, benötigt die App Administratorrechte.",
+  "appRightsAlertBody2": "Sie möchten der App keine Administratorrechte erteilen? Mit folgendem Befehl können Sie den Schreibschutz auch von Hand im Terminal aktivieren",
+  "appBrowserAuthComplete": "Die Authentifizierung ist abgeschlossen, Sie können diesen Tab jetzt schließen.",
+  "setGenTitle": "Allgemeine Einstellungen",
+  "setGenUpdate": "Update",
+  "setGenNewVersion": "Eine neue Version der App ist verfügbar und wurde heruntergeladen",
+  "setGenReleaseNotes": "Versionshinweise anzeigen",
+  "setGenReloadToUpdate": "Seite aktualisieren, um das Update durchzuführen",
+  "setGenUpdateManual": "Eine neue Version ist verfügbar. Sie wird nach Updates suchen und diese automatisch installieren, ein automatisches Update Ihrer Version ist aber nicht möglich.",
+  "setGenDownloadUpdate": "Update herunterladen",
+  "setGenUpdateAuto": "Automatisch herunterladen und installieren",
+  "setGenUpdateCheck": "Auf Updates überprüfen, aber nicht installieren",
+  "setGenNoUpdate": "Nie nach Updates suchen",
+  "setGenUpdateChecking": "Updates werden gesucht",
+  "setGenCheckUpdate": "Nach Updates suchen",
+  "setGenErrorChecking": "Updatesuche fehlgeschlagen",
+  "setGenLastCheckSuccess": "Letzte erfolgreiche Überprüfung am {}",
+  "setGenLastCheckVer": "Die aktuelle Version war {}",
+  "setGenCheckedAt": "Überprüft am",
+  "setGenLatestVer": "Sie haben die aktuellste Version",
+  "setGenNewVer": "Neue Version {} verfügbar, veröffentlicht am",
+  "setGenDownloadingUpdate": "Update wird heruntergeladen …",
+  "setGenExtractingUpdate": "Update wird entpackt …",
+  "setGenCheckErr": "Beim Herunterladen der neuen Version ist ein Fehler aufgetreten",
+  "setGenNeverChecked": "Nie nach Updates gesucht",
+  "setGenRestartToUpdate": "App neu starten, um das Update durchzuführen",
+  "setGenDownloadAndRestart": "Update herunterladen und App neu starten",
+  "setGenAppearance": "Oberfläche",
+  "setGenTheme": "Theme",
+  "setGenThemeDefault": "Standard",
+  "setGenThemeDark": "Dunkel",
+  "setGenThemeLight": "Hell",
+  "setGenThemeBlue": "Flach blau",
+  "setGenThemeFb": "Mattblau",
+  "setGenThemeBl": "Hell blau",
+  "setGenThemeBrown": "Brownie",
+  "setGenThemeDb": "Dunkelbraun",
+  "setGenThemeLb": "Hell braun",
+  "setGenThemeTerminal": "Terminal",
+  "setGenThemeTe": "Terminal",
+  "setGenThemeLt": "Hell Terminal",
+  "setGenThemeHighContrast": "Hoher Kontrast",
+  "setGenThemeHc": "Hoher Kontrast",
+  "setGenThemeDc": "Dunkel Kontrast",
+  "setGenThemeSol": "Solarized",
+  "setGenThemeSd": "Solarisiert dunkel",
+  "setGenThemeSl": "Solarisiert hell",
+  "setGenMoreThemes": "Mehr Themes",
+  "setGenAutoSwitchTheme": "Automatisch zwischen hellem und dunklem Thema umschalten, sofern möglich",
+  "setGenLocale": "Sprache",
+  "setGenLocOther": "Andere Sprachen sind als Plugins verfügbar.",
+  "setGenFontSize": "Schriftgröße",
+  "setGenFontSizeNormal": "Standard",
+  "setGenFontSizeLarge": "Groß",
+  "setGenFontSizeLargest": "Größte",
+  "setGenTitlebarStyle": "Fensterstil (erfordert Neustart des Programms)",
+  "setGenTitlebarStyleDefault": "Standard",
+  "setGenTitlebarStyleHidden": "Eigener Titel",
+  "setGenTitlebarStyleHiddenInset": "Eigener Titel, verschiebbares Fenster",
+  "setGenShowSubgroups": "Einträge aus allen Untergruppen anzeigen",
+  "setGenTableView": "Einträge in Tabellenansicht anzeigen",
+  "setGenColorfulIcons": "Eigene Symbole in der Listenansicht farbig anzeigen",
+  "setGenUseMarkdown": "Markdown in Notizen",
+  "setGenUseGroupIconForEntries": "Für neue Einträge automatisch das Gruppensymbol verwenden",
+  "setGenDirectAutotype": "Wenn nur ein passender Eintrag gefunden wird, diesen automatisch für Auto-Type auswählen",
+  "setGenFunction": "Arbeitsweise",
+  "setGenAutoSyncOnClose": "Beim Schließen speichern und synchronisieren",
+  "setGenAutoSyncTimer": "Regelmäßig speichern und synchronisieren",
+  "setGenAutoSyncTimerOff": "Abgeschaltet",
+  "setGenAutoSyncTimerInterval": "Alle {} Minuten",
+  "setGenRememberKeyFiles": "Schlüsseldateien merken",
+  "setGenNoRememberKeyFiles": "Nicht merken",
+  "setGenRememberKeyFilesData": "Im internen App-Speicher ablegen",
+  "setGenRememberKeyFilesPath": "Nur Speicherort der Schlüsseldateien merken",
+  "setGenLockInactive": "Wenn die App inaktiv ist",
+  "setGenNoAutoLock": "Nicht automatisch sperren",
+  "setGenLockMinutes": "Nach {} Minuten",
+  "setGenLockHour": "In einer Stunde",
+  "setGenLockHours": "Nach {} Stunden",
+  "setGenLockDay": "Nach einem Tag",
+  "setGenClearClip": "Zwischenablage nach dem Kopieren leeren",
+  "setGenNoClear": "Nicht leeren",
+  "setGenClearSeconds": "In {} Sekunden",
+  "setGenClearMinute": "Nach einer Minute",
+  "setGenMinInstead": "App beim Schließen stattdessen minimieren",
+  "setGenLock": "Automatisch sperren",
+  "setGenLockMinimize": "Beim Minimieren der App",
+  "setGenLockCopy": "Nach dem Kopieren eines Passworts",
+  "setGenLockAutoType": "Bei Auto-Type",
+  "setGenLockOrSleep": "Bei Aktivierung von Bildschirmsperre oder Ruhezustand",
+  "setGenStorage": "Synchronisierung",
+  "setGenDisableOfflineStorage": "Geladene Dateien nicht in Offline-Speicher zwischenspeichern",
+  "setGenStorageLogout": "Abmelden",
+  "setGenShowAdvanced": "Erweiterte Einstellungen anzeigen",
+  "setGenDevTools": "Entwicklerwerkzeuge anzeigen",
+  "setGenTryBeta": "Betaversion bis zum Schließen der App ausprobieren",
+  "setGenTryBetaWarning": "Ungespeicherte Dateien",
+  "setGenTryBetaWarningBody": "Bitte speichern Sie alle Dateien und klicken erneut auf diese Schaltfläche",
+  "setGenShowAppLogs": "App-Logs anzeigen",
+  "setGenReloadApp": "App neu laden",
+  "setGenFieldLabelDblClickAutoType": "Auto-Type durch Anklicken von Beschriftungen aktivieren",
+  "setGenTouchId": "Fingerabdruck",
+  "setGenTouchIdDisabled": "Fingerabdruck nicht benutzen",
+  "setGenTouchIdMemory": "Nur mit Fingerabdruck entsperren, wenn KeeWeb aktiv ist",
+  "setGenTouchIdFile": "Benutze immer den Fingerabdruck anstatt das Master-Passwort",
+  "setGenTouchIdPass": "Benötige Master-Passwort nach",
+  "setGenAudit": "Audit",
+  "setGenAuditPasswords": "Warnungen für schwache Passwörter anzeigen",
+  "setGenAuditPasswordEntropy": "Passwortlänge und Zufälligkeit prüfen",
+  "setGenExcludePinsFromAudit": "Kurze Pin-Codes niemals prüfen (z. B. 12345)",
+  "setGenHelpHIBP": "KeeWeb kann überprüfen ob deine Passwörter bei einem früheren Datenleck veröffentlicht wurden. Deine Passwörter können nicht beim übertragen ausgelesen werden, aber die Anzahl der überprüften Passwörter kann möglicherweise entdeckt werden. {} kannst du mehr über den Datenschutz beim Nutzen dieses Dienstes erfahren. Wenn diese Option aktiviert ist überprüft KeeWeb deine Passwörter automatisch.",
+  "setGenHelpHIBPLink": "hier",
+  "setGenAuditPasswordAge": "Alte Passwörter",
+  "setGenAuditPasswordAgeOff": "Zeige keine Warnungen über alte Passwörter",
+  "setGenAuditPasswordAgeOneYear": "Zeige Warnungen für Passwörter die über ein Jahr alt sind",
+  "setGenAuditPasswordAgeYears": "Zeige Warnungen für Passwörter die über {} Jahre alt sind",
+  "setFilePath": "Dateipfad",
+  "setFileStorage": "Diese Datei wird von {} geladen.",
+  "setFileIntl": "Diese Datei ist im internen App-Speicher abgelegt",
+  "setFileLocalHint": "Sie wollen nahtlos mit lokalen Dateien arbeiten?",
+  "setFileDownloadApp": "Laden Sie die Desktop-App herunter",
+  "setFileSave": "Speichern",
+  "setFileSaveTo": "Speichern unter …",
+  "setFileClose": "Sperren",
+  "setFileSync": "Synchronisierung",
+  "setFileSyncVerb": "Synchronisieren",
+  "setFileSaveToXml": "XML",
+  "setFileSaveToHtml": "HTML",
+  "setFileLastSync": "Letzte Synchronisierung",
+  "setFileLastSyncUnknown": "unbekannt",
+  "setFileSyncInProgress": "Synchronisierung läuft",
+  "setFileSyncError": "Synchronisierungsfehler",
+  "setFilePass": "Hauptpasswort",
+  "setFileConfirmPass": "Masterpasswort bestätigen",
+  "setFilePassChange": "Um das Passwort zu ändern, geben Sie es im Bestätigungsfeld an",
+  "setFilePassChanged": "Das Passwort wurde geändert. Lassen Sie das Feld leer, um das bisherige Passwort zu behalten.",
+  "setFilePassNotMatch": "Die Passwörter stimmen nicht überein, bitte geben Sie diese erneut ein",
+  "setFileKeyFile": "Schlüsseldatei",
+  "setFileSelKeyFile": "Schlüsseldatei auswählen",
+  "setFileNames": "Namen",
+  "setFileDefUser": "Standard-Benutzername",
+  "setFileEnableTrash": "Papierkorb aktivieren",
+  "setFileHistMode": "Eintragsverlauf",
+  "setFileHistLimited": "Alte Einträge im Verlauf automatisch löschen",
+  "setFileHistDisabled": "Keinen Verlauf speichern",
+  "setFileHistUnlimited": "Verlauf dauerhaft speichern",
+  "setFileHistLen": "Anzahl der im Verlauf gespeicherten Versionen",
+  "setFileHistSize": "Maximalgröße des Verlaufs pro Datei in MB",
+  "setFileBackups": "Sicherungen",
+  "setFileBackupEnable": "Diese Datei sichern",
+  "setFileBackupPath": "Sicherungspfad",
+  "setFileBackupTime": "Sicherungen anlegen",
+  "setFileBackupNow": "Jetzt sichern",
+  "setFileBackupNowWorking": "Ausführung läuft …",
+  "setFileBackupError": "Sicherungsfehler",
+  "setFileBackupErrorDescription": "Fehler beim Schreiben der Sicherungsdatei",
+  "setFileBackupErrorIsDir": "Der Sicherungspfad ist ungültig",
+  "setFileBackupErrorIsDirDescription": "Der Sicherungspfad scheint ein Verzeichnis zu sein. Bitte geben Sie stattdessen einen Dateinamen ein.",
+  "setFileBackupOnSave": "Immer, wenn die Datei gespeichert wird",
+  "setFileBackupDaily": "Täglich",
+  "setFileBackupWeekly": "Wöchentlich",
+  "setFileBackupMonthly": "Monatlich",
+  "setFileBackupManually": "Manuell, keine automatische Sicherung",
+  "setFileRounds": "Verschlüsselungs-Runden",
+  "setFileKdfParams": "Schlüsselableitungsfunktion",
+  "setFileKdfParamsIter": "Iterationen",
+  "setFileKdfParamsMem": "Speicher in KB",
+  "setFileKdfParamsPar": "Parallelismus",
+  "setFileKeyChangeForce": "Hinweis zum Ändern des Schlüssels nach (Tagen)",
+  "setFileUseKeyFile": "Schlüsseldatei benutzen",
+  "setFileUseGenKeyFile": "Generierte Schlüsseldatei benutzen",
+  "setFileUseOldKeyFile": "Alte Schlüsseldatei benutzen",
+  "setFileGenKeyFile": "Neue Schlüsseldatei generieren",
+  "setFileDontUseKeyFile": "Keine Schlüsseldatei verwenden",
+  "setFileEmptyPass": "Leeres Passwort",
+  "setFileEmptyPassBody": "Eine Datenbank ohne Passwort zu speichern, macht diese vollkommen ungeschützt. Möchten Sie dies trotzdem tun?",
+  "setFileSaveError": "Fehler beim Speichern",
+  "setFileSaveErrorBody": "Schreibfehler beim Speichern",
+  "setFileAlreadyExists": "Existiert bereits",
+  "setFileAlreadyExistsBody": "Die Datei {} existiert bereits. Überschreiben?",
+  "setFileUnsaved": "Ungespeicherte Änderungen",
+  "setFileUnsavedBody": "Es gibt ungespeicherte Änderungen in dieser Datei",
+  "setFileCloseNoSave": "Sperren und Änderungen verwerfen",
+  "setFileDontClose": "Nicht sperren",
+  "setFileFormatVersion": "Dateiformat",
+  "setFileExportRaw": "Passwörter exportieren",
+  "setFileExportRawBody": "Die Exportdatei wird Ihre Passwörter als unverschlüsselten Klartext enthalten. Möchten Sie fortfahren?",
+  "setFileDeviceIntro": "Einmal-Codes aus diesem {} werden in der App angezeigt.",
+  "setFileDeviceSettings": "Einstellungen",
+  "setFileYubiKey": "YubiKey",
+  "setFileDontUseYubiKey": "Keinen YubiKey verwenden",
+  "setFileRefreshYubiKeyList": "Liste aktualisieren",
+  "setFileYubiKeyHeader": "YubiKey",
+  "setFileYubiKeyBody": "Es ist gefährlich, einen YubiKey als Teil des Hauptschlüssels zu verwenden. Falls etwas schief geht, besteht möglicherweise kein Zugriff mehr auf die Passwörter. Haben Sie ein Backup Ihrer Datei erstellt, bevor diese Einstellung geändert wurde?",
+  "setFileYubiKeyErrorEmptyMac": "Scheinbar wurde ein YubiKey angeschlossen, er ist aber nicht sichtbar. KeeWeb muss in den Sicherheitseinstellungen im Abschnitt Input-Monitoring hinzugefügt werden, um auf YubiKeys zugreifen zu können.",
+  "setShTitle": "Tastenkürzel",
+  "setShShowAll": "alle Einträge anzeigen",
+  "setShColors": "mit Farben markierte Einträge anzeigen",
+  "setShTrash": "Papierkorb öffnen",
+  "setShFind": "Suchen oder einfach beginnen zu tippen",
+  "setShClearSearch": "Suchfeld leeren",
+  "setShCopyPass": "Passwort bzw. ausgewähltes Feld kopieren",
+  "setShCopyUser": "Benutzername kopieren",
+  "setShCopyUrl": "Website kopieren",
+  "setShAutoType": "Auto-Type für ausgewählten Eintrag",
+  "setShPrev": "zum vorherigen Eintrag gehen",
+  "setShNext": "zum nächsten Eintrag gehen",
+  "setShCreateEntry": "Neuer Eintrag",
+  "setShOpen": "Öffnen / Neu",
+  "setShSave": "Alle Dateien speichern",
+  "setShGen": "Passwort generieren",
+  "setShSet": "App-Einstellungen",
+  "setShCopyPassGlobal": "Passwort kopieren",
+  "setShCopyOtp": "Einmal-Passwort kopieren",
+  "setShAutoTypeGlobal": "Auto-Type",
+  "setShCopyPassOnly": "Passwort kopieren",
+  "setShRestoreApp": "{} öffnen",
+  "setShGlobal": "Diese systemweiten Tastenkürzel funktionieren auch, wenn die App im Hintergrund läuft. Klicken Sie auf einen Eintrag, um ein eigenes Kürzel festzulegen.",
+  "setShLock": "Datenbank sperren",
+  "setShEdit": "Drücken Sie eine Tastenkombination, um diese als Kürzel zu festzulegen",
+  "setPlInstallTitle": "Neue Plugins installieren",
+  "setPlInstallDesc": "KeeWeb-Plugins fügen Funktionen, Themes und Sprachen zu KeeWeb hinzu. Plugins werden mit denselben Rechten ausgeführt wie KeeWeb selbst, sie können auf all Ihre Passwörter zugreifen oder diese ändern. Installieren Sie niemals Plugins, denen Sie nicht vertrauen.",
+  "setPlInstallLabel": "Plugin-URL",
+  "setPlInstallBtn": "Installieren",
+  "setPlInstallBtnProgress": "Installation läuft",
+  "setPlUninstallBtn": "Deinstallieren",
+  "setPlDisableBtn": "Deaktivieren",
+  "setPlEnableBtn": "Aktivieren",
+  "setPlUpdateBtn": "Aktualisieren",
+  "setPlLocaleBtn": "Diese Sprache aktivieren",
+  "setPlThemeBtn": "Dieses Theme aktivieren",
+  "setPlJs": "Code",
+  "setPlCss": "Stile",
+  "setPlLoc": "Sprache",
+  "setPlCreatedBy": "Erstellt von {}",
+  "setPlLoadTime": "geladen in {}",
+  "setPlLastUpdate": "Letzte Prüfung auf Updates",
+  "setPlLoadError": "Fehler beim Laden des Plugins",
+  "setPlGalleryLoading": "Plugins werden geladen, bitte einen Moment warten",
+  "setPlGalleryLoadError": "Fehler beim Laden der Plugins",
+  "setPlInstallUrlTitle": "Plugin von einer URL hinzufügen",
+  "setPlInstallUrlDesc": "Wenn das Plugin nicht in der Galerie verfügbar ist, können Sie es manuell von einer URL installieren",
+  "setPlOfficial": "Offizielles KeeWeb-Plugin",
+  "setPlSearch": "Nach Plugins suchen",
+  "setPlDevelop": "Eigene Plugins entwickeln?",
+  "setPlDevelopStart": "Hier entlang",
+  "setPlTranslate": "Oder {}",
+  "setPlTranslateLink": "übersetzen Sie die App in Ihre Sprache",
+  "setPlAutoUpdate": "Automatisch aktualisieren",
+  "setPlLoadGallery": "Plugin-Galerie laden",
+  "setDevicesTitle": "Geräte",
+  "setDevicesEnableUsb": "Interaktion mit USB-Geräten aktivieren",
+  "setDevicesYubiKeyIntro": "Es wird empfehlen {} zu lesen, bevor ein YubiKey verwendet wird.",
+  "setDevicesYubiKeyIntroLink": "dieses Dokument",
+  "setDevicesYubiKeyToolsDesc": "Um YubiKey in diesem Modus verwenden zu können, müssen Sie vorher das Tool {} installieren.",
+  "setDevicesYubiKeyToolsDesc2": "{}, um mehr Informationen über dieses Tool zu erhalten.",
+  "setDevicesYubiKeyToolsDescLink": "Hier klicken",
+  "setDevicesYubiKeyToolsStatusChecking": "Prüfung, ob {} installiert ist",
+  "setDevicesYubiKeyToolsStatusOk": "{} ist installiert",
+  "setDevicesYubiKeyToolsStatusError": "{} ist nicht installiert oder funktioniert nicht korrekt",
+  "setDevicesYubiKeyOtpTitle": "Einmal-Codes",
+  "setDevicesYubiKeyOtpDesc": "Ein YubiKey kann genutzt werden, um Einmal-Codes für verschiedene Dienste zu erzeugen.",
+  "setDevicesYubiKeyOtpShowIcon": "Das Symbol auf der Startseite anzeigen",
+  "setDevicesYubiKeyOtpAutoOpen": "Einmal-Codes automatisch laden, wenn Dateien geöffnet sind",
+  "setDevicesYubiKeyOtpMatchEntries": "Passende Einmal-Codes in den Einträgen anzeigen",
+  "setDevicesYubiKeyChalRespTitle": "Challenge-Response",
+  "setDevicesYubiKeyChalRespDesc": "Es ist auch möglich, einen YubiKey im Challenge-Response-Modus zu verwenden, um einen Teil des Private Schlüssels, der zum Verschlüsseln der Dateien verwendet wird, auf dem YubiKey zu speichern.",
+  "setDevicesYubiKeyChalRespShow": "Optionen zum Verwenden eines YubiKeys beim Öffnen von Dateien anzeigen",
+  "setDevicesYubiKeyStuckWorkaround": "YubiKey entfernen und neu verbinden, falls der Ladeprozess hängt",
+  "setDevicesYubiKeyRememberChalResp": "Challenge-Response-Einstellungen merken, während die App geöffnet ist",
+  "setAboutTitle": "Über",
+  "setAboutBuilt": "Diese App wurde mit folgenden Werkzeugen erstellt",
+  "setAboutLic": "Lizenz",
+  "setAboutLicComment": "Die App selbst und alle enthaltenen Komponenten, die nicht Public Domain sind, stehen unter der MIT-Lizenz.",
+  "setAboutFirst": "Dies ist eine Open-Source App, erstellt von {}",
+  "setAboutSecond": "und lizenziert unter {}.",
+  "setAboutSource": "Quellcode und Tickets befinden sich auf {}.",
+  "setHelpFormat": "Dateiformat",
+  "setHelpFormatBody": "Dies ist eine Portierung der App {}, programmiert mit Webtechnologien. Sie ist kompatibel mit Dateien im KeePass-Format (kdbx). Sie können solche Dateien (Passwort-Datenbanken) entweder mit KeePass oder mit dieser App erstellen. Das Dateiformat ist zu 100 % kompatibel und sollte in beiden Anwendungen nutzbar sein.",
+  "setHelpProblems": "Probleme?",
+  "setHelpProblems1": "Falls etwas schief geht, {}",
+  "setHelpProblems2": "oder {}",
+  "setHelpOpenIssue": "eröffnen Sie bitte ein Ticket auf GitHub (englisch)",
+  "setHelpContactLink": "kontaktieren Sie den Entwickler direkt",
+  "setHelpAppInfo": "App-Informationen",
+  "setHelpOtherPlatforms": "Andere Plattformen",
+  "setHelpDesktopApps": "Deskop-Apps",
+  "setHelpWebApp": "Web-App",
+  "setHelpUpdates": "Neuigkeiten",
+  "setHelpTwitter": "Twitter",
+  "dropboxSetupDesc": "Etwas Konfiguration ist notwendig, um Dropbox in einer selbst gehosteten Web-App zu verwenden. Bitte erstellen Sie eine eigene Dropbox-App und tragen Sie ihren App-Schlüssel unten ein.",
+  "dropboxAppKey": "Dropbox-App-Schlüssel",
+  "dropboxAppKeyDesc": "Kopieren Sie den Schlüssel aus Ihrer Dropbox-App (Entwicklereinstellungen)",
+  "dropboxAppKeyHint": "Ihr App-Schlüssel",
+  "dropboxAppSecret": "Dropbox-App-Secret",
+  "dropboxAppSecretDesc": "Das App-Secret ist neben dem App-Schlüssel zu finden",
+  "dropboxFolder": "App-Ordner",
+  "dropboxFolderDesc": "Wenn Ihre App mit der gesamten Dropbox verlinkt ist (anstatt mit einem bestimmten Ordner), geben Sie hier den Pfad zum Ordner mit Ihren KDBX-Dateien an.",
+  "dropboxFolderSettingsDesc": "Wählen Sie einen Ordner in Ihrer Dropbox, in dem die Dateien gespeichert werden (standardmäßig das Stammverzeichnis)",
+  "dropboxFolderPlaceholder": "Standardordner",
+  "dropboxLink": "App verlinken mit",
+  "dropboxLinkApp": "App-Ordner (Apps/KeeWeb)",
+  "dropboxLinkFull": "Gesamte Dropbox oder beliebiger Ordner",
+  "dropboxLinkCustom": "Eigene Dropbox-App",
+  "gdriveSharedWithMe": "Mit mir geteilt",
+  "webdavSaveMethod": "Speichermethode",
+  "webdavSaveMove": "Eine temporäre Datei hochladen und verschieben",
+  "webdavSavePut": "kdbx-Datei mittels PUT überschreiben",
+  "launcherSave": "Passwortdatenbank speichern",
+  "launcherFileFilter": "KeePass-Dateien",
+  "authPopupRequired": "Pop-ups blockiert",
+  "authPopupRequiredBody": "Bitte erlauben Sie Pop-ups in Ihrem Browser.",
+  "exportFileInfo": "Dateiinformationen",
+  "exportHtmlName": "Name",
+  "exportHtmlDate": "Exportdatum",
+  "exportGenerator": "Software",
+  "exportDescription": "Diese Datei wurde mit {} erstellt.",
+  "importCsvTitle": "Aus CSV importieren",
+  "importCsvRun": "Importieren",
+  "importIgnoreField": "Ignorieren",
+  "importTo": "Einträge werden importiert nach:",
+  "importNewFile": "Neue Datei",
+  "yubiKeyStuckError": "Der YubiKey scheint nicht mehr zu funktionieren. Auto-Repair kann in den App-Einstellungen aktiviert werden.",
+  "yubiKeyNoKeyHeader": "YubiKey benötigt",
+  "yubiKeyNoKeyBody": "Bitte den YubiKey mit der Seriennummer {} anschließen",
+  "yubiKeySlot": "Anschluss",
+  "yubiKeyTouchRequestedHeader": "Bitte den YubiKey berühren",
+  "yubiKeyTouchRequestedBody": "Bitte den YubiKey mit der Seriennummer {} berühren",
+  "yubiKeyDisabledErrorHeader": "USB ist deaktiviert",
+  "yubiKeyDisabledErrorBody": "YubiKey ist zum Öffnen dieser Datei erforderlich. Bitte USB-Geräte in den Einstellungen aktivieren.",
+  "yubiKeyErrorWithCode": "YubiKey-Fehler, Code {}.",
+  "bioOpenAuthPrompt": "„{}“ öffnen"
+}

app/locales/fr-FR.json

@@ -0,0 +1,701 @@
+{
+  "retToApp": "retour vers l'appli",
+  "name": "nom",
+  "icon": "icône",
+  "title": "titre",
+  "password": "mot de passe",
+  "user": "utilisateur",
+  "website": "site web",
+  "tags": "tags",
+  "notes": "notes",
+  "entry": "entrée",
+  "group": "groupe",
+  "noTitle": "aucun titre",
+  "or": "ou",
+  "history": "historique",
+  "template": "modèle",
+  "notImplemented": "Non Implémenté",
+  "saveChanges": "Sauvegarder les modifications",
+  "discardChanges": "Annuler les modifications",
+  "advanced": "Avancé",
+  "shortcuts": "Raccourcis",
+  "help": "Aide",
+  "settings": "Paramètres",
+  "plugins": "Modules (plugins)",
+  "ctrlKey": "ctrl",
+  "shiftKey": "shift",
+  "altKey": "alt",
+  "error": "erreur",
+  "oneMinute": "une minute",
+  "minutes": "{} minutes",
+  "oneHour": "une heure",
+  "hours": "{} heures",
+  "oneDay": "un jour",
+  "days": "{} jours",
+  "oneWeek": "une semaine",
+  "oneMonth": "un mois",
+  "oneYear": "une année",
+  "cache": "cache",
+  "file": "fichier",
+  "device": "appareil",
+  "webdav": "WebDAV",
+  "dropbox": "Dropbox",
+  "gdrive": "Google Drive",
+  "onedrive": "OneDrive",
+  "menuAllItems": "Tout",
+  "menuColors": "Couleurs",
+  "menuTrash": "Corbeille",
+  "menuSetGeneral": "Général",
+  "menuSetAbout": "À propos",
+  "menuSetDevices": "Appareils",
+  "menuAlertNoTags": "Aucun tag",
+  "menuAlertNoTagsBody": "Vous pouvez ajouter de nouveaux tags en éditant les champs, dans la section Tags.",
+  "menuEmptyTrash": "Vider la Corbeille",
+  "menuEmptyTrashAlert": "Vider la Corbeille ?",
+  "menuEmptyTrashAlertBody": "Vous ne pourrez plus récupérer ces éléments",
+  "menuItemCollapsed": "Double-cliquez pour déplier",
+  "menuRestoreApp": "Ouvrir {}",
+  "menuQuitApp": "Quitter {}",
+  "sysMenuAboutKeeWeb": "A propos {}",
+  "sysMenuServices": "Services",
+  "sysMenuHide": "Cacher {}",
+  "sysMenuHideOthers": "Cacher autres",
+  "sysMenuUnhide": "Montrer tous",
+  "sysMenuQuit": "Quitter {}",
+  "sysMenuEdit": "Editer",
+  "sysMenuUndo": "Annuler",
+  "sysMenuRedo": "Répéter",
+  "sysMenuCut": "Couper",
+  "sysMenuCopy": "Copier",
+  "sysMenuPaste": "Coller",
+  "sysMenuSelectAll": "Tout sélectionner",
+  "sysMenuWindow": "Fenêtre",
+  "sysMenuMinimize": "Réduire",
+  "sysMenuClose": "Fermer fenêtre",
+  "alertYes": "Oui",
+  "alertNo": "Non",
+  "alertOk": "OK",
+  "alertCancel": "Annuler",
+  "alertSignIn": "Connexion",
+  "alertCopy": "Copier",
+  "alertClose": "Fermer",
+  "alertDoNotAsk": "Ne plus me le redemander",
+  "appBeta": "ATTENTION: version beta, aperçu seulement",
+  "footerOpen": "Ouvrir/Nouveau",
+  "footerSyncError": "Erreur de synchronisation",
+  "footerTitleGen": "Générer",
+  "footerTitleLock": "Verrouiller",
+  "genLen": "Longueur",
+  "genNewPass": "Nouveau mot de passe",
+  "genPresetDefault": "réglages par défaut",
+  "genPresetDerived": "similaire à l'ancien mot de passe",
+  "genPresetPronounceable": "prononçable",
+  "genPresetMed": "longueur moyenne",
+  "genPresetLong": "long",
+  "genPresetPin4": "code à 4 chiffres",
+  "genPresetMac": "adresse MAC",
+  "genPresetHash128": "hash 128 bits",
+  "genPresetHash256": "hash 256 bits",
+  "genHidePass": "Masquer le mot de passe",
+  "genShowPass": "Afficher le mot de passe",
+  "grpTitle": "Groupe",
+  "grpSearch": "Activer la recherche dans les entrées de ce groupe",
+  "grpAutoType": "Activer l'auto-complétion",
+  "grpAutoTypeSeq": "Séquence d'auto-complétion",
+  "grpAutoTypeSeqDefault": "Utiliser la séquence d'auto-complétion par défaut",
+  "grpTrash": "Supprimer le groupe et toutes ses entrées",
+  "tagTitle": "Tag",
+  "tagTrash": "Supprimer le tag de toutes les entrées",
+  "tagRename": "Renommer",
+  "tagTrashQuestion": "Supprimer le tag de toutes les entrées ?",
+  "tagTrashQuestionBody": "Ce tag va être supprimé de toutes les entrées. Il n'y aura pas de moyen facile pour le remettre.",
+  "tagExists": "Ce tag existe déjà",
+  "tagExistsBody": "Un tag existe déjà avec ce nom. Merci de choisir un autre nom.",
+  "tagBadName": "Nom invalide",
+  "tagBadNameBody": "Les noms de Tag ne peuvent contenir les caractères {}. Veuillez les supprimer.",
+  "genPsTitle": "Préréglages du Générateur",
+  "genPsCreate": "Nouveau préréglage",
+  "genPsDelete": "Supprimer préréglage",
+  "genPsNew": "préréglage",
+  "genPsEnabled": "Afficher dans la liste des préréglages",
+  "genPsDefault": "Sélectionné par défaut",
+  "genPsDefaultLength": "Longueur par défaut",
+  "genPsUpper": "Lettres latines majuscules",
+  "genPsLower": "Lettres latines minuscules",
+  "genPsDigits": "Chiffres",
+  "genPsSpecial": "Caractères spéciaux",
+  "genPsBrackets": "Parenthèses",
+  "genPsHigh": "Caractères ASCII étendus",
+  "genPsAmbiguous": "Caractères ambigus",
+  "genPsInclude": "Caractères additionnels à inclure",
+  "genPsExample": "Exemple de mot de passe généré",
+  "genPsPattern": "Modèle",
+  "genPsPatternHelp": "Des modèles peuvent être utilisés pour spécifier des règles de sélection de caractères. 1-AA générera un mot de passe commençant par un chiffre, suivi d'un tiret et de 2 lettres. Vous pouvez utiliser ces symboles :",
+  "genPsAllRanges": "Tous les caractères",
+  "genPsIncluded": "Caractères additionnels ajoutés ci-dessus",
+  "keyChangeTitleRemote": "Clé Maître Modifiée",
+  "keyChangeMessageRemote": "La clé maître a été modifiée pour cette base de données. Merci de saisir une nouvelle clé.",
+  "keyChangeTitleExpired": "Clé Maître Expirée",
+  "keyChangeMessageExpired": "La clé maître pour cette base de donnée est expirée. Merci de saisir une nouvelle clé.",
+  "keyChangeRepeatPassword": "Mot de passe, encore une fois",
+  "keyEnter": "Entrée",
+  "iconFavTitle": "Télécharger et utiliser le favicon du site web",
+  "iconSelCustom": "Sélectionner une icône personnalisée",
+  "listEmptyTitle": "Vide",
+  "listEmptyAdd": "ajouter avec le bouton {} au-dessus",
+  "listGroup": "Groupe",
+  "listNoWebsite": "aucun site web",
+  "listNoUser": "aucun utilisateur",
+  "listNoAttachments": "aucune pièce-jointe",
+  "listAddTemplateHeader": "Modèles",
+  "listAddTemplateBody1": "Les modèles (templates) vous permettent de créer des nouvelles entrées en un clic. Ajouter quelque chose à l'entrée du modèle et ensuite cliquer de nouveau sur {} pour utiliser ce modèle.",
+  "listAddTemplateBody2": "Vous pouvez toujours retrouver vos modèles dans le groupe {}.",
+  "searchAddNew": "Ajouter Nouveau",
+  "searchSort": "Trier",
+  "searchCreated": "Créé",
+  "searchUpdated": "Mis à jour",
+  "searchAttachments": "Pièce-jointes",
+  "searchAZ": "A {} Z",
+  "searchZA": "Z {} A",
+  "searchON": "Ancien {} Nouveau",
+  "searchNO": "Nouveau {} Ancien",
+  "searchShiftClickOr": "maj-click ou",
+  "searchAdvTitle": "Afficher/masquer recherche avancée",
+  "searchSearchIn": "Rechercher dans",
+  "searchOther": "Autres champs",
+  "searchProtect": "Champs sécurisés",
+  "searchOptions": "Options",
+  "searchCase": "Respecte la casse",
+  "searchRegex": "RegEx",
+  "searchRank": "Auto",
+  "searchExact": "Exact",
+  "openOpen": "Ouvrir",
+  "openNew": "Nouveau",
+  "openNewFile": "Nouveau",
+  "openMore": "Plus",
+  "openDemo": "Démo",
+  "openGenerate": "Générer",
+  "openXml": "Importer XML",
+  "openCaps": "Majuscules activées",
+  "openClickToOpen": "Cliquer pour ouvrir un fichier",
+  "openKeyFile": "fichier clé",
+  "openKeyFileDropbox": "(depuis DropBox)",
+  "openDropHere": "déposez les fichiers ici",
+  "openFailedRead": "Échec lors de la lecture du fichier",
+  "openNothingFound": "Aucun résultat",
+  "openNothingFoundBody": "Nous n'avons trouvé aucun fichier convenable.",
+  "openSelectFile": "Sélectionnez un fichier",
+  "openSelectFileBody": "Sélectionnez un fichier que vous voudriez ouvrir",
+  "openPassFor": "Mot de passe pour",
+  "openRemoveLastQuestion": "Supprimer le fichier local ?",
+  "openRemoveLastQuestionBody": "Le fichier que vous voulez supprimer est sauvegardé dans l'appli. Le supprimer de façon définitive ?",
+  "openRemoveLastQuestionModBody": "Le fichier que vous voulez supprimer a des modifications locales. Le supprimer et annuler ces modifications ?",
+  "openLocalFile": "Fichier local",
+  "openLocalFileBody": "Vous allez ouvrir un fichier qui sera stocké dans l'application. Les modifications apportées ne seront pas sauvegardées vers le système de fichiers. Pour obtenir le fichier avec vos données, exportez-le via les paramètres.",
+  "openLocalFileDontShow": "Ne plus afficher",
+  "openWrongFile": "Fichier invalide",
+  "openWrongFileBody": "Ce format de fichier n'est pas supporté. Cette application fonctionne avec des fichiers de base de donnée KeePass (kdbx).",
+  "openKdbFileBody": "Vous essayez d'ouvrir un ancien fichier de base de donnée KeePass (KDB). Cette application supporte uniquement le nouveaux format (kdbx), merci d'utiliser KeePass 2 afin de convertir celui-ci.",
+  "openConfigHeader": "Paramètres {}",
+  "openUrl": "URL",
+  "openUrlDesc": "https://serveur/chemin/fichier.kdbx, ou seulement fichier.kdbx",
+  "openUser": "Nom d'utilisateur",
+  "openUserDesc": "Nom d'utilisateur du serveur WebDAV (si requis)",
+  "openUserPlaceholder": "aucun nom d'utilisateur",
+  "openPass": "Mot de passe",
+  "openPassDesc": "Mot de passe du serveur WebDAV (ce n'est pas votre mot de passe de fichier)",
+  "openPassPlaceholder": "aucun mot de passe",
+  "openConfigError": "Erreur: {}",
+  "openConfigErrorNotFound": "Aucun fichier trouvé",
+  "openError": "Erreur",
+  "openErrorDescription": "Une erreur est survenue à l'ouverture du fichier",
+  "openErrorDescriptionMaybeTouchIdChanged": "L'erreur ressemble à ce qu'y arrive habituellement quand la configuration de Touch ID a été changée. Par exemple, vous avez ajouté ou supprimé un doigt supplémentaire. Si c'est le cas, allez dans Paramètres, désactiver Touch ID et activer le de nouveau.",
+  "openErrorFileNotFound": "Fichier non trouvé",
+  "openListErrorBody": "Erreur au chargement de la liste des fichiers",
+  "openShowAllFiles": "Tous les fichiers",
+  "openFileNoCacheError": "Fichier non trouvé dans la mémoire cache. Cela peut arriver parce que le stockage du navigateur a été nettoyé. Pour ouvrir le fichier, supprimez-le de KeeWeb et ajoutez-le à nouveau.",
+  "openChalRespHeader": "Challenge-Réponse",
+  "openChalRespLoading": "Chargement de la liste des YubiKeys",
+  "openChalRespSelectYubiKey": "Sélectionnez une YubiKey que vous voudriez utiliser",
+  "openChalRespErrorEmpty": "Pas de clé YubiKey trouvée.",
+  "openChalRespErrorEmptyMac": "Première fois que vous utilisez cette fonctionnalité sur MacOS ? KeeWeb doit avoir été autorisé dans la section \"Surveillance de l’entrée\" des paramètres de sécurité.",
+  "detAttDownload": "Cliquez sur le bouton de pièce-jointe en pressant la touche Maj pour le télécharger ou",
+  "detAttDelToRemove": "Supprimer pour enlever",
+  "detAttSave": "Enregistrer sous",
+  "detEmpty": "Vos mots de passe seront affichés ici",
+  "detGroupRestore": "Pour restaurer ce groupe, veuillez le glisser-déposer dans un des groupes hors de la corbeille",
+  "detHistoryClickPoint": "Cliquer sur une entrée de l'historique pour voir son état",
+  "detHistoryReturn": "Retour vers l'entrée",
+  "detHistoryRevert": "Revenir à cet état",
+  "detHistoryDel": "Supprimer cet état",
+  "detHistoryEmpty": "vide",
+  "detHistoryModified": "modifié",
+  "detHistoryRec": "archive",
+  "detHistoryRecs": "archives",
+  "detHistoryVersion": "Version",
+  "detHistorySaved": "Sauvegardé",
+  "detHistoryNoTitle": "sans titre",
+  "detHistoryCurState": "état actuel",
+  "detHistoryCurUnsavedState": "état actuel non sauvegardé",
+  "detHistoryRevertAlert": "Revenir à cet état de l'historique ?",
+  "detHistoryRevertAlertBody": "L'état courant sera sauvegardé dans l'historique.",
+  "detHistoryDeleteAlert": "Supprimer cet état de l'historique ?",
+  "detHistoryDeleteAlertBody": "Vous ne pourrez plus le restaurer.",
+  "detHistoryDiscardChangesAlert": "Ne pas sauvegarder les modifications de cette entrée ?",
+  "detHistoryDiscardChangesAlertBody": "Les changements non sauvegardés seront définitivement perdus, il n'y a pas de retour en arrière.",
+  "detBackToList": "retour vers liste",
+  "detSetIconColor": "Changer de couleur",
+  "detSetIcon": "Changer d'icône",
+  "detDropAttachments": "Déposer une pièce-jointe ici",
+  "detDelEntry": "Supprimer",
+  "detDelEntryPerm": "Supprimer définitivement",
+  "detExpires": "Expire",
+  "detExpired": "expirée",
+  "detGroup": "Groupe",
+  "detCreated": "Créé le",
+  "detUpdated": "Mis à jour",
+  "detNetField": "Nouveau champ",
+  "detAttachments": "Pièces-jointes",
+  "detDelFromTrash": "Supprimer de la Corbeille ?",
+  "detDelFromTrashBody": "Vous ne pourrez plus le récupérer.",
+  "detDelFromTrashBodyHint": "Pour supprimer tous les éléments de la Corbeille, cliquez l’icône \"Vider la corbeille\" du menu Corbeille.",
+  "detDelToTrash": "Supprimer l'entrée ?",
+  "detDelToTrashBody": "L'entrée sera déplacée dans la corbeille.",
+  "detFieldCopied": "Copié",
+  "detFieldCopiedTime": "Copié pendant {} secondes",
+  "detCopyHint": "Vous pouvez copier la valeur du champ en cliquant sur ton titre",
+  "detMore": "plus",
+  "detClickToAddField": "cliquez pour ajouter un nouveau champ",
+  "detMenuAddNewField": "Ajouter nouveau champ",
+  "detMenuShowEmpty": "Montrer les champs vides",
+  "detMenuHideEmpty": "Cacher les champs vides",
+  "detMenuAddField": "Ajouter {}",
+  "detMenuCopyPassword": "Copier mot de passe",
+  "detMenuCopyUser": "Copier nom",
+  "detMenuCopyOtp": "Copier le code à usage unique",
+  "detSetupOtp": "Codes à usage unique",
+  "detClone": "Dupliquer",
+  "detCopyEntryToClipboard": "Copier tous les champs",
+  "detClonedName": "Copier",
+  "detAutoType": "Saisie auto",
+  "detAutoTypeSettings": "Paramètres saisie auto",
+  "detAutoTypeEnabled": "Activer la saisie automatique pour cette entrée",
+  "detAutoTypeSequence": "Frappes",
+  "detAutoTypeInput": "Entrée",
+  "detAutoTypeShortcutsDesc": "{} ou {} tant que l'appli est inactive",
+  "detAutoTypeObfuscation": "Mélanger touches réelles et aléatoire",
+  "detAutoTypeWindow": "Fenêtre",
+  "detAutoTypeInputWindow": "Titre de fenêtre",
+  "detSetupOtpAlert": "Scanner le QR code",
+  "detSetupOtpAlertBody": "Veuillez copier le QR code qui est affiché sur la page d'autorisation",
+  "detSetupOtpAlertBody1": "1. aller sur la page d'autorisation",
+  "detSetupOtpAlertBody2": "2. faire une capture d'écran du QR code avec {}",
+  "detSetupOtpAlertBody3": "3. collez-la ici avec {}",
+  "detSetupOtpAlertBody3Mobile": "3. Sélectionner ou scanner avec votre appareil photo en utilisant Sélectionner/Scan ci-dessous",
+  "detSetupOtpAlertBody4": "Si vous ne pouvez pas scanner le code, cliquer sur Entrer le code manuellement",
+  "detSetupOtpManualButton": "Entrer le code manuellement",
+  "detSetupOtpScanButton": "Sélectionner/Scan",
+  "detSetupOtpAlertBodyWith": "avec {}",
+  "detOtpImageError": "Erreur de lecture de l'image",
+  "detOtpImageErrorBody": "Désolé, le format de l'image ne peut pas être lu, merci de contacter les auteurs de l'application avec le détail de l'erreur.",
+  "detOtpImageReading": "Lecture du QR code...",
+  "detOtpQrError": "Erreur lecture du QR code",
+  "detOtpQrErrorBody": "Désolé, le QR code n'a pas pu être lu, essayez à nouveau ou contacter les auteurs de l'application avec le détail de l'erreur.",
+  "detOtpQrWrong": "QR code incorrect",
+  "detOtpQrWrongBody": "Votre code QR code a été scanné avec succès mais il ne contient pas d'information pour un code à usage unique.",
+  "detOtpField": "Code à usage unique",
+  "detOtpClickToTouch": "Cliquer pour générer",
+  "detOtpGenerating": "Création...",
+  "detOtpTouch": "Touchez votre {}",
+  "detLockField": "Verrouiller ce champ, ainsi son contenu ne sera pas visible ni ne pourra être cherché. Visualiser son contenu exigera de le cliquer explicitement.",
+  "detUnlockField": "Déverrouiller ce champ, rendant son contenu immédiatement visible et pouvant être cherché",
+  "detRevealField": "Révéler",
+  "detHideField": "Cacher",
+  "detAutoTypeField": "Saisie auto",
+  "detIssuesHideTooltip": "Cacher cet avertissement",
+  "detIssueWeakPassword": "Ce mot de passe est faible, nous vous recommandons de le changer",
+  "detIssuePoorPassword": "Ce mot de passe est très faible, nous vous recommandons très fort de le changer",
+  "detIssuePwnedPassword": "Ce mot de passe a été exposé à une faille selon {}, il est recommandé de le changer",
+  "detIssuePasswordCheckError": "Une erreur est survenue en vérifiant la force du mot de passe en ligne",
+  "detIssueOldPassword": "Ce mot de passe est vieux",
+  "detIssueCloseAlertHeader": "Cacher les problèmes de mots de passe",
+  "detIssueCloseAlertBody": "Il y a plusieurs façon de cacher ce message :",
+  "detIssueCloseAlertEntry": "Ne plus montrer pour cette entrée",
+  "detIssueCloseAlertSettings": "Modifier les paramètres globaux",
+  "autoTypeEntryFields": "Champs",
+  "autoTypeModifiers": "Touches modificatrices",
+  "autoTypeKeys": "Clés",
+  "autoTypeLink": "plus...",
+  "autoTypeError": "Erreur saisie auto",
+  "autoTypeErrorGeneric": "Il y a eu une erreur lors de la saisie automatique : {}",
+  "autoTypeErrorAccessibilityMacOS": "Nous avons essayé d'envoyer les frappes de caractères à cette application mais cela ne semble pas fonctionner parce qu'il manque des permissions. Cliquer ici pour en lire plus.",
+  "autoTypeErrorGlobal": "Pour utiliser un raccourci global, sélectionner l'application là où vous voulez saisir le mot de passe",
+  "autoTypeErrorNotInstalled": "{} n'est pas installé",
+  "autoTypeHeader": "Saisie auto : Selectionner",
+  "autoTypeMsgNoWindow": "Nous n'avons pas pu obtenir le titre de la fenêtre active, commencez à taper pour rechercher",
+  "autoTypeMsgMatchedByWindow": "Sélectionner un mot de passe pour {}",
+  "autoTypeNoMatches": "aucun",
+  "autoTypeSelectionHint": "Saisissez la séquence automatique",
+  "autoTypeSelectionHintAction": "Entrez seulement le mot de passe",
+  "autoTypeSelectionHintOpt": "Entrez seulement le compte",
+  "autoTypeSelectionHintShift": "Autres champs",
+  "autoTypeSelectionOtp": "code à usage unique",
+  "appSecWarn": "Non sécurisé !",
+  "appSecWarnBody1": "Vous avez chargé cette appli avec une connexion non sécurisée. Quelqu'un peut vous observer et voler vos mots de passe. Nous vous recommandons fortement d'arrêter cette connexion, à moins que vous ne compreniez exactement ce que vous faites.",
+  "appSecWarnBody2": "Oui, votre base est chiffrée mais personne ne peut garantir que l'application n'a pas été modifiée avant d'arriver à vous.",
+  "appSecWarnBtn": "Je comprends les risques, continuer",
+  "appUnsavedWarn": "Modifications non sauvegardées",
+  "appUnsavedWarnBody": "Vous avez des fichiers non sauvegardés, si vous fermez l'appli, les changements seront perdus.",
+  "appDontExitBtn": "Ne pas quitter",
+  "appCannotLockAutoInit": "L'appli ne peut pas être verrouillée car la sauvegarde automatique est désactivée.",
+  "appCannotLock": "Vous avez des modifications non sauvegardées qui seront perdus. Continuer ?",
+  "appAutoSave": "Sauver les modifications automatiquement",
+  "appSaveError": "Sauver l'erreur",
+  "appSaveErrorBody": "Échec sauvegarde auto du fichier",
+  "appSaveErrorBodyMul": "Échec sauvegarde auto des fichiers",
+  "appSaveErrorExitLoseChanges": "Afsluiten en alle aanpassingen kwijtraken",
+  "appSaveErrorExitLoseChangesBody": "Je kunt de app afsluiten en alle wijzigingen kwijtraken, of je kunt de bestandsinstellingen gebruiken om gegevens te exporteren",
+  "appSettingsError": "Erreur lancement appli",
+  "appSettingsErrorBody": "Il y a eu une erreur lors du chargement des paramètres. Merci de revérifier l'URL de l'application ou contacter votre administrateur.",
+  "appNotSupportedError": "Votre navigateur n'est pas compatible avec certaines fonctionnalités importantes que nous utilisons.",
+  "appTabWarn": "Trop d'onglets",
+  "appTabWarnBody": "KeeWeb ne peut être utilisé dans 2 onglets de navigateurs simultanément. Fermer cet onglet, s'il vous plait.",
+  "appRightsAlert": "Protéger l'appli KeeWeb",
+  "appRightsAlertBody1": "Votre application KeeWeb est accessible en écriture. Nous demandons les droits administrateurs pour le mettre en écriture uniquement pour les administrateurs.",
+  "appRightsAlertBody2": "Vous ne voulez pas donner les permissions ? Vous pouvez le faire vous-même à partir d'un terminal",
+  "appBrowserAuthComplete": "Authentification terminée, vous pouvez fermer cet onglet.",
+  "setGenTitle": "Paramètres",
+  "setGenUpdate": "Mettre à jour",
+  "setGenNewVersion": "Une nouvelle version a été téléchargée",
+  "setGenReleaseNotes": "Voir les notes de version",
+  "setGenReloadToUpdate": "Recharger pour mettre à jour",
+  "setGenUpdateManual": "Une nouvelle version est disponible. Elle vérifiera les mises à jour et les installera automatiquement, mais cette mise à jour automatique à partir de votre version n'est pas possible.",
+  "setGenDownloadUpdate": "Télécharger mise à jour",
+  "setGenUpdateAuto": "Télécharger et installer automatiquement",
+  "setGenUpdateCheck": "Vérifier mais ne pas installer",
+  "setGenNoUpdate": "Ne jamais vérifier les mises à jour",
+  "setGenUpdateChecking": "Vérification des mises à jour",
+  "setGenCheckUpdate": "Vérifier les mises à jour",
+  "setGenErrorChecking": "Erreur vérification des mises à jour",
+  "setGenLastCheckSuccess": "Dernière vérification réussie fut le {}",
+  "setGenLastCheckVer": "la dernière version était {}",
+  "setGenCheckedAt": "Vérifié le",
+  "setGenLatestVer": "vous utilisez la dernière version",
+  "setGenNewVer": "nouvelle version {} disponible",
+  "setGenDownloadingUpdate": "Téléchargement de la mise à jour...",
+  "setGenExtractingUpdate": "Décompression de la mise à jour...",
+  "setGenCheckErr": "Une erreur est intervenue durant le téléchargement de la mise à jour",
+  "setGenNeverChecked": "Ne jamais vérifier les mises à jour",
+  "setGenRestartToUpdate": "Redémarrer KeeWeb pour mettre à jour",
+  "setGenDownloadAndRestart": "Télécharger la mise à jour et redémarrer",
+  "setGenAppearance": "Apparence",
+  "setGenTheme": "Thème",
+  "setGenThemeDefault": "Défaut",
+  "setGenThemeDark": "Sombre",
+  "setGenThemeLight": "Clair",
+  "setGenThemeBlue": "Bleu",
+  "setGenThemeFb": "Bleu foncé",
+  "setGenThemeBl": "Bleu clair",
+  "setGenThemeBrown": "Brownie",
+  "setGenThemeDb": "Marron foncé",
+  "setGenThemeLb": "Brun clair",
+  "setGenThemeTerminal": "Terminal",
+  "setGenThemeTe": "Terminal",
+  "setGenThemeLt": "Terminal clair",
+  "setGenThemeHighContrast": "Contraste élevé",
+  "setGenThemeHc": "Contraste élevé",
+  "setGenThemeDc": "Contraste foncé",
+  "setGenThemeSol": "Solarisé",
+  "setGenThemeSd": "Solarized dark",
+  "setGenThemeSl": "Solarized light",
+  "setGenMoreThemes": "Plus de thèmes",
+  "setGenAutoSwitchTheme": "Basculer automatiquement entre les thèmes clairs et foncés lorsque possible",
+  "setGenLocale": "Langue",
+  "setGenLocOther": "d'autres langues sont disponibles en tant que modules",
+  "setGenFontSize": "Taille de police",
+  "setGenFontSizeNormal": "Normal",
+  "setGenFontSizeLarge": "Large",
+  "setGenFontSizeLargest": "Très large",
+  "setGenTitlebarStyle": "Style de fenêtres (redémarrage requis)",
+  "setGenTitlebarStyleDefault": "Par défaut",
+  "setGenTitlebarStyleHidden": "Titre personnalisé",
+  "setGenTitlebarStyleHiddenInset": "Titre personnalisé, fenêtre déplaçable",
+  "setGenShowSubgroups": "Afficher les entrées de tous les sous groupes",
+  "setGenTableView": "Voir les entrées en liste",
+  "setGenColorfulIcons": "Icônes colorées dans la liste",
+  "setGenUseMarkdown": "Markdown dans les notes",
+  "setGenUseGroupIconForEntries": "Utilise automatiquement l'icône de groupe pour les nouvelles entrées",
+  "setGenDirectAutotype": "Si une seule entrée correspondante est trouvée, sélectionner celle-ci automatiquement pour l'autotype.",
+  "setGenFunction": "Opérations",
+  "setGenAutoSyncOnClose": "Sauvegarde et synchro automatique à la fermeture",
+  "setGenAutoSyncTimer": "Sauvegarde et synchro automatique régulièrement",
+  "setGenAutoSyncTimerOff": "Désactivé",
+  "setGenAutoSyncTimerInterval": "Toutes les {} minute(s)",
+  "setGenRememberKeyFiles": "Se souvenir des fichiers clé",
+  "setGenNoRememberKeyFiles": "Ne pas se souvenir",
+  "setGenRememberKeyFilesData": "Sauvegarder dans le stockage interne de l'appli",
+  "setGenRememberKeyFilesPath": "Se souvenir seulement des chemins des fichiers",
+  "setGenLockInactive": "si l'application est inactive",
+  "setGenNoAutoLock": "Ne pas verrouiller automatiquement",
+  "setGenLockMinutes": "Dans {} minutes",
+  "setGenLockHour": "Dans une heure",
+  "setGenLockHours": "Dans {} heures",
+  "setGenLockDay": "Dans 1 jour",
+  "setGenClearClip": "Vider le presse-papier après une copie",
+  "setGenNoClear": "Ne pas effacer",
+  "setGenClearSeconds": "Dans {} secondes",
+  "setGenClearMinute": "Dans une minute",
+  "setGenMinInstead": "Réduire l'application au lieu de fermer",
+  "setGenMinOnFieldCopy": "Réduire sur copie d'un champ",
+  "setGenLock": "Verrou Auto",
+  "setGenLockMinimize": "quand l'appli est en arrière-plan",
+  "setGenLockCopy": "sur copie de m.d.p.",
+  "setGenLockAutoType": "sur saisie auto",
+  "setGenLockOrSleep": "Quand l'ordinateur est verrouillé ou mis en sommeil",
+  "setGenStorage": "Stockage",
+  "setGenDisableOfflineStorage": "Ne pas mettre en cache des fichiers d'un stockage offline",
+  "setGenShortLivedStorageToken": "Utiliser des sessions de courte-durée avec les fournisseurs de stockage dans le cloud",
+  "setGenStorageLogout": "Déconnexion",
+  "setGenShowAdvanced": "Afficher les paramètres avancés",
+  "setGenDevTools": "Afficher les outils de développement",
+  "setGenTryBeta": "Essayer une fois la version beta ",
+  "setGenTryBetaWarning": "Fichiers non sauvegardés",
+  "setGenTryBetaWarningBody": "Sauvegarder tous les fichiers et re-cliquer ce bouton",
+  "setGenShowAppLogs": "Voir les logs",
+  "setGenReloadApp": "Recharger l'application",
+  "setGenFieldLabelDblClickAutoType": "Remplissage auto par double clic sur les noms de champ",
+  "setGenTouchId": "Touch ID",
+  "setGenTouchIdDisabled": "Ne pas utiliser Touch ID",
+  "setGenTouchIdMemory": "Dévérouiller avec Touch ID uniquement quand KeeWeb est lancé",
+  "setGenTouchIdFile": "Toujours utiliser Touch ID à la place du mot de passe",
+  "setGenTouchIdPass": "Exige le mot de passe après",
+  "setGenAudit": "Audit",
+  "setGenAuditPasswords": "Voir des avertissements sur la force du mot de passe",
+  "setGenAuditPasswordEntropy": "Vérifier la longueur et l'aléas du mot de passe",
+  "setGenExcludePinsFromAudit": "Ne jamais vérifier les codes PIN courts, comme 123456",
+  "setGenCheckPasswordsOnHIBP": "Vérifier les mots de passe en utilisant un service en ligne {}",
+  "setGenHelpHIBP": "KeeWeb peut vérifier si vos mots de passes ont été précédemment exposés à une faille de sécurité en utilisant un service en ligne. Votre mot de passe ne peut pas être récupéré à partir de données envoyées en ligne, cependant le nombre de mots de passes vérifiés peut être exposé. Plus d'informations sur votre sécurité en utilisant ce service peuvent être trouvées {}. Si cette option est activée, KeeWeb vérifiera automatiquement vos mots de passes là.",
+  "setGenHelpHIBPLink": "ici",
+  "setGenAuditPasswordAge": "Vieux mots de passe",
+  "setGenAuditPasswordAgeOff": "Ne pas afficher d'avertissements à propos des vieux mots de passe",
+  "setGenAuditPasswordAgeOneYear": "Afficher des avertissements pour les mots de passe plus vieux qu'un an",
+  "setGenAuditPasswordAgeYears": "Afficher des avertissement pour les mots de passe plus vieux que {} ans",
+  "setFilePath": "Chemin",
+  "setFileStorage": "Le fichier est ouvert de {}.",
+  "setFileIntl": "Le fichier est conservé dans le stockage interne de l'application",
+  "setFileLocalHint": "Voulez-vous travailler avec des fichiers locaux ?",
+  "setFileDownloadApp": "Télécharger l'application",
+  "setFileSave": "Enregistrer",
+  "setFileSaveTo": "Enregistrer sous...",
+  "setFileClose": "Fermer",
+  "setFileSync": "Sync",
+  "setFileSyncVerb": "Synchroniser",
+  "setFileSaveToXml": "XML",
+  "setFileSaveToHtml": "HTML",
+  "setFileLastSync": "Dernière synchro",
+  "setFileLastSyncUnknown": "inconnu",
+  "setFileSyncInProgress": "synchronisation en cours",
+  "setFileSyncError": "Sync erreur",
+  "setFilePass": "Mot de passe principal",
+  "setFileConfirmPass": "Confirmer le mot de passe Maître",
+  "setFilePassChange": "pour changer le mot de passe, merci de le saisir dans le champ Confirmation",
+  "setFilePassChanged": "Le mot de passe a été changé ; laissez le champ vide pour utiliser l'ancien mot de passe",
+  "setFilePassNotMatch": "les mots de passe ne correspondent pas, veuillez  réessayer",
+  "setFileKeyFile": "Fichier clé",
+  "setFileSelKeyFile": "Sélectionner fichier clé",
+  "setFileNames": "Noms",
+  "setFileDefUser": "Utilisateur par défaut",
+  "setFileEnableTrash": "Activer corbeille",
+  "setFileHistMode": "Historique",
+  "setFileHistLimited": "Supprimer les anciens enregistrements automatiquement",
+  "setFileHistDisabled": "Ne pas sauvegarder l'historique",
+  "setFileHistUnlimited": "Garder les enregistrements de l'historique pour toujours",
+  "setFileHistLen": "Longueur de l'historique, conserve les derniers enregistrements",
+  "setFileHistSize": "Taille de l'historique, Mo par fichier",
+  "setFileBackups": "Sauvegardes",
+  "setFileBackupEnable": "Sauvegarder ce fichier",
+  "setFileBackupPath": "Chemin",
+  "setFileBackupTime": "Lancer sauvegardes ",
+  "setFileBackupNow": "Sauvegarder...",
+  "setFileBackupNowWorking": "En cours...",
+  "setFileBackupError": "Erreur sauvegarde",
+  "setFileBackupErrorDescription": "Erreur à l'écriture du fichier",
+  "setFileBackupErrorIsDir": "Chemin de sauvegarde invalide",
+  "setFileBackupErrorIsDirDescription": "Le chemin de sauvegarde semble pointer sur un répertoire. Merci de spécifier un fichier dans un répertoire à la place.",
+  "setFileBackupOnSave": "A chaque fois que je sauvegarde",
+  "setFileBackupDaily": "Quotidien",
+  "setFileBackupWeekly": "Chaque semaine",
+  "setFileBackupMonthly": "Chaque mois",
+  "setFileBackupManually": "Manuellement, pas de sauvegarde automatique",
+  "setFileRounds": "Cycles de chiffrement de la clé",
+  "setFileKdfParams": "Fonction de dérivation de clé",
+  "setFileKdfParamsIter": "Itérations",
+  "setFileKdfParamsMem": "Mémoire, Ko",
+  "setFileKdfParamsPar": "Parallèlisme",
+  "setFileKeyChangeForce": "Demander à changer la clé après (jours)",
+  "setFileUseKeyFile": "Utiliser un fichier clé",
+  "setFileUseGenKeyFile": "Utiliser le fichier clé généré",
+  "setFileUseOldKeyFile": "Utiliser l'ancien fichier clé",
+  "setFileGenKeyFile": "Générer un nouveau fichier clé",
+  "setFileDontUseKeyFile": "Ne pas utiliser de fichier clé",
+  "setFileEmptyPass": "Mot de passe vide",
+  "setFileEmptyPassBody": "Sauvegarder la base de données avec un mot de passe vide la laisse sans aucune protection. Voulez-vous vraiment faire cela ?",
+  "setFileSaveError": "Erreur sauvegarde",
+  "setFileSaveErrorBody": "Erreur sauvegarde dans le fichier",
+  "setFileAlreadyExists": "Existe déjà",
+  "setFileAlreadyExistsBody": "Le fichier {} existe déjà. L'écraser ?",
+  "setFileUnsaved": "Modif non sauvegardées",
+  "setFileUnsavedBody": "Il y a des modifications non sauvegardées dans ce fichier",
+  "setFileCloseNoSave": "Fermer et perdre les modifs",
+  "setFileDontClose": "Ne pas fermer",
+  "setFileFormatVersion": "Format de fichier",
+  "setFileExportRaw": "Exporter vos mots de passe",
+  "setFileExportRawBody": "Le fichier exporté contiendra vos mots de passe, il n'y seront plus cryptés. Voulez vous continuer ?",
+  "setFileDeviceIntro": "Les codes à usage unique de cette {} vont être affichés dans l'application.",
+  "setFileDeviceSettings": "Paramètres",
+  "setFileYubiKey": "YubiKey",
+  "setFileDontUseYubiKey": "Ne pas utiliser une YubiKey",
+  "setFileRefreshYubiKeyList": "Rafraichir la liste",
+  "setFileYubiKeyHeader": "YubiKey",
+  "setFileYubiKeyBody": "Utiliser une YubiKey comme partie de la clé maitre est dangeureux, et vous risquez de perdre l'accès à vos mots de passe si quelque chose tourne mal. Avez vous réalisé une sauvegarde de votre fichier avant de modifier les paramètres ?",
+  "setFileYubiKeyErrorEmptyMac": "Il semble qu'il y a une YubiKey connectée, mais elle est invisible. KeeWeb doit avoir été autorisé dans la section \"Surveillance de l’entrée\" des paramètres de sécurité pour se connecter à la YubiKey.",
+  "setShTitle": "Raccourcis",
+  "setShShowAll": "montrer tout",
+  "setShColors": "montrer les champs en couleur",
+  "setShTrash": "aller à Corbeille",
+  "setShFind": "rechercher ou juste commencer à taper",
+  "setShClearSearch": "effacer recherche",
+  "setShCopyPass": "copier le mot de passe ou le champ sélectionné",
+  "setShCopyUser": "copier le nom",
+  "setShCopyUrl": "copier le site",
+  "setShAutoType": "saisie automatique pour cette entrée",
+  "setShPrev": "aller au précédent",
+  "setShNext": "aller au prochain",
+  "setShCreateEntry": "créer une entrée",
+  "setShOpen": "ouvrir/nouveau",
+  "setShSave": "sauver tous les fichiers",
+  "setShGen": "générer un mot de passe",
+  "setShSet": "paramètres",
+  "setShCopyPassGlobal": "copier le mot de passe",
+  "setShCopyOtp": "Copier l'OTP",
+  "setShAutoTypeGlobal": "saisie automatique",
+  "setShCopyPassOnly": "Copier mot de passe",
+  "setShRestoreApp": "Ouvrir {}",
+  "setShGlobal": "Ces raccourcis à l'échelle du système fonctionnent lorsque l'application s'exécute en arrière-plan. Vous pouvez cliquer dessus pour sélectionner votre propre raccourci.",
+  "setShLock": "verrouiller la base",
+  "setShEdit": "Appuyez sur une nouvelle combinaison de touches pour la définir comme raccourci.",
+  "setPlInstallTitle": "Installer de nouveaux modules",
+  "setPlInstallDesc": "Les modules (plugins) de KeeWeb ajoutent des fonctionnalités, thèmes et langues à KeeWeb. Les modules sont lancés avec les même privilèges que KeeWeb : ils peuvent accéder et gérer tous vos mots de passe. Ne jamais installer de modules auxquels vous ne faites pas confiance.",
+  "setPlInstallLabel": "URL du module",
+  "setPlInstallBtn": "Installer",
+  "setPlInstallBtnProgress": "Installation",
+  "setPlUninstallBtn": "Désintaller",
+  "setPlDisableBtn": "Désactiver",
+  "setPlEnableBtn": "Activer",
+  "setPlUpdateBtn": "Mettre à jour",
+  "setPlLocaleBtn": "Changer pour cette langue",
+  "setPlThemeBtn": "Changer pour ce thème",
+  "setPlJs": "code",
+  "setPlCss": "styles",
+  "setPlLoc": "langue",
+  "setPlCreatedBy": "Créé par {}",
+  "setPlLoadTime": "{} pour charger",
+  "setPlLastUpdate": "Dernière vérification des mises à jour",
+  "setPlLoadError": "erreur au chargement du module",
+  "setPlGalleryLoading": "Chargement des modules, patientez un instant",
+  "setPlGalleryLoadError": "erreur au chargement des modules",
+  "setPlInstallUrlTitle": "Ajouter un module à partir d'une URL",
+  "setPlInstallUrlDesc": "Si un module n'est pas dans le catalogue, vous pouvez l'installer manuellement à partir d'une URL.",
+  "setPlOfficial": "Module officiel KeeWeb",
+  "setPlSearch": "Rechercher des modules",
+  "setPlDevelop": "Vous souhaitez développer vos propres modules ?",
+  "setPlDevelopStart": "Commencez ici",
+  "setPlTranslate": "Ou vous pouvez {}",
+  "setPlTranslateLink": "traduire l'appli dans votre langue",
+  "setPlAutoUpdate": "Mise à jour automatique",
+  "setPlLoadGallery": "Charger le catalogue",
+  "setDevicesTitle": "Appareils",
+  "setDevicesEnableUsb": "Autoriser les interactions avec les appareils USB",
+  "setDevicesYubiKeyIntro": "Il est recommandé de lire {} avant d'utiliser une YubiKey.",
+  "setDevicesYubiKeyIntroLink": "ce document",
+  "setDevicesYubiKeyToolsDesc": "Pour permettre l'utilisation de YubiKey dans ce mode, vous devez installer un outil appelé {}.",
+  "setDevicesYubiKeyToolsDesc2": "{} pour avoir plus d'information sur cet outil.",
+  "setDevicesYubiKeyToolsDescLink": "Cliquez ici",
+  "setDevicesYubiKeyToolsStatusChecking": "Vérification si {} est installé",
+  "setDevicesYubiKeyToolsStatusOk": "{} est installé",
+  "setDevicesYubiKeyToolsStatusError": "{} n'est pas installé, ou ne fonctionne pas",
+  "setDevicesYubiKeyOtpTitle": "Codes à usage unique",
+  "setDevicesYubiKeyOtpDesc": "YubiKey peut être utilisé pour générer des codes à usage unique pour différents services.",
+  "setDevicesYubiKeyOtpShowIcon": "Afficher l'icône sur l'écran de démarrage",
+  "setDevicesYubiKeyOtpAutoOpen": "Charger automatiquement les codes à usage unique lorsqu'il y a des fichiers ouverts",
+  "setDevicesYubiKeyOtpMatchEntries": "Afficher les codes à usage unique qui correspondent dans les entrées",
+  "setDevicesYubiKeyChalRespTitle": "Challenge-Réponse",
+  "setDevicesYubiKeyChalRespDesc": "Il est aussi possible d'utiliser une YubiKey en mode Challenge-Réponse, afin qu'une partie de la clé privée utilisée pour crypter les fichiers provienne d'une YubiKey.",
+  "setDevicesYubiKeyChalRespShow": "Proposer l'option d'utiliser une YubiKey à l'ouverture des fichiers",
+  "setDevicesYubiKeyStuckWorkaround": "Reconnecter la YubiKey si elle semble bloquée au moment du chargement",
+  "setDevicesYubiKeyRememberChalResp": "Se souvenir du challenge-réponse le temps que l'application reste ouverte",
+  "setAboutTitle": "À propos",
+  "setAboutBuilt": "Cette appli est construite avec ces outils géniaux",
+  "setAboutLic": "Licence",
+  "setAboutLicComment": "Cette application et tous les composants qu'elle contient qui ne sont pas dans le domaine public sont sous licence MIT, sauf si autrement spécifié",
+  "setAboutFirst": "Ceci est une application open-source créée par {}",
+  "setAboutSecond": " et sous licence {}.",
+  "setAboutSource": "Le code source et les problèmes sont sur {}.",
+  "setHelpFormat": "Format de fichier",
+  "setHelpFormatBody": "Ceci est un portage de l'appli {} développée avec les technologies web. Il interprète les fichiers au format KeePass  (kdbx). Vous pouvez créer de tels fichiers (bases de données de mots de passe) soit avec KeePass, soit avec cette appli. Le format de fichier est 100% compatible et devrait être compris par les 2 applications.",
+  "setHelpProblems": "Un problème ?",
+  "setHelpProblems1": "Si quelque chose ne va pas, merci de {}",
+  "setHelpProblems2": "ou {}",
+  "setHelpOpenIssue": "faire connaître le problème sur GitHub",
+  "setHelpContactLink": "contactez le développeur directement",
+  "setHelpAppInfo": "Information",
+  "setHelpOtherPlatforms": "Autres plateformes",
+  "setHelpDesktopApps": "Applis Desktop",
+  "setHelpWebApp": "Appli web",
+  "setHelpUpdates": "Mises à jour",
+  "setHelpTwitter": "Appli twitter",
+  "dropboxSetupDesc": "Une configuration particulière est nécessaire pour utiliser Dropbox dans une application auto-hébergée. Merci de créer votre propre application Dropbox et d'inscrire sa clé ci-dessous.",
+  "dropboxAppKey": "Clé Dropbox",
+  "dropboxAppKeyDesc": "Copier la clé de votre appli Dropbox (Réglages développeur)",
+  "dropboxAppKeyHint": "Votre \"Dropbox App Key\"",
+  "dropboxAppSecret": "Votre \"Dropbox App Secret\"",
+  "dropboxAppSecretDesc": "Votre \"Dropbox App Secret\" peut être trouvée à côté de votre \"Dropbox App Key\".",
+  "dropboxFolder": "Dossier Appli",
+  "dropboxFolderDesc": "Si votre appli est liée à l'espace Dropbox entier (et non un dossier), définir le dossier avec vos fichiers Kdbx ici",
+  "dropboxFolderSettingsDesc": "Sélectionner un dossier dans votre Dropbox où les fichiers sont stockés (à la racine par défaut)",
+  "dropboxFolderPlaceholder": "dossier par défaut",
+  "dropboxLink": "Lier l'appli à",
+  "dropboxLinkApp": "Dossier de l'appli (Apps/KeeWeb)",
+  "dropboxLinkFull": "Tout Dropbox ou n'importe quel dossier",
+  "dropboxLinkCustom": "Votre appli Dropbox",
+  "gdriveSharedWithMe": "Partagé avec moi",
+  "webdavSaveMethod": "Méthode de sauvegarde",
+  "webdavSaveMove": "Envoyer un fichier temporaire et le déplacer",
+  "webdavSavePut": "Écraser le fichier kdbx avec PUT",
+  "webdavNoLastModified": "L'entête HTTP \"Last-Modified\" est absent",
+  "webdavStatReload": "Toujours recharger le fichier au lieu de se fier à l'entête HTTP \"Last-Modified\"",
+  "launcherSave": "Sauvegarder base des mots de passe",
+  "launcherFileFilter": "Fichiers Keepass",
+  "authPopupRequired": "Les pop-up sont bloquées",
+  "authPopupRequiredBody": "Merci d'autoriser les pop-ups pour cette appli dans votre navigateur ou essayez à nouveau.",
+  "exportFileInfo": "Propriétés du fichier",
+  "exportHtmlName": "Nom",
+  "exportHtmlDate": "Date d'exportation",
+  "exportGenerator": "Logiciel",
+  "exportDescription": "Ce fichier est généré par {}.",
+  "importCsvTitle": "Import depuis un CSV",
+  "importCsvRun": "Importer",
+  "importIgnoreField": "Ignorer",
+  "importTo": "Les entrées seront importées dans",
+  "importNewFile": "Nouveau fichier",
+  "yubiKeyStuckError": "La YubiKey semble coincée, la réparation automatique est activable dans les paramètres de l'application.",
+  "yubiKeyNoKeyHeader": "Une YubiKey est requise",
+  "yubiKeyNoKeyBody": "Merci d'insérer votre YubiKey avec le numéro de série {}",
+  "yubiKeySlot": "port",
+  "yubiKeyTouchRequestedHeader": "Touchez votre YubiKey",
+  "yubiKeyTouchRequestedBody": "Merci de toucher votre YubiKey avec le numéro de série {}",
+  "yubiKeyDisabledErrorHeader": "L'USB est désactivé",
+  "yubiKeyDisabledErrorBody": "Yubikey est nécessaire pour ouvrir ce fichier, merci d'activer les appareils USB dans les paramètres",
+  "yubiKeyErrorWithCode": "Erreur Yubikey code {}.",
+  "bioOpenAuthPrompt": "ouvrir \"{}\""
+}

app/manifest.appcache

@@ -1,10 +0,0 @@
-CACHE MANIFEST
-
-# YYYY-MM-DD:v0.0.0
-# updmin:v0.0.0
-
-CACHE:
-index.html
-
-NETWORK:
-*

app/manifest/browserconfig.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<browserconfig>
+    <msapplication>
+        <tile>
+            <square70x70logo src="/icons/mstile-70x70.png"/>
+            <square150x150logo src="/icons/mstile-150x150.png"/>
+            <square310x310logo src="/icons/mstile-310x310.png"/>
+            <wide310x150logo src="/icons/mstile-310x150.png"/>
+            <TileColor>#6386ec</TileColor>
+        </tile>
+    </msapplication>
+</browserconfig>

app/manifest/manifest.json

@@ -0,0 +1,21 @@
+{
+    "name": "KeeWeb",
+    "short_name": "KeeWeb",
+    "description": "Free cross-platform password manager compatible with KeePass",
+    "start_url": "./",
+    "display": "standalone",
+    "theme_color": "#6386ec",
+    "background_color": "#6386ec",
+    "icons": [
+        {
+            "src": "icons/android-chrome-192x192.png",
+            "sizes": "192x192",
+            "type": "image/png"
+        },
+        {
+            "src": "icons/android-chrome-512x512.png",
+            "sizes": "512x512",
+            "type": "image/png"
+        }
+    ]
+}

app/resources/public-key-new.pem

@@ -0,0 +1,9 @@
+-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyZAmWXMpKsh9WCyUO5TR
+2/QIJsgyaViWRAgY5nHZhTR/sjhfG97OeurW7NYC4XPsnyJDepEjDsj9LNzquMES
+xsLRSmxo+m1lVWn8Q59LwqOvUK+BKH4eZYF89Nwv2HZjZnr/w7xYcxJbhOuAzpbq
+FD/gAvlozrsHG9uI95h1FHPd6mfolEHLK30LXPQ5FdJ/AWb29ILKYbVEdM8qsjoN
+fSICw7XTbd7wB0TMcgRpjWllzKaftxCO38svhBjAz4cUvtZ05yi4dzK0VsJHfW33
+uno3YBn0/bwLkqMzD1/Hv05p6CVzuDTOCBsXkEobra8OBviatoSukot6cS4Famki
+9QIDAQAB
+-----END PUBLIC KEY-----

app/resources/public-key.pem

@@ -0,0 +1,9 @@
+-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnRq2k3TTx0ewTe6wDr6Q
+VeB5diwiIWzsJD+ApfZu1KNPedcAgslAfjpNsYF1if6cYsPMJH70xJ2np6RQBl1V
+PdwShOuxkD7m0BD5Hw/Aar8Hdp5cvAdOOMdBO+0DbGeUMy+z66s+oUCJmqVp19T6
+PkkxbhN08rgtT7v+aFvrbqbO/vlsskbJpH2K2io+e1XmRGPnSr9q4KSqfGbTfe5g
+LwDIOFd66Z4mb5Utb5wWpsy6Gjh06Yf257AccGD3A1bkTNOyeeX0tqciYBePWMk0
+icP/aZ6hnErfhnUKf3tOgPLppSHiGcaSKekhChZ2xLUs3U64JwrXSmwHj+TzdO3S
+0QIDAQAB
+-----END PUBLIC KEY-----

app/scripts/app.js

@@ -1,43 +0,0 @@
-'use strict';
-
-var AppModel = require('./models/app-model'),
-    AppView = require('./views/app-view'),
-    KeyHandler = require('./comp/key-handler'),
-    IdleTracker = require('./comp/idle-tracker'),
-    Alerts = require('./comp/alerts'),
-    DropboxLink = require('./comp/dropbox-link'),
-    Updater = require('./comp/updater'),
-    ThemeChanger = require('./util/theme-changer'),
-    Locale = require('./util/locale');
-
-$(function() {
-    if (location.href.indexOf('state=') >= 0) {
-        DropboxLink.receive();
-        return;
-    }
-    require('./mixins/view');
-    require('./helpers');
-    KeyHandler.init();
-    IdleTracker.init();
-
-    var appModel = new AppModel();
-    if (appModel.settings.get('theme')) {
-        ThemeChanger.setTheme(appModel.settings.get('theme'));
-    }
-    if (['https:', 'file:', 'app:'].indexOf(location.protocol) < 0 && !localStorage.disableSecurityCheck) {
-        Alerts.error({ header: Locale.appSecWarn, icon: 'user-secret', esc: false, enter: false, click: false,
-            body: Locale.appSecWarnBody1 + '<br/><br/>' + Locale.appSecWarnBody2,
-            buttons: [
-                { result: '', title: Locale.appSecWarnBtn, error: true }
-            ],
-            complete: showApp
-        });
-    } else {
-        showApp();
-    }
-
-    function showApp() {
-        new AppView({ model: appModel }).render();
-        Updater.init();
-    }
-});

app/scripts/auto-type/auto-type-emitter.js

@@ -0,0 +1,160 @@
+import { Features } from 'util/features';
+import { NativeModules } from 'comp/launcher/native-modules';
+import { Logger } from 'util/logger';
+import { Launcher } from 'comp/launcher';
+import { Timeouts } from 'const/timeouts';
+
+const logger = new Logger('auto-type-emitter');
+
+const KeyMap = {
+    tab: 'Tab',
+    enter: 'Return',
+    space: 'Space',
+    up: 'UpArrow',
+    down: 'DownArrow',
+    left: 'LeftArrow',
+    right: 'RightArrow',
+    home: 'Home',
+    end: 'End',
+    pgup: 'PageUp',
+    pgdn: 'PageDown',
+    ins: 'Insert',
+    del: 'ForwardDelete',
+    bs: 'BackwardDelete',
+    esc: 'Escape',
+    win: 'Meta',
+    rwin: 'RightMeta',
+    f1: 'F1',
+    f2: 'F2',
+    f3: 'F3',
+    f4: 'F4',
+    f5: 'F5',
+    f6: 'F6',
+    f7: 'F7',
+    f8: 'F8',
+    f9: 'F9',
+    f10: 'F10',
+    f11: 'F11',
+    f12: 'F12',
+    f13: 'F13',
+    f14: 'F14',
+    f15: 'F15',
+    f16: 'F16',
+    add: 'KeypadPlus',
+    subtract: 'KeypadMinus',
+    multiply: 'KeypadMultiply',
+    divide: 'KeypadDivide',
+    n0: 'D0',
+    n1: 'D1',
+    n2: 'D2',
+    n3: 'D3',
+    n4: 'D4',
+    n5: 'D5',
+    n6: 'D6',
+    n7: 'D7',
+    n8: 'D8',
+    n9: 'D9'
+};
+
+const ModMap = {
+    '^': Features.isMac ? 'Command' : 'Ctrl',
+    '+': 'Shift',
+    '%': 'Alt',
+    '^^': 'Ctrl'
+};
+
+class AutoTypeEmitter {
+    constructor(callback) {
+        this.callback = callback;
+        this.mod = {};
+    }
+
+    begin() {
+        this.withCallback(NativeModules.kbdEnsureModifierNotPressed());
+    }
+
+    setMod(mod, enabled) {
+        const nativeMod = ModMap[mod];
+        if (!nativeMod) {
+            return this.callback(`Bad modifier: ${mod}`);
+        }
+        NativeModules.kbdKeyMoveWithModifier(!!enabled, [nativeMod]).catch((e) => {
+            logger.error('Error moving modifier', mod, enabled ? 'down' : 'up', e);
+        });
+        if (enabled) {
+            this.mod[nativeMod] = true;
+        } else {
+            delete this.mod[nativeMod];
+        }
+    }
+
+    text(str) {
+        if (!str) {
+            return this.withCallback(Promise.resolve());
+        }
+        const mods = Object.keys(this.mod);
+        if (mods.length) {
+            this.withCallback(NativeModules.kbdTextAsKeys(str, mods));
+        } else {
+            this.withCallback(NativeModules.kbdText(str));
+        }
+    }
+
+    key(key) {
+        const mods = Object.keys(this.mod);
+        if (typeof key === 'number') {
+            this.withCallback(NativeModules.kbdKeyPressWithCharacter(0, key, mods));
+        } else {
+            if (!KeyMap[key]) {
+                return this.callback('Bad key: ' + key);
+            }
+            const code = KeyMap[key];
+            this.withCallback(NativeModules.kbdKeyPress(code, mods));
+        }
+    }
+
+    copyPaste(text) {
+        setTimeout(() => {
+            Launcher.setClipboardText(text);
+            setTimeout(() => {
+                this.withCallback(NativeModules.kbdShortcut('V'));
+            }, Timeouts.AutoTypeCopyPaste);
+        }, Timeouts.AutoTypeCopyPaste);
+    }
+
+    wait(time) {
+        setTimeout(() => this.withCallback(Promise.resolve()), time);
+    }
+
+    waitComplete() {
+        this.withCallback(Promise.resolve());
+    }
+
+    setDelay() {
+        this.callback('Not implemented');
+    }
+
+    withCallback(promise) {
+        promise
+            .then(() => {
+                try {
+                    this.callback();
+                } catch (err) {
+                    logger.error('Callback error', err);
+                }
+            })
+            .catch((err) => {
+                const keyPressFailed = err.message === 'Key press failed';
+                if (keyPressFailed) {
+                    err.keyPressFailed = true;
+                }
+                try {
+                    this.callback(err);
+                } catch (err) {
+                    logger.error('Callback error', err);
+                }
+            });
+    }
+}
+
+export { AutoTypeEmitter };

app/scripts/auto-type/auto-type-helper.js

@@ -0,0 +1,16 @@
+import { NativeModules } from 'comp/launcher/native-modules';
+
+class AutoTypeHelper {
+    getActiveWindowInfo(callback) {
+        NativeModules.kbdGetActiveWindow({
+            getWindowTitle: true,
+            getBrowserUrl: true
+        })
+            .then((win) => {
+                callback(undefined, win);
+            })
+            .catch((err) => callback(err));
+    }
+}
+
+export { AutoTypeHelper };

app/scripts/auto-type/auto-type-obfuscator.js

@@ -0,0 +1,205 @@
+import { Logger } from 'util/logger';
+
+const logger = new Logger('auto-type-obfuscator');
+
+const MaxFakeOps = 30;
+const MaxSteps = 1000;
+const MaxCopy = 2;
+const FakeCharAlphabet = 'ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnpqrstuvwxyz123456789O0oIl';
+
+const AutoTypeObfuscator = function (chars) {
+    this.chars = chars;
+    this.inputChars = [];
+    this.inputCursor = 0;
+    this.inputSel = 0;
+    this.ops = [];
+    this.stepCount = 0;
+    this.copyCount = 0;
+};
+
+AutoTypeObfuscator.prototype.obfuscate = function () {
+    while (!this.finished()) {
+        this.step();
+        if (this.stepCount++ > MaxSteps) {
+            throw 'Obfuscate failed';
+        }
+    }
+    for (let i = 0; i < this.chars.length; i++) {
+        this.chars[i] = null;
+        this.inputChars[i] = null;
+    }
+    return this.ops;
+};
+
+AutoTypeObfuscator.prototype.finished = function () {
+    return (
+        this.chars.length === this.inputChars.length &&
+        this.chars.every(function (ch, ix) {
+            return this.inputChars[ix].ch === ch;
+        }, this)
+    );
+};
+
+AutoTypeObfuscator.prototype.step = function () {
+    const isFake = this.stepCount < MaxFakeOps && Math.random() > this.stepCount / MaxFakeOps;
+    if (isFake) {
+        this.stepFake();
+    } else {
+        this.stepReal();
+    }
+    if (logger.getLevel() >= Logger.Level.Debug) {
+        logger.debug('value', this.inputChars.map((ic) => ic.ch).join(''));
+    }
+};
+
+AutoTypeObfuscator.prototype.stepFake = function () {
+    const pos = Math.floor(Math.random() * (this.inputChars.length + 1));
+    const ch = FakeCharAlphabet[Math.floor(Math.random() * FakeCharAlphabet.length)];
+    logger.info('step.fake', pos, ch);
+    this.moveToPos(pos);
+    const insert = this.inputChars.length === 0 || Math.random() > 0.3;
+    if (insert) {
+        this.inputChar(ch);
+    } else {
+        let moveLeft = Math.random() > 0.5;
+        let maxMove = moveLeft ? pos : this.inputChars.length - pos;
+        if (maxMove === 0) {
+            moveLeft = !moveLeft;
+            maxMove = moveLeft ? pos : this.inputChars.length - pos;
+        }
+        const moveCount = Math.max(Math.floor(Math.pow(Math.random(), 3) * maxMove), 1);
+        if (moveCount <= 1 && Math.random() > 0.5) {
+            this.deleteText(moveLeft);
+        } else {
+            this.selectText(moveLeft, moveCount);
+            if (Math.random() > 0.3) {
+                this.deleteText(Math.random() > 0.5);
+            } else {
+                this.inputChar(ch);
+            }
+        }
+    }
+};
+
+AutoTypeObfuscator.prototype.stepReal = function () {
+    const possibleActions = [];
+    const inputRealPositions = [];
+    let i;
+    for (i = 0; i < this.chars.length; i++) {
+        inputRealPositions.push(-1);
+    }
+    for (i = 0; i < this.inputChars.length; i++) {
+        const ix = this.inputChars[i].ix;
+        if (ix === undefined) {
+            possibleActions.push({ del: true, pos: i });
+        } else {
+            inputRealPositions[ix] = i;
+        }
+    }
+    for (i = 0; i < this.chars.length; i++) {
+        if (inputRealPositions[i] < 0) {
+            let from = 0,
+                to = this.inputChars.length;
+            for (let j = 0; j < this.chars.length; j++) {
+                if (j < i && inputRealPositions[j] >= 0) {
+                    from = inputRealPositions[j] + 1;
+                }
+                if (j > i && inputRealPositions[j] >= 0) {
+                    to = inputRealPositions[j];
+                    break;
+                }
+            }
+            possibleActions.push({ ins: true, ch: this.chars[i], ix: i, from, to });
+        }
+    }
+    const action = possibleActions[Math.floor(Math.random() * possibleActions.length)];
+    logger.info('step.real', inputRealPositions, action);
+    if (action.del) {
+        this.moveToPos(action.pos + 1);
+        this.deleteText(true);
+    } else {
+        const insPos = action.from + Math.floor(Math.random() * (action.to - action.from));
+        this.moveToPos(insPos);
+        if (this.copyCount < MaxCopy && action.ch !== '\n' && Math.random() > 0.5) {
+            this.copyCount++;
+            this.copyPaste(action.ch);
+        } else {
+            this.inputChar(action.ch);
+        }
+        this.inputChars[insPos].ix = action.ix;
+    }
+};
+
+AutoTypeObfuscator.prototype.moveToPos = function (pos) {
+    logger.debug('moveToPos', pos);
+    while (this.inputCursor > pos) {
+        this.moveLeft();
+    }
+    while (this.inputCursor < pos) {
+        this.moveRight();
+    }
+};
+
+AutoTypeObfuscator.prototype.moveLeft = function () {
+    logger.debug('moveLeft');
+    this.ops.push({ type: 'key', value: 'left' });
+    this.inputCursor--;
+    this.inputSel = 0;
+};
+
+AutoTypeObfuscator.prototype.moveRight = function () {
+    logger.debug('moveRight');
+    this.ops.push({ type: 'key', value: 'right' });
+    this.inputCursor++;
+    this.inputSel = 0;
+};
+
+AutoTypeObfuscator.prototype.inputChar = function (ch) {
+    logger.debug('inputChar', ch);
+    this.ops.push({ type: 'text', value: ch });
+    this.inputChars.splice(this.inputCursor, this.inputSel, { ch });
+    this.inputCursor++;
+    this.inputSel = 0;
+};
+
+AutoTypeObfuscator.prototype.copyPaste = function (ch) {
+    logger.debug('copyPaste', ch);
+    this.ops.push({ type: 'cmd', value: 'copyPaste', arg: ch });
+    this.inputChars.splice(this.inputCursor, this.inputSel, { ch });
+    this.inputCursor++;
+    this.inputSel = 0;
+};
+
+AutoTypeObfuscator.prototype.selectText = function (backward, count) {
+    logger.debug('selectText', backward ? 'left' : 'right', count);
+    const ops = [];
+    for (let i = 0; i < count; i++) {
+        ops.push({ type: 'key', value: backward ? 'left' : 'right' });
+    }
+    if (ops.length === 1) {
+        ops[0].mod = { '+': true };
+        this.ops.push(ops[0]);
+    } else {
+        this.ops.push({ type: 'group', value: ops, mod: { '+': true } });
+    }
+    if (backward) {
+        this.inputCursor -= count;
+    }
+    this.inputSel = count;
+};
+
+AutoTypeObfuscator.prototype.deleteText = function (backward) {
+    logger.debug('deleteText', backward ? 'left' : 'right');
+    this.ops.push({ type: 'key', value: backward ? 'bs' : 'del' });
+    if (this.inputSel) {
+        this.inputChars.splice(this.inputCursor, this.inputSel);
+        this.inputSel = 0;
+    } else {
+        this.inputChars.splice(backward ? this.inputCursor - 1 : this.inputCursor, 1);
+        if (backward) {
+            this.inputCursor--;
+        }
+    }
+};
+
+export { AutoTypeObfuscator };

app/scripts/auto-type/auto-type-parser.js

@@ -0,0 +1,127 @@
+import { AutoTypeRunner } from 'auto-type/auto-type-runner';
+
+const AutoTypeParser = function (sequence) {
+    this.sequence = sequence;
+    this.ix = 0;
+    this.states = [];
+};
+
+AutoTypeParser.opRegex = /^(.*?)(?:([\s:=])[\s:=]*(.*))?$/;
+
+AutoTypeParser.prototype.parse = function () {
+    const len = this.sequence.length;
+    this.pushState();
+    while (this.ix < len) {
+        const ch = this.sequence[this.ix];
+        switch (ch) {
+            case '{':
+                this.readOp();
+                continue;
+            case '+':
+            case '%':
+            case '^':
+                this.readModifier(ch);
+                break;
+            case '(':
+                this.pushState();
+                break;
+            case ')':
+                this.popState();
+                break;
+            case ' ':
+                break;
+            case '~':
+                this.addOp('enter');
+                break;
+            default:
+                this.addChar(ch);
+                break;
+        }
+        this.ix++;
+    }
+    if (this.states.length !== 1) {
+        throw 'Groups count mismatch';
+    }
+    return new AutoTypeRunner(this.state().ops);
+};
+
+AutoTypeParser.prototype.pushState = function () {
+    this.states.unshift({
+        modifiers: null,
+        ops: []
+    });
+};
+
+AutoTypeParser.prototype.popState = function () {
+    if (this.states.length <= 1) {
+        throw 'Unexpected ")" at index ' + this.ix;
+    }
+    const state = this.states.shift();
+    this.addState(state);
+};
+
+AutoTypeParser.prototype.state = function () {
+    return this.states[0];
+};
+
+AutoTypeParser.prototype.readOp = function () {
+    const toIx = this.sequence.indexOf('}', this.ix + 2);
+    if (toIx < 0) {
+        throw 'Mismatched "{" at index ' + this.ix;
+    }
+    const contents = this.sequence.substring(this.ix + 1, toIx);
+    this.ix = toIx + 1;
+    if (contents.length === 1) {
+        this.addChar(contents);
+        return;
+    }
+    const [, op, sep, arg] = contents.match(AutoTypeParser.opRegex);
+    this.addOp(op, sep, arg);
+};
+
+AutoTypeParser.prototype.readModifier = function (modifier) {
+    const state = this.state();
+    if (!state.modifiers) {
+        state.modifiers = {};
+    }
+    if (modifier === '^' && state.modifiers['^']) {
+        delete state.modifiers['^'];
+        modifier = '^^';
+    }
+    state.modifiers[modifier] = true;
+};
+
+AutoTypeParser.prototype.resetModifiers = function () {
+    const state = this.state();
+    const modifiers = state.modifiers;
+    state.modifiers = null;
+    return modifiers;
+};
+
+AutoTypeParser.prototype.addState = function (state) {
+    this.state().ops.push({
+        type: 'group',
+        value: state.ops,
+        mod: this.resetModifiers()
+    });
+};
+
+AutoTypeParser.prototype.addChar = function (ch) {
+    this.state().ops.push({
+        type: 'text',
+        value: ch,
+        mod: this.resetModifiers()
+    });
+};
+
+AutoTypeParser.prototype.addOp = function (op, sep, arg) {
+    this.state().ops.push({
+        type: 'op',
+        value: op,
+        mod: this.resetModifiers(),
+        sep,
+        arg
+    });
+};
+
+export { AutoTypeParser };

app/scripts/auto-type/auto-type-runner.js

@@ -0,0 +1,537 @@
+import { AutoTypeEmitter } from 'auto-type/auto-type-emitter';
+import { AutoTypeObfuscator } from 'auto-type/auto-type-obfuscator';
+import { StringFormat } from 'util/formatting/string-format';
+import { Logger } from 'util/logger';
+
+const emitterLogger = new Logger('auto-type-emitter');
+
+const AutoTypeRunner = function (ops) {
+    this.ops = ops;
+    this.pendingResolvesCount = 0;
+    this.entry = null;
+    this.now = new Date();
+};
+
+AutoTypeRunner.PendingResolve = { pending: true };
+
+AutoTypeRunner.Keys = {
+    tab: 'tab',
+    enter: 'enter',
+    space: 'space',
+    up: 'up',
+    down: 'down',
+    left: 'left',
+    right: 'right',
+    home: 'home',
+    end: 'end',
+    pgup: 'pgup',
+    pgdn: 'pgdn',
+    insert: 'ins',
+    ins: 'ins',
+    delete: 'del',
+    del: 'del',
+    backspace: 'bs',
+    bs: 'bs',
+    bksp: 'bs',
+    esc: 'esc',
+    win: 'win',
+    lwin: 'win',
+    rwin: 'rwin',
+    f1: 'f1',
+    f2: 'f2',
+    f3: 'f3',
+    f4: 'f4',
+    f5: 'f5',
+    f6: 'f6',
+    f7: 'f7',
+    f8: 'f8',
+    f9: 'f9',
+    f10: 'f10',
+    f11: 'f11',
+    f12: 'f12',
+    f13: 'f13',
+    f14: 'f14',
+    f15: 'f15',
+    f16: 'f16',
+    add: 'add',
+    subtract: 'subtract',
+    multiply: 'multiply',
+    divide: 'divide',
+    numpad0: 'n0',
+    numpad1: 'n1',
+    numpad2: 'n2',
+    numpad3: 'n3',
+    numpad4: 'n4',
+    numpad5: 'n5',
+    numpad6: 'n6',
+    numpad7: 'n7',
+    numpad8: 'n8',
+    numpad9: 'n9'
+};
+
+AutoTypeRunner.Substitutions = {
+    title(runner, op) {
+        return runner.getEntryFieldKeys('Title', op);
+    },
+    username(runner, op) {
+        return runner.getEntryFieldKeys('UserName', op);
+    },
+    url(runner, op) {
+        return runner.getEntryFieldKeys('URL', op);
+    },
+    password(runner, op) {
+        return runner.getEntryFieldKeys('Password', op);
+    },
+    notes(runner, op) {
+        return runner.getEntryFieldKeys('Notes', op);
+    },
+    group(runner) {
+        return runner.getEntryGroupName();
+    },
+    totp(runner, op) {
+        return runner.getOtp(op);
+    },
+    s(runner, op) {
+        return runner.getEntryFieldKeys(op.arg, op);
+    },
+    'dt_simple'(runner) {
+        return runner.dt('simple');
+    },
+    'dt_year'(runner) {
+        return runner.dt('Y');
+    },
+    'dt_month'(runner) {
+        return runner.dt('M');
+    },
+    'dt_day'(runner) {
+        return runner.dt('D');
+    },
+    'dt_hour'(runner) {
+        return runner.dt('h');
+    },
+    'dt_minute'(runner) {
+        return runner.dt('m');
+    },
+    'dt_second'(runner) {
+        return runner.dt('s');
+    },
+    'dt_utc_simple'(runner) {
+        return runner.udt('simple');
+    },
+    'dt_utc_year'(runner) {
+        return runner.udt('Y');
+    },
+    'dt_utc_month'(runner) {
+        return runner.udt('M');
+    },
+    'dt_utc_day'(runner) {
+        return runner.udt('D');
+    },
+    'dt_utc_hour'(runner) {
+        return runner.udt('h');
+    },
+    'dt_utc_minute'(runner) {
+        return runner.udt('m');
+    },
+    'dt_utc_second'(runner) {
+        return runner.udt('s');
+    }
+};
+
+AutoTypeRunner.prototype.resolve = function (entry, context, callback) {
+    this.entry = entry;
+    this.context = context;
+    try {
+        this.resolveOps(this.ops);
+        if (!this.pendingResolvesCount) {
+            callback();
+        } else {
+            this.resolveCallback = callback;
+        }
+    } catch (e) {
+        return callback(e);
+    }
+};
+
+AutoTypeRunner.prototype.resolveOps = function (ops) {
+    for (let i = 0, len = ops.length; i < len; i++) {
+        const op = ops[i];
+        if (op.type === 'group') {
+            this.resolveOps(op.value);
+        } else {
+            this.resolveOp(op);
+        }
+    }
+};
+
+AutoTypeRunner.prototype.resolveOp = function (op) {
+    if (op.value.length === 1 && !op.sep) {
+        // {x}
+        op.type = 'text';
+        return;
+    }
+    if (op.value.length === 1 && op.sep === ' ') {
+        // {x 3}
+        op.type = 'text';
+        const ch = op.value;
+        let text = ch;
+        const len = +op.arg;
+        while (text.length < len) {
+            text += ch;
+        }
+        op.value = text;
+        return;
+    }
+    const lowerValue = op.value.toLowerCase();
+    const key = AutoTypeRunner.Keys[lowerValue];
+    if (key) {
+        if (op.sep === ' ' && +op.arg > 0) {
+            // {TAB 3}
+            op.type = 'group';
+            op.value = [];
+            const count = +op.arg;
+            for (let i = 0; i < count; i++) {
+                op.value.push({ type: 'key', value: key });
+            }
+        } else {
+            // {TAB}
+            op.type = 'key';
+            op.value = key;
+        }
+        return;
+    }
+    if (this.context?.resolved?.[lowerValue]) {
+        op.type = 'text';
+        op.value = this.context.resolved[lowerValue];
+        return;
+    }
+    const substitution = AutoTypeRunner.Substitutions[lowerValue];
+    if (substitution) {
+        // {title}
+        op.type = 'text';
+        op.value = substitution(this, op);
+        if (op.value === AutoTypeRunner.PendingResolve) {
+            this.pendingResolvesCount++;
+        }
+        return;
+    }
+    if (!this.tryParseCommand(op)) {
+        throw 'Bad op: ' + op.value;
+    }
+};
+
+AutoTypeRunner.prototype.tryParseCommand = function (op) {
+    switch (op.value.toLowerCase()) {
+        case 'clearfield':
+            // {CLEARFIELD}
+            op.type = 'group';
+            op.value = [
+                { type: 'key', value: 'end' },
+                { type: 'key', value: 'home', mod: { '+': true } },
+                { type: 'key', value: 'bs' }
+            ];
+            return true;
+        case 'vkey':
+            // {VKEY 10} {VKEY 0x1F}
+            op.type = 'key';
+            op.value = parseInt(op.arg);
+            if (isNaN(op.value) || op.value < 0) {
+                throw 'Bad vkey: ' + op.arg;
+            }
+            return true;
+        case 'delay':
+            // {DELAY 5} {DELAY=5}
+            op.type = 'cmd';
+            op.value = op.sep === '=' ? 'setDelay' : 'wait';
+            if (!op.arg) {
+                throw 'Delay requires milliseconds count';
+            }
+            if (isNaN(+op.arg)) {
+                throw 'Bad delay: ' + op.arg;
+            }
+            if (op.arg < 0) {
+                throw 'Delay requires positive interval';
+            }
+            op.arg = +op.arg;
+            return true;
+        default:
+            return false;
+    }
+};
+
+AutoTypeRunner.prototype.getEntryFieldKeys = function (field, op) {
+    if (!field || !this.entry) {
+        return '';
+    }
+    const value = this.entry.getFieldValue(field);
+    if (!value) {
+        return '';
+    }
+    if (value.isProtected) {
+        op.type = 'group';
+        const ops = [];
+        value.forEachChar((ch) => {
+            if (ch === 10 || ch === 13) {
+                ops.push({ type: 'key', value: 'enter' });
+            } else {
+                ops.push({ type: 'text', value: String.fromCharCode(ch) });
+            }
+        });
+        return ops;
+    } else {
+        const parts = value.split(/[\r\n]/g);
+        if (parts.length === 1) {
+            return value;
+        }
+        op.type = 'group';
+        const partsOps = [];
+        parts.forEach((part) => {
+            if (partsOps.length) {
+                partsOps.push({ type: 'key', value: 'enter' });
+            }
+            if (part) {
+                partsOps.push({ type: 'text', value: part });
+            }
+        });
+        return partsOps;
+    }
+};
+
+AutoTypeRunner.prototype.getEntryGroupName = function () {
+    return this.entry && this.entry.group.title;
+};
+
+AutoTypeRunner.prototype.dt = function (part) {
+    switch (part) {
+        case 'simple':
+            return (
+                this.dt('Y') +
+                this.dt('M') +
+                this.dt('D') +
+                this.dt('h') +
+                this.dt('m') +
+                this.dt('s')
+            );
+        case 'Y':
+            return this.now.getFullYear().toString();
+        case 'M':
+            return StringFormat.pad(this.now.getMonth() + 1, 2);
+        case 'D':
+            return StringFormat.pad(this.now.getDate(), 2);
+        case 'h':
+            return StringFormat.pad(this.now.getHours(), 2);
+        case 'm':
+            return StringFormat.pad(this.now.getMinutes(), 2);
+        case 's':
+            return StringFormat.pad(this.now.getSeconds(), 2);
+        default:
+            throw 'Bad part: ' + part;
+    }
+};
+
+AutoTypeRunner.prototype.udt = function (part) {
+    switch (part) {
+        case 'simple':
+            return (
+                this.udt('Y') +
+                this.udt('M') +
+                this.udt('D') +
+                this.udt('h') +
+                this.udt('m') +
+                this.udt('s')
+            );
+        case 'Y':
+            return this.now.getUTCFullYear().toString();
+        case 'M':
+            return StringFormat.pad(this.now.getUTCMonth() + 1, 2);
+        case 'D':
+            return StringFormat.pad(this.now.getUTCDate(), 2);
+        case 'h':
+            return StringFormat.pad(this.now.getUTCHours(), 2);
+        case 'm':
+            return StringFormat.pad(this.now.getUTCMinutes(), 2);
+        case 's':
+            return StringFormat.pad(this.now.getUTCSeconds(), 2);
+        default:
+            throw 'Bad part: ' + part;
+    }
+};
+
+AutoTypeRunner.prototype.getOtp = function (op) {
+    if (!this.entry) {
+        return '';
+    }
+    this.entry.initOtpGenerator();
+    if (!this.entry.otpGenerator) {
+        return '';
+    }
+    this.entry.otpGenerator.next((err, otp) => {
+        this.pendingResolved(op, otp, err);
+    });
+    return AutoTypeRunner.PendingResolve;
+};
+
+AutoTypeRunner.prototype.pendingResolved = function (op, value, error) {
+    const wasPending = op.value === AutoTypeRunner.PendingResolve;
+    if (value) {
+        op.value = value;
+    }
+    if (!wasPending) {
+        return;
+    }
+    this.pendingResolvesCount--;
+    if ((this.pendingResolvesCount === 0 || error) && this.resolveCallback) {
+        this.resolveCallback(error);
+        this.resolveCallback = null;
+    }
+};
+
+AutoTypeRunner.prototype.obfuscate = function () {
+    this.obfuscateOps(this.ops);
+};
+
+AutoTypeRunner.prototype.obfuscateOps = function (ops) {
+    for (let i = 0, len = ops.length; i < len; i++) {
+        const op = ops[i];
+        if (op.mod) {
+            continue;
+        }
+        if (op.type === 'text') {
+            this.obfuscateOp(op);
+        } else if (op.type === 'group') {
+            const onlyText = op.value.every((grOp) => grOp.type === 'text' && !grOp.mod);
+            if (onlyText) {
+                this.obfuscateOp(op);
+            } else {
+                this.obfuscateOps(op.value);
+            }
+        }
+    }
+};
+
+AutoTypeRunner.prototype.obfuscateOp = function (op) {
+    let letters = [];
+    if (op.type === 'text') {
+        if (!op.value || op.value.length <= 1) {
+            return;
+        }
+        letters = op.value.split('');
+    } else {
+        op.value.forEach((grOp) => letters.push(...grOp.value.split('')));
+    }
+    if (letters.length <= 1) {
+        return;
+    }
+    const obfuscator = new AutoTypeObfuscator(letters);
+    op.value = obfuscator.obfuscate();
+    op.type = 'group';
+};
+
+AutoTypeRunner.prototype.run = function (callback, windowId) {
+    this.emitter = new AutoTypeEmitter(this.emitNext.bind(this), windowId);
+    this.emitterState = {
+        callback,
+        stack: [],
+        ops: this.ops,
+        opIx: 0,
+        mod: {},
+        activeMod: {},
+        finished: null
+    };
+    this.emitter.begin();
+};
+
+AutoTypeRunner.prototype.emitNext = function (err) {
+    if (err) {
+        this.emitterState.finished = true;
+        this.emitterState.callback(err);
+        return;
+    }
+    if (this.emitterState.finished) {
+        this.emitterState.callback();
+        return;
+    }
+    this.resetEmitterMod(this.emitterState.mod);
+    if (this.emitterState.opIx >= this.emitterState.ops.length) {
+        const state = this.emitterState.stack.pop();
+        if (state) {
+            Object.assign(this.emitterState, { ops: state.ops, opIx: state.opIx, mod: state.mod });
+            this.emitNext();
+        } else {
+            this.resetEmitterMod({});
+            this.emitterState.finished = true;
+            emitterLogger.debug('waitComplete');
+            this.emitter.waitComplete();
+        }
+        return;
+    }
+    const op = this.emitterState.ops[this.emitterState.opIx];
+    if (op.type === 'group') {
+        if (op.mod) {
+            this.setEmitterMod(op.mod);
+        }
+        this.emitterState.stack.push({
+            ops: this.emitterState.ops,
+            opIx: this.emitterState.opIx + 1,
+            mod: { ...this.emitterState.mod }
+        });
+        Object.assign(this.emitterState, {
+            ops: op.value,
+            opIx: 0,
+            mod: { ...this.emitterState.activeMod }
+        });
+        this.emitNext();
+        return;
+    }
+    this.emitterState.opIx++;
+    if (op.mod) {
+        this.setEmitterMod(op.mod);
+    }
+    switch (op.type) {
+        case 'text':
+            emitterLogger.debug('text', op.value);
+            if (op.value) {
+                this.emitter.text(op.value);
+            } else {
+                this.emitNext();
+            }
+            break;
+        case 'key':
+            emitterLogger.debug('key', op.value);
+            this.emitter.key(op.value);
+            break;
+        case 'cmd': {
+            const method = this.emitter[op.value];
+            if (!method) {
+                throw 'Bad cmd: ' + op.value;
+            }
+            emitterLogger.debug(op.value, op.arg);
+            method.call(this.emitter, op.arg);
+            break;
+        }
+        default:
+            throw 'Bad op: ' + op.type;
+    }
+};
+
+AutoTypeRunner.prototype.setEmitterMod = function (addedMod) {
+    Object.keys(addedMod).forEach(function (mod) {
+        if (addedMod[mod] && !this.emitterState.activeMod[mod]) {
+            emitterLogger.debug('mod', mod, true);
+            this.emitter.setMod(mod, true);
+            this.emitterState.activeMod[mod] = true;
+        }
+    }, this);
+};
+
+AutoTypeRunner.prototype.resetEmitterMod = function (targetState) {
+    Object.keys(this.emitterState.activeMod).forEach(function (mod) {
+        if (this.emitterState.activeMod[mod] && !targetState[mod]) {
+            emitterLogger.debug('mod', mod, false);
+            this.emitter.setMod(mod, false);
+            delete this.emitterState.activeMod[mod];
+        }
+    }, this);
+};
+
+export { AutoTypeRunner };

app/scripts/auto-type/index.js

@@ -0,0 +1,313 @@
+import { Events } from 'framework/events';
+import { AutoTypeHelper } from 'auto-type/auto-type-helper';
+import { AutoTypeParser } from 'auto-type/auto-type-parser';
+import { SelectEntryFilter } from 'comp/app/select-entry-filter';
+import { Launcher } from 'comp/launcher';
+import { Features } from 'util/features';
+import { Alerts } from 'comp/ui/alerts';
+import { Timeouts } from 'const/timeouts';
+import { AppSettingsModel } from 'models/app-settings-model';
+import { AppModel } from 'models/app-model';
+import { Locale } from 'util/locale';
+import { Logger } from 'util/logger';
+import { Links } from 'const/links';
+import { SelectEntryView } from 'views/select/select-entry-view';
+
+const logger = new Logger('auto-type');
+const clearTextAutoTypeLog = !!localStorage.debugAutoType;
+
+const AutoType = {
+    enabled: !!(Launcher && Launcher.autoTypeSupported),
+    supportsEventsWithWindowId: !!(Launcher && Launcher.platform() === 'linux'),
+    selectEntryView: false,
+    running: false,
+
+    init() {
+        if (!this.enabled) {
+            return;
+        }
+        Events.on('auto-type', (e) => this.handleEvent(e));
+    },
+
+    handleEvent(e) {
+        const entry = (e && e.entry) || null;
+        const sequence = (e && e.sequence) || null;
+        const context = (e && e.context) || null;
+        logger.info('Auto type event', entry);
+        if (this.running) {
+            logger.info('Already running, skipping event');
+            return;
+        }
+        if (entry) {
+            this.hideWindow(() => {
+                this.runAndHandleResult({ entry, sequence, context });
+            });
+        } else {
+            if (this.selectEntryView) {
+                return;
+            }
+            if (Launcher.isAppFocused()) {
+                return Alerts.error({
+                    header: Locale.autoTypeError,
+                    body: Locale.autoTypeErrorGlobal,
+                    skipIfAlertDisplayed: true
+                });
+            }
+            this.selectEntryAndRun();
+        }
+    },
+
+    runAndHandleResult(result, windowId) {
+        this.run(result, windowId, (err) => {
+            if (err) {
+                let body = Locale.autoTypeErrorGeneric.replace('{}', err.message || err.toString());
+                let link;
+                if (err.keyPressFailed && Features.isMac) {
+                    body = Locale.autoTypeErrorAccessibilityMacOS;
+                    link = Links.AutoTypeMacOS;
+                }
+                Alerts.error({
+                    header: Locale.autoTypeError,
+                    body,
+                    link
+                });
+            }
+        });
+
+        if (AppSettingsModel.lockOnAutoType) {
+            Events.emit('lock-workspace');
+        }
+    },
+
+    run(result, windowId, callback) {
+        this.running = true;
+        const sequence = result.sequence || result.entry.getEffectiveAutoTypeSeq();
+        const context = result.context;
+        logger.info('Start', sequence);
+        const ts = logger.ts();
+        try {
+            const parser = new AutoTypeParser(sequence);
+            const runner = parser.parse();
+            logger.info('Parsed', this.printOps(runner.ops));
+            runner.resolve(result.entry, context, (err) => {
+                if (err) {
+                    this.running = false;
+                    logger.error('Resolve error', err);
+                    return callback && callback(err);
+                }
+                logger.info('Resolved', this.printOps(runner.ops));
+                if (result.entry.autoTypeObfuscation) {
+                    try {
+                        runner.obfuscate();
+                    } catch (e) {
+                        this.running = false;
+                        logger.error('Obfuscate error', e);
+                        return callback && callback(e);
+                    }
+                    logger.info('Obfuscated');
+                }
+                runner.run((err) => {
+                    this.running = false;
+                    if (err) {
+                        logger.error('Run error', err);
+                        return callback && callback(err);
+                    }
+                    logger.info('Complete', logger.ts(ts));
+                    return callback && callback();
+                }, windowId);
+            });
+        } catch (ex) {
+            this.running = false;
+            logger.error('Parse error', ex);
+            return callback && callback(ex);
+        }
+    },
+
+    validate(entry, sequence, callback) {
+        try {
+            const parser = new AutoTypeParser(sequence);
+            const runner = parser.parse();
+            runner.resolve(entry, null, callback);
+        } catch (ex) {
+            return callback(ex);
+        }
+    },
+
+    printOps(ops) {
+        return '[' + ops.map(this.printOp, this).join(',') + ']';
+    },
+
+    printOp(op) {
+        const mod = op.mod ? Object.keys(op.mod).join('') : '';
+        if (op.type === 'group') {
+            return mod + this.printOps(op.value);
+        }
+        if (op.type === 'text') {
+            let value = op.value;
+            if (!clearTextAutoTypeLog) {
+                value = value.replace(/./g, '*');
+            }
+            return mod + value;
+        }
+        return mod + op.type + ':' + op.value;
+    },
+
+    hideWindow(callback) {
+        logger.info('Hide window');
+        if (Launcher.isAppFocused()) {
+            Launcher.hideApp();
+            setTimeout(callback, Timeouts.AutoTypeAfterHide);
+        } else {
+            callback();
+        }
+    },
+
+    getActiveWindowInfo(callback) {
+        logger.info('Getting window info');
+        const helper = new AutoTypeHelper();
+        return helper.getActiveWindowInfo((err, windowInfo) => {
+            if (err) {
+                logger.error('Error getting window info', err);
+            } else {
+                if (!windowInfo.url) {
+                    // try to find a URL in the title
+                    const urlMatcher =
+                        /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\\+~#=]{2,256}\.[a-z]{2,4}\b([-a-zA-Z0-9@:%_\\+.~#?&\/=]*)/;
+                    const urlMatches = urlMatcher.exec(windowInfo.title);
+                    windowInfo.url = urlMatches && urlMatches.length > 0 ? urlMatches[0] : null;
+                }
+                logger.info('Window info', windowInfo.id, windowInfo.title, windowInfo.url);
+            }
+            return callback(err, windowInfo);
+        });
+    },
+
+    activeWindowMatches(windowInfo, callback) {
+        if (!windowInfo || !windowInfo.id) {
+            logger.info('Skipped active window check because window id is unknown');
+            return callback(true);
+        }
+        this.getActiveWindowInfo((err, activeWindowInfo) => {
+            if (!activeWindowInfo) {
+                logger.info('Error during active window check, something is wrong', err);
+                return callback(false);
+            }
+            if (activeWindowInfo.id !== windowInfo.id && !this.supportsEventsWithWindowId) {
+                logger.info(
+                    `Active window doesn't match: ID is different. ` +
+                        `Expected ${windowInfo.id}, got ${activeWindowInfo.id}`
+                );
+                return callback(false, activeWindowInfo);
+            }
+            if (activeWindowInfo.url !== windowInfo.url && !this.supportsEventsWithWindowId) {
+                logger.info(
+                    `Active window doesn't match: url is different. ` +
+                        `Expected "${windowInfo.url}", got "${activeWindowInfo.url}"`
+                );
+                return callback(false, activeWindowInfo);
+            }
+            logger.info('Active window matches');
+            callback(true, activeWindowInfo);
+        });
+    },
+
+    selectEntryAndRun() {
+        this.getActiveWindowInfo(async (e, windowInfo) => {
+            const filter = new SelectEntryFilter(
+                windowInfo,
+                AppModel.instance,
+                AppModel.instance.files,
+                {
+                    autoType: true
+                }
+            );
+            const evt = { filter, windowInfo };
+            if (!AppModel.instance.files.hasOpenFiles()) {
+                logger.info('auto-type event delayed');
+                this.focusMainWindow();
+                try {
+                    await AppModel.instance.unlockAnyFile('autoTypeUnlockMessage');
+                } catch {
+                    logger.info('auto-type event canceled');
+                    return;
+                }
+                if (this.selectEntryView) {
+                    this.selectEntryView.show();
+                }
+            }
+            logger.info('processing auto-type event');
+            this.processEventWithFilter(evt);
+        });
+    },
+
+    focusMainWindow() {
+        if (!Launcher.isAppFocused()) {
+            setTimeout(() => Launcher.showMainWindow(), Timeouts.RedrawInactiveWindow);
+        }
+    },
+
+    processEventWithFilter(evt) {
+        let entries = evt.filter.getEntries();
+        if (entries.length === 1 && AppSettingsModel.directAutotype) {
+            this.hideWindow(() => {
+                this.runAndHandleResult({ entry: entries[0] }, evt.windowInfo.id);
+            });
+            return;
+        }
+        this.focusMainWindow();
+
+        if (entries.length === 0) {
+            if (evt.filter.useUrl) {
+                evt.filter.useUrl = false;
+                if (evt.filter.title && AppSettingsModel.autoTypeTitleFilterEnabled) {
+                    evt.filter.useTitle = true;
+                }
+            }
+            entries = evt.filter.getEntries();
+            if (entries.length === 0 && evt.filter.useTitle) {
+                evt.filter.useTitle = false;
+            }
+        }
+
+        const humanReadableTarget = evt.filter.title || evt.filter.url;
+        const topMessage = humanReadableTarget
+            ? Locale.autoTypeMsgMatchedByWindow.replace('{}', humanReadableTarget)
+            : Locale.autoTypeMsgNoWindow;
+
+        this.selectEntryView = new SelectEntryView({
+            isAutoType: true,
+            itemOptions: true,
+            filter: evt.filter,
+            topMessage
+        });
+        this.selectEntryView.on('result', (result) => {
+            logger.info('Entry selected', result);
+            this.selectEntryView.off('result');
+            this.selectEntryView.remove();
+            this.selectEntryView = null;
+            this.hideWindow(() => {
+                if (result?.entry) {
+                    this.activeWindowMatches(evt.windowInfo, (matches, activeWindowInfo) => {
+                        if (matches) {
+                            this.runAndHandleResult(result, evt.windowInfo.id);
+                        }
+                    });
+                }
+            });
+        });
+        this.selectEntryView.render();
+        this.selectEntryView.on('show-open-files', async () => {
+            this.selectEntryView.hide();
+            try {
+                await AppModel.instance.unlockAnyFile('autoTypeUnlockMessage');
+            } catch {
+                this.selectEntryView.emit('result', undefined);
+                return;
+            }
+            this.selectEntryView.show();
+            this.selectEntryView.render();
+        });
+    }
+};
+
+export { AutoType };

app/scripts/bootstrap.ts

@@ -0,0 +1,188 @@
+import 'util/kdbxweb/protected-value';
+import { h, render } from 'preact';
+import { App } from 'ui/app';
+import { Events } from 'util/events';
+import { StartProfiler } from 'util/logging/start-profiler';
+import { AppRightsChecker } from 'comp/launcher/app-rights-checker';
+import { ExportApi } from 'comp/app/export-api';
+import { SingleInstanceChecker } from 'comp/browser/single-instance-checker';
+import { FocusDetector } from 'comp/browser/focus-detector';
+import { IdleTracker } from 'comp/browser/idle-tracker';
+import { ThemeWatcher } from 'comp/browser/theme-watcher';
+import { KeyHandler } from 'comp/browser/key-handler';
+import { PopupNotifier } from 'comp/browser/popup-notifier';
+import { SettingsManager } from 'comp/settings/settings-manager';
+import { Alerts } from 'comp/ui/alerts';
+import { AppSettings } from 'models/app-settings';
+import { RuntimeData } from 'models/runtime-data';
+import { Features } from 'util/features';
+import { KdbxwebInit } from 'comp/kdbxweb/kdbxweb-init';
+import { Locale } from 'util/locale';
+import { Logger } from 'util/logger';
+import { FeatureTester } from 'util/browser/feature-tester';
+import { UsbListener } from 'comp/devices/usb-listener';
+import { noop } from 'util/fn';
+import { ConfigLoader } from 'comp/settings/config-loader';
+import { WindowClass } from 'comp/browser/window-class';
+import { FileManager } from 'models/file-manager';
+import { Updater } from './comp/app/updater';
+import { Timeouts } from 'const/timeouts';
+import { PluginManager } from 'plugins/plugin-manager';
+import { Workspace } from 'models/workspace';
+
+declare global {
+    interface Window {
+        kw: typeof ExportApi;
+    }
+}
+
+StartProfiler.milestone('loading modules');
+
+document.addEventListener('DOMContentLoaded', () => {
+    bootstrap().catch(noop);
+});
+
+export async function bootstrap(): Promise<void> {
+    StartProfiler.milestone('document ready');
+
+    const logger = new Logger('bootstrap');
+
+    try {
+        await loadConfigs();
+        await initModules();
+        await loadRemoteConfig();
+        await ensureCanRun();
+        addWindowClasses();
+        initUsbListener();
+        await showApp();
+        postInit();
+    } catch (e) {
+        logger.error('Error starting app', e);
+    }
+
+    async function ensureCanRun() {
+        if (Features.isFrame && !AppSettings.allowIframes) {
+            return Promise.reject(
+                'Running in iframe is not allowed (this can be changed in the app config).'
+            );
+        }
+
+        try {
+            await FeatureTester.test();
+            StartProfiler.milestone('checking features');
+        } catch (e) {
+            Alerts.error({
+                header: Locale.appSettingsError,
+                body: Locale.appNotSupportedError,
+                pre: String(e),
+                buttons: [],
+                esc: undefined,
+                enter: undefined,
+                click: undefined
+            });
+            logger.error('Feature test failed', e);
+            throw new Error(`Feature test failed`);
+        }
+    }
+
+    function loadConfigs() {
+        return Promise.all([AppSettings.init(), RuntimeData.init(), FileManager.init()]).then(
+            () => {
+                StartProfiler.milestone('loading configs');
+            }
+        );
+    }
+
+    async function initModules() {
+        KeyHandler.init();
+        PopupNotifier.init();
+        KdbxwebInit.init();
+        FocusDetector.init();
+        // AutoType.init(); // TODO
+        ThemeWatcher.init();
+        SettingsManager.init();
+        await PluginManager.init();
+        window.kw = ExportApi;
+
+        StartProfiler.milestone('initializing modules');
+    }
+
+    async function loadRemoteConfig() {
+        SettingsManager.setBySettings();
+
+        const loaded = await ConfigLoader.loadConfig();
+        if (loaded) {
+            SettingsManager.setBySettings();
+        }
+
+        StartProfiler.milestone('loading remote config');
+    }
+
+    function addWindowClasses() {
+        WindowClass.init();
+        StartProfiler.milestone('adding window classes');
+    }
+
+    function initUsbListener() {
+        UsbListener.init();
+        StartProfiler.milestone('starting usb');
+    }
+
+    function showApp() {
+        return Promise.resolve().then(() => {
+            const skipHttpsWarning = AppSettings.skipHttpsWarning;
+            const protocolIsInsecure = ['https:', 'file:', 'app:'].indexOf(location.protocol) < 0;
+            const hostIsInsecure = location.hostname !== 'localhost';
+            if (protocolIsInsecure && hostIsInsecure && !skipHttpsWarning) {
+                return new Promise<void>((resolve) => {
+                    Alerts.error({
+                        header: Locale.appSecWarn,
+                        icon: 'user-secret',
+                        esc: undefined,
+                        enter: undefined,
+                        click: undefined,
+                        body: Locale.appSecWarnBody1 + '\n\n' + Locale.appSecWarnBody2,
+                        buttons: [{ result: '', title: Locale.appSecWarnBtn, error: true }],
+                        complete: () => {
+                            resolve(showView());
+                        }
+                    });
+                });
+            } else {
+                return showView().then(
+                    () => new Promise<void>((resolve) => requestAnimationFrame(() => resolve()))
+                );
+            }
+        });
+    }
+
+    function postInit() {
+        Updater.init();
+        SingleInstanceChecker.init();
+        AppRightsChecker.init().catch(noop);
+        IdleTracker.init();
+        // BrowserExtensionConnector.init(appModel); // TODO
+
+        setTimeout(() => {
+            PluginManager.runAutoUpdate().catch(noop);
+        }, Timeouts.PluginsAutoUpdateAfterStart);
+    }
+
+    function showView() {
+        Workspace.showOpen();
+
+        const root = document.querySelector('.app');
+        if (root) {
+            const app = h(App, null);
+            render(app, document.body, root);
+        }
+        StartProfiler.milestone('first view rendering');
+
+        Events.emit('app-ready');
+        StartProfiler.milestone('app ready event');
+
+        StartProfiler.report();
+
+        return Promise.resolve();
+    }
+}

app/scripts/collections/entry-collection.js

@@ -1,47 +0,0 @@
-'use strict';
-
-var Backbone = require('backbone'),
-    EntryModel = require('../models/entry-model'),
-    Comparators = require('../util/comparators');
-
-var EntryCollection = Backbone.Collection.extend({
-    model: EntryModel,
-
-    comparator: function() {},
-
-    comparators: {
-        'title': Comparators.stringComparator('title', true),
-        '-title': Comparators.stringComparator('title', false),
-        'website': Comparators.stringComparator('url', true),
-        '-website': Comparators.stringComparator('url', false),
-        'user': Comparators.stringComparator('user', true),
-        '-user': Comparators.stringComparator('user', false),
-        'created': Comparators.dateComparator('created', true),
-        '-created': Comparators.dateComparator('created', false),
-        'updated': Comparators.dateComparator('updated', true),
-        '-updated': Comparators.dateComparator('updated', false),
-        '-attachments': function(x, y) { return this.attachmentSortVal(x).localeCompare(this.attachmentSortVal(y)); }
-    },
-
-    defaultComparator: 'title',
-
-    initialize: function() {
-        this.comparator = this.comparators[this.defaultComparator];
-    },
-
-    sortEntries: function(comparator) {
-        this.comparator = this.comparators[comparator] || this.comparators[this.defaultComparator];
-        this.sort();
-    },
-
-    attachmentSortVal: function(entry) {
-        var att = entry.attachments;
-        var str = att.length ? String.fromCharCode(64 + att.length) : 'Z';
-        if (att[0]) {
-            str += att[0].title;
-        }
-        return str;
-    }
-});
-
-module.exports = EntryCollection;

app/scripts/collections/file-collection.js

@@ -1,30 +0,0 @@
-'use strict';
-
-var Backbone = require('backbone'),
-    FileModel = require('../models/file-model');
-
-var FileCollection = Backbone.Collection.extend({
-    model: FileModel,
-
-    hasOpenFiles: function() {
-        return this.some(function(file) { return file.get('open'); });
-    },
-
-    hasUnsavedFiles: function() {
-        return this.some(function(file) { return file.get('modified'); });
-    },
-
-    hasDirtyFiles: function() {
-        return this.some(function(file) { return file.get('dirty'); });
-    },
-
-    getByName: function(name) {
-        return this.find(function(file) { return file.get('name').toLowerCase() === name.toLowerCase(); });
-    },
-
-    getById: function(id) {
-        return this.find(function(file) { return file.get('id') === id; });
-    }
-});
-
-module.exports = FileCollection;

app/scripts/collections/file-info-collection.js

@@ -1,47 +0,0 @@
-'use strict';
-
-var Backbone = require('backbone'),
-    FileInfoModel = require('../models/file-info-model'),
-    SettingsStore = require('../comp/settings-store');
-
-var FileInfoCollection = Backbone.Collection.extend({
-    model: FileInfoModel,
-
-    initialize: function () {
-    },
-
-    load: function () {
-        var data = SettingsStore.load('file-info');
-        if (data) {
-            this.reset(data, {silent: true});
-        }
-    },
-
-    save: function () {
-        SettingsStore.save('file-info', this.toJSON());
-    },
-
-    getLast: function () {
-        return this.first();
-    },
-
-    getMatch: function (storage, name, path) {
-        return this.find(function(fi) {
-            return (fi.get('storage') || '') === (storage || '') &&
-                (fi.get('name') || '') === (name || '') &&
-                (fi.get('path') || '') === (path || '');
-        });
-    },
-
-    getByName: function(name) {
-        return this.find(function(file) { return file.get('name').toLowerCase() === name.toLowerCase(); });
-    }
-});
-
-FileInfoCollection.load = function() {
-    var coll = new FileInfoCollection();
-    coll.load();
-    return coll;
-};
-
-module.exports = FileInfoCollection;

app/scripts/collections/group-collection.js

@@ -1,10 +0,0 @@
-'use strict';
-
-var Backbone = require('backbone'),
-    GroupModel = require('../models/group-model');
-
-var GroupCollection = Backbone.Collection.extend({
-    model: GroupModel
-});
-
-module.exports = GroupCollection;

app/scripts/collections/menu/menu-item-collection.js

@@ -1,10 +0,0 @@
-'use strict';
-
-var Backbone = require('backbone'),
-    MenuItemModel = require('../../models/menu/menu-item-model');
-
-var MenuItemCollection = Backbone.Collection.extend({
-    model: MenuItemModel
-});
-
-module.exports = MenuItemCollection;

app/scripts/collections/menu/menu-option-collection.js

@@ -1,10 +0,0 @@
-'use strict';
-
-var Backbone = require('backbone'),
-    MenuOptionModel = require('../../models/menu/menu-option-model');
-
-var MenuOptionCollection = Backbone.Collection.extend({
-    model: MenuOptionModel
-});
-
-module.exports = MenuOptionCollection;

app/scripts/collections/menu/menu-section-collection.js

@@ -1,10 +0,0 @@
-'use strict';
-
-var Backbone = require('backbone'),
-    MenuSectionModel = require('../../models/menu/menu-section-model');
-
-var MenuSectionCollection = Backbone.Collection.extend({
-    model: MenuSectionModel
-});
-
-module.exports = MenuSectionCollection;

app/scripts/comp/alerts.js

@@ -1,82 +0,0 @@
-'use strict';
-
-var ModalView = require('../views/modal-view'),
-    Locale = require('../util/locale');
-
-var Alerts = {
-    alertDisplayed: false,
-
-    buttons: {
-        ok: {result: 'yes', title: Locale.alertOk},
-        yes: {result: 'yes', title: Locale.alertYes},
-        no: {result: '', title: Locale.alertNo}
-    },
-
-    alert: function(config) {
-        Alerts.alertDisplayed = true;
-        var view = new ModalView({ model: config });
-        view.render();
-        view.on('result', function(res, check) {
-            Alerts.alertDisplayed = false;
-            if (res && config.success) {
-                config.success(res, check);
-            }
-            if (!res && config.cancel) {
-                config.cancel();
-            }
-            if (config.complete) {
-                config.complete(res, check);
-            }
-        });
-    },
-
-    notImplemented: function() {
-        this.alert({
-            header: Locale.notImplemented,
-            body: '',
-            icon: 'exclamation-triangle',
-            buttons: [this.buttons.ok],
-            esc: '',
-            click: '',
-            enter: ''
-        });
-    },
-
-    info: function(config) {
-        this.alert(_.extend({
-            header: '',
-            body: '',
-            icon: 'info',
-            buttons: [this.buttons.ok],
-            esc: '',
-            click: '',
-            enter: ''
-        }, config));
-    },
-
-    error: function(config) {
-        this.alert(_.extend({
-            header: '',
-            body: '',
-            icon: 'exclamation-circle',
-            buttons: [this.buttons.ok],
-            esc: '',
-            click: '',
-            enter: ''
-        }, config));
-    },
-
-    yesno: function(config) {
-        this.alert(_.extend({
-            header: '',
-            body: '',
-            icon: 'question',
-            buttons: [this.buttons.yes, this.buttons.no],
-            esc: '',
-            click: '',
-            enter: 'yes'
-        }, config));
-    }
-};
-
-module.exports = Alerts;

app/scripts/comp/app/drag-drop-info.ts

@@ -0,0 +1,5 @@
+const DragDropInfo = {
+    dragObject: null as unknown
+};
+
+export { DragDropInfo };

app/scripts/comp/app/export-api.ts

@@ -0,0 +1,29 @@
+import { AppSettingsFieldName, AppSettings } from 'models/app-settings';
+import { RuntimeData } from 'models/runtime-data';
+
+const ExportApi = {
+    settings: {
+        get(key?: AppSettingsFieldName): unknown {
+            return key ? AppSettings[key] : { ...AppSettings };
+        },
+        set(key: AppSettingsFieldName, value: unknown): boolean {
+            return AppSettings.set(key, value);
+        },
+        del(key: AppSettingsFieldName): void {
+            AppSettings.delete(key);
+        }
+    },
+    runtimeData: {
+        get(key?: string): unknown {
+            return key ? RuntimeData.get(key) : { ...RuntimeData };
+        },
+        set(key: string, value: unknown): boolean {
+            return RuntimeData.set(key, value);
+        },
+        del(key: string): void {
+            RuntimeData.delete(key);
+        }
+    }
+};
+
+export { ExportApi };

app/scripts/comp/app/file-controller.ts

@@ -0,0 +1,689 @@
+import * as kdbxweb from 'kdbxweb';
+import { Logger } from 'util/logger';
+import { Storage } from 'storage';
+import { Locale } from 'util/locale';
+import { IdGenerator } from 'util/generators/id-generator';
+import { OpenParams } from 'models/ui/open-state';
+import { FileManager } from 'models/file-manager';
+import { File } from 'models/file';
+import { FileInfo } from 'models/file-info';
+import {
+    StorageFileData,
+    StorageFileNotFoundError,
+    StorageFileOptions,
+    StorageFileStat,
+    StorageRevConflictError,
+    StorageSaveResult
+} from 'storage/types';
+import { AppSettings } from 'models/app-settings';
+import { errorToString, noop } from 'util/fn';
+import { StorageBase } from 'storage/storage-base';
+import { UrlFormat } from 'util/formatting/url-format';
+import { DateFormat } from 'util/formatting/date-format';
+
+const MaxLoadLoops = 3;
+
+interface FileSyncOptions {
+    storage?: string;
+    path?: string;
+    opts: StorageFileOptions;
+}
+
+interface SyncContext {
+    logger: Logger;
+    file: File;
+    fileInfo: FileInfo;
+    storage: StorageBase;
+    path: string;
+    stat?: StorageFileStat;
+    opts?: StorageFileOptions;
+    retryCount: number;
+}
+
+class FileController {
+    async open(params: OpenParams): Promise<File> {
+        const logger = new Logger('open', params.name);
+        logger.info('File open request');
+
+        if (!params.name) {
+            throw new Error('Empty name');
+        }
+
+        const fileInfo = params.id
+            ? FileManager.getFileInfoById(params.id)
+            : FileManager.getFileInfo(params.name, params.storage, params.path);
+
+        if (!params.opts && fileInfo && fileInfo.opts) {
+            params.opts = fileInfo.opts;
+        }
+
+        if (fileInfo && fileInfo.modified) {
+            logger.info('Open file from cache because it is modified');
+            const file = await this.openFileFromCache(params, fileInfo, logger);
+            logger.info('Sync just opened modified file');
+            setTimeout(() => {
+                this.syncFile(file).catch(noop);
+            }, 0);
+            return file;
+        } else if (params.fileData) {
+            logger.info('Open file from supplied content');
+            if (params.storage === 'file' && params.path) {
+                const stat = await Storage.file.stat(params.path);
+                params.rev = stat.rev;
+                return this.openFileWithData(params, fileInfo, params.fileData, false);
+            } else {
+                return this.openFileWithData(params, fileInfo, params.fileData, true);
+            }
+        } else if (!params.storage && fileInfo) {
+            logger.info('Open file from cache as main storage');
+            return this.openFileFromCache(params, fileInfo, logger);
+        } else if (
+            fileInfo?.openDate &&
+            fileInfo.rev === params.rev &&
+            fileInfo.storage !== 'file' &&
+            !AppSettings.disableOfflineStorage
+        ) {
+            logger.info('Open file from cache because it is latest');
+            try {
+                return this.openFileFromCache(params, fileInfo, logger);
+            } catch (err) {
+                if (err instanceof kdbxweb.KdbxError) {
+                    // TODO: || err.ykError
+                    throw err;
+                }
+                logger.info('Error loading file from cache, trying to open from storage', err);
+                return this.openFileFromStorage(params, fileInfo, logger, true);
+            }
+        } else if (
+            !fileInfo ||
+            !fileInfo.openDate ||
+            params.storage === 'file' ||
+            AppSettings.disableOfflineStorage
+        ) {
+            return this.openFileFromStorage(params, fileInfo, logger, false);
+        } else {
+            logger.info('Open file from cache, will sync after load', params.storage);
+            let file: File;
+            try {
+                file = await this.openFileFromCache(params, fileInfo, logger);
+            } catch (err) {
+                if (err instanceof kdbxweb.KdbxError) {
+                    // TODO: || err.ykError
+                    throw err;
+                }
+                logger.info('Error loading file from cache, trying to open from storage', err);
+                return this.openFileFromStorage(params, fileInfo, logger, true);
+            }
+
+            logger.info('Sync just opened file');
+            setTimeout(() => {
+                this.syncFile(file).catch(noop);
+            }, 0);
+            return file;
+        }
+    }
+
+    private async openFileFromCache(
+        params: OpenParams,
+        fileInfo: FileInfo,
+        logger: Logger
+    ): Promise<File> {
+        let data: ArrayBuffer;
+        try {
+            const res = await Storage.cache.load(fileInfo.id);
+            if (!res?.data) {
+                throw new Error(Locale.openFileNoCacheError);
+            }
+            data = res.data;
+            logger.info('Loaded from cache');
+        } catch (err) {
+            logger.info('Loaded error from cache', err);
+            throw err;
+        }
+        return this.openFileWithData(params, fileInfo, data, false);
+    }
+
+    private async openFileFromStorage(
+        params: OpenParams,
+        fileInfo: FileInfo | undefined,
+        logger: Logger,
+        noCache: boolean
+    ): Promise<File> {
+        if (!params.storage) {
+            throw new Error('Storage open error: empty storage');
+        }
+        if (!params.path) {
+            throw new Error('Storage open error: empty path');
+        }
+
+        logger.info('Open file from storage', params.storage);
+
+        const storage = Storage.get(params.storage ?? '');
+        if (!storage) {
+            logger.error('Storage not found', storage);
+            throw new Error(`Storage not found: ${storage ?? ''}`);
+        }
+        const cacheRev = (fileInfo && fileInfo.rev) || null;
+        if (cacheRev && storage.stat) {
+            logger.info('Stat file');
+            let stat: StorageFileStat;
+            try {
+                stat = await storage.stat(params.path, params.opts);
+            } catch (err) {
+                if (
+                    !noCache &&
+                    fileInfo &&
+                    storage.name !== 'file' &&
+                    !AppSettings.disableOfflineStorage
+                ) {
+                    logger.info('Open file from cache because of stat error', err);
+                    return this.openFileFromCache(params, fileInfo, logger);
+                } else {
+                    logger.info('Stat error', err);
+                    throw err;
+                }
+            }
+            if (
+                !noCache &&
+                fileInfo &&
+                storage.name !== 'file' &&
+                stat.rev === cacheRev &&
+                !AppSettings.disableOfflineStorage
+            ) {
+                logger.info('Open file from cache because it is latest');
+                return this.openFileFromCache(params, fileInfo, logger);
+            }
+            logger.info(`Open file from storage (${stat.rev ?? '(empty)'}, local ${cacheRev})`);
+        }
+
+        logger.info('Load from storage');
+        let res: StorageFileData;
+        try {
+            res = await storage.load(params.path, params.opts);
+        } catch (err) {
+            if (fileInfo && fileInfo.openDate && !AppSettings.disableOfflineStorage) {
+                logger.info('Open file from cache because of storage load error', err);
+                return this.openFileFromCache(params, fileInfo, logger);
+            } else {
+                logger.info('Storage load error', err);
+                throw err;
+            }
+        }
+
+        logger.info('Open file from content loaded from storage');
+        params.fileData = res.data;
+        params.rev = res.rev;
+
+        const needSaveToCache = storage.name !== 'file';
+        return this.openFileWithData(params, fileInfo, res.data, needSaveToCache);
+    }
+
+    private async openFileWithData(
+        params: OpenParams,
+        fileInfo: FileInfo | undefined,
+        data: ArrayBuffer,
+        updateCacheOnSuccess: boolean
+    ): Promise<File> {
+        if (!params.name) {
+            throw new Error('Open file without name');
+        }
+        if (!params.password) {
+            throw new Error('Open file without password');
+        }
+        const logger = new Logger('open', params.name);
+
+        let needLoadKeyFile = false;
+        if (!params.keyFileData && fileInfo && fileInfo.keyFileName) {
+            params.keyFileName = fileInfo.keyFileName;
+            if (AppSettings.rememberKeyFiles === 'data' && fileInfo.keyFileHash) {
+                params.keyFileData = File.createKeyFileWithHash(fileInfo.keyFileHash);
+            } else if (AppSettings.rememberKeyFiles === 'path' && fileInfo.keyFilePath) {
+                params.keyFilePath = fileInfo.keyFilePath;
+                if (Storage.file.enabled) {
+                    needLoadKeyFile = true;
+                }
+            }
+        } else if (params.keyFilePath && !params.keyFileData && !fileInfo) {
+            needLoadKeyFile = true;
+        }
+
+        if (needLoadKeyFile && params.keyFilePath) {
+            let data: ArrayBuffer;
+            try {
+                const res = await Storage.file.load(params.keyFilePath);
+                data = res.data;
+            } catch (err) {
+                logger.info('Storage load error', err);
+                throw err;
+            }
+            params.keyFileData = data;
+        }
+
+        const id = fileInfo ? fileInfo.id : IdGenerator.uuid();
+
+        if (FileManager.getFileById(id)) {
+            throw new Error('Duplicate file id');
+        }
+
+        const file = await File.open(id, params.name, params.password, data, params.keyFileData);
+        file.batchSet(() => {
+            file.storage = params.storage;
+            file.path = params.path;
+            file.keyFileName = params.keyFileName;
+            file.keyFilePath = params.keyFilePath;
+            file.backup = fileInfo?.backup;
+            file.chalResp = params.chalResp;
+            file.syncDate = fileInfo?.syncDate;
+            // if (params.encryptedPassword) { // TODO: touch id
+            //     file.encryptedPassword = fileInfo?.encryptedPassword;
+            //     file.encryptedPasswordDate = fileInfo?.encryptedPasswordDate || new Date();
+            // }
+        });
+
+        if (fileInfo?.modified) {
+            if (fileInfo.editState) {
+                logger.info('Loaded local edit state');
+                file.setLocalEditState(fileInfo.editState);
+            }
+            logger.info('Mark file as modified');
+            file.modified = true;
+        }
+        if (updateCacheOnSuccess && !AppSettings.disableOfflineStorage && params.fileData) {
+            logger.info('Save loaded file to cache');
+            await Storage.cache.save(file.id, params.fileData);
+        }
+
+        const rev = params.rev || (fileInfo && fileInfo.rev);
+        // this.setFileOpts(file, params.opts); // TODO: file opts
+
+        logger.info('Add last open file', file.id, file.name, file.storage, file.path, rev);
+        FileManager.addLastOpenFileInfo(file, rev);
+        FileManager.addFile(file);
+        // this.fileOpened(file, data, params); // TODO: fileOpened
+
+        return file;
+    }
+
+    async syncFile(file: File, options?: FileSyncOptions): Promise<void> {
+        if (file.demo) {
+            return;
+        }
+        const logger = new Logger('sync', file.name);
+
+        const storageName = options?.storage || file.storage;
+        const storage = storageName ? Storage.get(storageName) : undefined;
+        const opts = options?.opts || file.opts;
+        let path = options?.path || file.path;
+        if (storage?.getPathForName && (!path || storage.name !== file.storage)) {
+            path = storage.getPathForName(file.name);
+        }
+
+        const optionsForLogging = { ...options };
+        if (optionsForLogging.opts && optionsForLogging.opts.password) {
+            optionsForLogging.opts = { ...optionsForLogging.opts };
+            optionsForLogging.opts.password = '***';
+        }
+        logger.info('Sync started', storage, path, optionsForLogging);
+        const fileInfo = this.getOrCreateFileInfo(file, logger);
+
+        let syncError: unknown;
+        try {
+            if (file.syncing) {
+                throw new Error('Sync in progress');
+            }
+            file.setSyncProgress();
+            if (!storage) {
+                if (!file.modified && fileInfo.id === file.id) {
+                    logger.info('Local, not modified');
+                } else {
+                    logger.info('Local, save to cache');
+                    const data = await file.getData();
+                    try {
+                        await Storage.cache.save(fileInfo.id, data);
+                        logger.info('Saved to cache');
+                    } catch (err) {
+                        logger.info('Cache save error', err);
+                        throw err;
+                    }
+                    // this.scheduleBackupFile(file, data); // TODO: backups
+                }
+            } else {
+                if (!path) {
+                    throw new Error('Cannot sync file to storage but without path');
+                }
+                const ctx: SyncContext = {
+                    logger,
+                    file,
+                    fileInfo,
+                    storage,
+                    path,
+                    opts,
+                    retryCount: 0
+                };
+
+                logger.info('Stat file');
+                let stat: StorageFileStat | undefined;
+                try {
+                    stat = await storage.stat(path, opts);
+                    ctx.stat = stat;
+                } catch (err) {
+                    if (err instanceof StorageFileNotFoundError) {
+                        logger.info('File does not exist in storage, creating');
+                        await this.saveToCacheAndStorage(ctx);
+                    } else if (file.dirty) {
+                        if (AppSettings.disableOfflineStorage) {
+                            logger.info('Stat error, dirty, cache is disabled', err);
+                            throw err;
+                        }
+                        logger.info('Stat error, dirty, save to cache');
+                        const data = await file.getData();
+                        try {
+                            await Storage.cache.save(fileInfo.id, data);
+                            file.dirty = false;
+                            logger.info('Saved to cache, exit with error', err);
+                        } catch (e) {
+                            logger.error('Error saving to cache', e);
+                        }
+                        throw err;
+                    } else {
+                        logger.info('Stat error, not dirty', err);
+                        throw err;
+                    }
+                }
+
+                if (stat) {
+                    if (stat.rev === fileInfo.rev) {
+                        if (file.modified) {
+                            logger.info('Stat found same version, modified, saving');
+                            await this.saveToCacheAndStorage(ctx);
+                        } else {
+                            logger.info('Stat found same version, not modified');
+                        }
+                    } else {
+                        logger.info('Found new version, loading from storage');
+                        await this.loadFromStorageAndMerge(ctx);
+                    }
+                }
+            }
+
+            logger.info('Sync finished OK');
+        } catch (e) {
+            syncError = e;
+            logger.error('Sync finished with error', syncError);
+        }
+
+        file.setSyncComplete(path, storageName, syncError ? errorToString(syncError) : undefined);
+        fileInfo.batchSet(() => {
+            fileInfo.name = file.name;
+            fileInfo.storage = storageName;
+            fileInfo.path = path;
+            // fileInfo.opts = this.getStoreOpts(file); // TODO: storage opts
+            fileInfo.modified = file.dirty ? fileInfo.modified : file.modified;
+            fileInfo.editState = file.dirty ? fileInfo.editState : file.getLocalEditState();
+            fileInfo.syncDate = file.syncDate;
+            fileInfo.chalResp = file.chalResp;
+
+            if (AppSettings.rememberKeyFiles === 'data') {
+                fileInfo.keyFileName = file.keyFileName;
+                fileInfo.keyFileHash = file.getKeyFileHash();
+            }
+        });
+
+        if (!FileManager.getFileById(fileInfo.id)) {
+            FileManager.addFileInfo(fileInfo, true);
+        }
+
+        if (syncError) {
+            throw syncError;
+        }
+    }
+
+    private getOrCreateFileInfo(file: File, logger: Logger): FileInfo {
+        let fileInfo = FileManager.getFileInfoById(file.id);
+        if (!fileInfo) {
+            logger.info('Create new file info');
+            const dt = new Date();
+            fileInfo = new FileInfo({
+                id: file.id,
+                name: file.name,
+                storage: file.storage,
+                path: file.path,
+                // opts: this.getStoreOpts(file), // TODO: store opts
+                modified: file.modified,
+                syncDate: dt,
+                openDate: dt,
+                backup: file.backup
+            });
+        }
+        return fileInfo;
+    }
+
+    private async saveToStorage(ctx: SyncContext, data: ArrayBuffer) {
+        ctx.logger.info('Save data to storage');
+        const storageRev = ctx.fileInfo.storage === ctx.storage.name ? ctx.fileInfo.rev : undefined;
+        let saveResult: StorageSaveResult;
+        try {
+            saveResult = await ctx.storage.save(ctx.path, data, ctx.opts, storageRev);
+        } catch (err) {
+            if (err instanceof StorageRevConflictError) {
+                ctx.logger.info('Save rev conflict, reloading from storage');
+                await this.loadFromStorageAndMerge(ctx);
+                return;
+            } else {
+                ctx.logger.info('Error saving data to storage');
+                throw err;
+            }
+        }
+        if (saveResult.rev) {
+            ctx.logger.info('Update rev in file info');
+            ctx.fileInfo.rev = saveResult.rev;
+        }
+        if (saveResult.path) {
+            ctx.logger.info('Update path in file info', saveResult.path);
+            ctx.file.path = saveResult.path;
+            ctx.fileInfo.path = saveResult.path;
+            ctx.path = saveResult.path;
+        }
+        ctx.file.syncDate = new Date();
+        ctx.logger.info('Save to storage complete, updated sync date');
+        // this.scheduleBackupFile(file, data); // TODO: backups
+    }
+
+    private async saveToCacheAndStorage(ctx: SyncContext) {
+        ctx.logger.info('Getting file data for saving');
+        const data = await ctx.file.getData();
+        if (ctx.storage.name === 'file') {
+            ctx.logger.info('Saving to file storage');
+        } else if (!ctx.file.dirty) {
+            ctx.logger.info('Saving to storage, skip cache because not dirty');
+        } else if (AppSettings.disableOfflineStorage) {
+            ctx.logger.info('Saving to storage, cache is disabled');
+        } else {
+            ctx.logger.info('Saving to cache');
+            await Storage.cache.save(ctx.file.id, data);
+            ctx.file.dirty = false;
+            ctx.logger.info('Saved to cache, saving to storage');
+        }
+        await this.saveToStorage(ctx, data);
+    }
+
+    private async loadFromStorageAndMerge(ctx: SyncContext) {
+        if (++ctx.retryCount === MaxLoadLoops) {
+            throw new Error('Too many load attempts');
+        }
+        ctx.logger.info('Load from storage, attempt', ctx.retryCount);
+        const storageLoadRes = await ctx.storage.load(ctx.path, ctx.opts);
+        ctx.logger.info('Load from storage', storageLoadRes.rev);
+
+        try {
+            await ctx.file.mergeOrUpdate(storageLoadRes.data);
+            ctx.logger.info('Merge complete OK');
+        } catch (err) {
+            ctx.logger.info('Merge error', err);
+            // this.refresh(); // TODO: trigger refresh
+            if (
+                err instanceof kdbxweb.KdbxError &&
+                err.code === kdbxweb.Consts.ErrorCodes.InvalidKey
+            ) {
+                ctx.logger.info('Remote key changed, request to enter new key');
+                // Events.emit('remote-key-changed', { file }); // TODO: show the key change screen
+            }
+            throw err;
+        }
+        if (ctx.stat?.rev) {
+            ctx.logger.info('Update rev in file info');
+            ctx.fileInfo.rev = ctx.stat.rev;
+        }
+        ctx.file.syncDate = new Date();
+        if (ctx.file.modified) {
+            ctx.logger.info('Updated sync date, saving modified file');
+            await this.saveToCacheAndStorage(ctx);
+        } else if (ctx.file.dirty) {
+            if (AppSettings.disableOfflineStorage) {
+                ctx.logger.info('File is dirty and cache is disabled');
+                throw new Error('File is dirty and cache is disabled');
+            }
+            ctx.logger.info('Saving not modified dirty file to cache');
+            await Storage.cache.save(ctx.fileInfo.id, storageLoadRes.data);
+            ctx.file.dirty = false;
+            ctx.logger.info('Complete, remove dirty flag');
+        } else {
+            ctx.logger.info('Complete, no changes');
+        }
+    }
+
+    private async backupFile(file: File, data: ArrayBuffer): Promise<void> {
+        if (file.backupInProgress) {
+            return;
+        }
+        file.backupInProgress = true;
+        try {
+            const opts = file.opts;
+            const backup = file.backup;
+            const logger = new Logger('backup', file.name);
+            if (!backup || !backup.storage || !backup.path) {
+                throw new Error('Invalid backup settings');
+            }
+            const storage = Storage.get(backup.storage);
+            if (!storage) {
+                throw new Error(`Invalid backup storage: ${backup.storage}`);
+            }
+
+            let path = backup.path.replace('{date}', DateFormat.dtStrFs(new Date()));
+            logger.info('Backup file to', backup.storage, path);
+
+            let folderPath = UrlFormat.fileToDir(path);
+            if (storage.getPathForName) {
+                folderPath = storage.getPathForName(folderPath).replace('.kdbx', '');
+            }
+            try {
+                await storage.stat(folderPath, opts);
+                logger.info('Backup folder exists, saving');
+            } catch (err) {
+                if (err instanceof StorageFileNotFoundError) {
+                    logger.info('Backup folder does not exist');
+                    if (!storage.mkdir) {
+                        throw new Error('Mkdir not supported by ' + backup.storage);
+                    }
+                    try {
+                        await storage.mkdir(folderPath);
+                        logger.info('Backup folder created');
+                    } catch (err) {
+                        logger.error('Error creating backup folder', err);
+                        throw new Error('Error creating backup folder');
+                    }
+                } else {
+                    logger.error('Stat folder error', err);
+                    throw new Error('Cannot stat backup folder');
+                }
+            }
+
+            if (storage.getPathForName) {
+                path = storage.getPathForName(path);
+            }
+            try {
+                await storage.save(path, data, opts);
+            } catch (err) {
+                logger.error('Backup error', err);
+                throw err;
+            }
+
+            logger.info('Backup complete');
+            backup.lastTime = Date.now();
+            file.backup = backup;
+
+            const fileInfo = FileManager.getFileInfoById(file.id);
+            if (fileInfo) {
+                fileInfo.backup = backup;
+            }
+        } finally {
+            file.backupInProgress = false;
+        }
+    }
+
+    private scheduleBackupFile(file: File, data: ArrayBuffer): void {
+        const backup = file.backup;
+        if (!backup || !backup.enabled || file.backupInProgress) {
+            return;
+        }
+        const logger = new Logger('backup', file.name);
+        let needBackup = false;
+        if (!backup.lastTime) {
+            needBackup = true;
+            logger.info('No last backup time, backup now');
+        } else {
+            const dt = new Date(backup.lastTime);
+            switch (backup.schedule) {
+                case '0':
+                    break;
+                case '1d':
+                    dt.setDate(dt.getDate() + 1);
+                    break;
+                case '1w':
+                    dt.setDate(dt.getDate() + 7);
+                    break;
+                case '1m':
+                    dt.setMonth(dt.getMonth() + 1);
+                    break;
+                default:
+                    return;
+            }
+            if (dt.getTime() <= Date.now()) {
+                needBackup = true;
+            }
+
+            const lastTimeStr = DateFormat.dtStrFs(backup.lastTime);
+            const dtStr = DateFormat.dtStrFs(dt);
+            logger.info(
+                `Last backup time: ${lastTimeStr}, schedule: ${backup.schedule}, ` +
+                    `next time: ${dtStr}, ${needBackup ? 'backup now' : 'skip backup'}`
+            );
+        }
+
+        const fileInfo = FileManager.getFileInfoById(file.id);
+        if (fileInfo) {
+            fileInfo.backup = backup;
+        }
+        if (needBackup) {
+            this.backupFile(file, data).catch(noop);
+        }
+    }
+
+    deleteAllCachedFiles(): void {
+        for (const fileInfo of FileManager.fileInfos) {
+            if (fileInfo.storage && !fileInfo.modified) {
+                Storage.cache.remove(fileInfo.id).catch(noop);
+            }
+        }
+    }
+
+    deleteAllStoredTokens(): void {
+        for (const storage of Object.values(Storage.getAll())) {
+            storage.deleteStoredToken();
+        }
+    }
+}
+
+const instance = new FileController();
+
+export { instance as FileController };

app/scripts/comp/app/focus-manager.ts

@@ -0,0 +1,26 @@
+import { Logger } from 'util/logger';
+
+const logger = new Logger('focus-manager');
+
+class FocusManager {
+    private readonly _modalStack: string[] = [];
+
+    get modal(): string | undefined {
+        return this._modalStack[this._modalStack.length - 1];
+    }
+
+    pushModal(value: string): void {
+        this._modalStack.push(value);
+        logger.debug('Push modal', value);
+    }
+
+    popModal(): string | undefined {
+        const lastModal = this._modalStack.pop();
+        logger.debug('Pop modal', lastModal, '=>', this._modalStack[this._modalStack.length - 1]);
+        return lastModal;
+    }
+}
+
+const instance = new FocusManager();
+
+export { instance as FocusManager };

app/scripts/comp/app/generator-presets.ts

@@ -0,0 +1,182 @@
+import { AppSettings } from 'models/app-settings';
+import { Locale } from 'util/locale';
+import {
+    PasswordGeneratorAppSetting,
+    PasswordGeneratorOptions,
+    PasswordGeneratorPreset,
+    PasswordGeneratorCustomPreset
+} from 'util/generators/password-generator';
+
+export const GeneratorPresets = {
+    get defaultPreset(): PasswordGeneratorPreset {
+        return {
+            name: 'Default',
+            title: Locale.genPresetDefault,
+            builtIn: true,
+            length: 16,
+            upper: true,
+            lower: true,
+            digits: true
+        };
+    },
+
+    get browserExtensionPreset(): PasswordGeneratorOptions {
+        return {
+            name: 'BrowserExtension',
+            length: 20,
+            upper: true,
+            lower: true,
+            special: true,
+            brackets: true,
+            ambiguous: true
+        };
+    },
+
+    get builtIn(): PasswordGeneratorPreset[] {
+        return [
+            this.defaultPreset,
+            {
+                name: 'Pronounceable',
+                title: Locale.genPresetPronounceable,
+                builtIn: true,
+                length: 10,
+                lower: true,
+                upper: true
+            },
+            {
+                name: 'Med',
+                title: Locale.genPresetMed,
+                builtIn: true,
+                length: 16,
+                upper: true,
+                lower: true,
+                digits: true,
+                special: true,
+                brackets: true,
+                ambiguous: true
+            },
+            {
+                name: 'Long',
+                title: Locale.genPresetLong,
+                builtIn: true,
+                length: 32,
+                upper: true,
+                lower: true,
+                digits: true
+            },
+            { name: 'Pin4', title: Locale.genPresetPin4, builtIn: true, length: 4, digits: true },
+            {
+                name: 'Mac',
+                title: Locale.genPresetMac,
+                builtIn: true,
+                length: 17,
+                include: '0123456789ABCDEF',
+                pattern: 'XX-'
+            },
+            {
+                name: 'Hash128',
+                title: Locale.genPresetHash128,
+                builtIn: true,
+                length: 32,
+                include: '0123456789abcdef'
+            },
+            {
+                name: 'Hash256',
+                title: Locale.genPresetHash256,
+                builtIn: true,
+                length: 64,
+                include: '0123456789abcdef'
+            }
+        ];
+    },
+
+    get all(): PasswordGeneratorPreset[] {
+        let presets = this.builtIn;
+        const setting = AppSettings.generatorPresets;
+        if (setting) {
+            if (setting.user) {
+                presets = presets.concat(setting.user.map((item) => ({ ...item })));
+            }
+            let hasDefault = false;
+            presets.forEach((preset) => {
+                if (setting.disabled && setting.disabled[preset.name]) {
+                    preset.disabled = true;
+                }
+                if (setting.default === preset.name) {
+                    hasDefault = true;
+                    preset.default = true;
+                }
+            });
+            if (!hasDefault) {
+                presets[0].default = true;
+            }
+        }
+        return presets;
+    },
+
+    get enabled(): PasswordGeneratorPreset[] {
+        const allPresets = this.all.filter((preset) => !preset.disabled);
+        if (!allPresets.length) {
+            allPresets.push(this.defaultPreset);
+        }
+        return allPresets;
+    },
+
+    getOrCreateSetting(): PasswordGeneratorAppSetting {
+        let setting = AppSettings.generatorPresets;
+        if (!setting) {
+            setting = { user: [], disabled: {} };
+        }
+        return setting;
+    },
+
+    add(preset: PasswordGeneratorCustomPreset): void {
+        const setting = this.getOrCreateSetting();
+        if (preset.name && !setting.user.filter((p) => p.name === preset.name).length) {
+            setting.user.push(preset);
+            this.save(setting);
+        }
+    },
+
+    remove(name: string): void {
+        const setting = this.getOrCreateSetting();
+        setting.user = setting.user.filter((p) => p.name !== name);
+        this.save(setting);
+    },
+
+    setPreset(name: string, props: Partial<PasswordGeneratorCustomPreset>): void {
+        const setting = this.getOrCreateSetting();
+        const preset = setting.user.filter((p) => p.name === name)[0];
+        if (preset) {
+            Object.assign(preset, props);
+            this.save(setting);
+        }
+    },
+
+    setDisabled(name: string, disabled: boolean): void {
+        const setting = this.getOrCreateSetting();
+        if (disabled) {
+            if (!setting.disabled) {
+                setting.disabled = {};
+            }
+            setting.disabled[name] = true;
+        } else if (setting.disabled) {
+            delete setting.disabled[name];
+        }
+        this.save(setting);
+    },
+
+    setDefault(name: string | null): void {
+        const setting = this.getOrCreateSetting();
+        if (name) {
+            setting.default = name;
+        } else {
+            delete setting.default;
+        }
+        this.save(setting);
+    },
+
+    save(setting: PasswordGeneratorAppSetting): void {
+        AppSettings.generatorPresets = { ...setting };
+    }
+};

app/scripts/comp/app/icon-select-controller.ts

@@ -0,0 +1,63 @@
+import { FileOpener } from 'util/browser/file-opener';
+import { IconSelectState } from 'models/ui/icon-select-state';
+import { Logger } from 'util/logger';
+import { Events } from 'util/events';
+import { IconUrlFormat } from 'util/formatting/icon-url-format';
+
+const logger = new Logger('icon-select');
+
+class IconSelectController {
+    openFile() {
+        FileOpener.open((file) => {
+            FileOpener.readBinary(file)
+                .then((fileData) => {
+                    IconSelectState.selectedIconDataUrl =
+                        IconUrlFormat.toDataUrl(fileData) ?? undefined;
+                })
+                .catch((ex) => logger.error('Error reading file', ex));
+        }, 'image/*');
+    }
+
+    downloadFavicon(websiteUrl: string): void {
+        if (IconSelectState.downloading) {
+            return;
+        }
+        IconSelectState.setDownloading();
+        const iconUrl = this.getIconUrl(websiteUrl);
+
+        const img = document.createElement('img');
+        img.crossOrigin = 'Anonymous';
+        img.src = iconUrl;
+        img.onload = () => {
+            IconSelectState.downloading = false;
+            logger.debug('Favicon downloaded', iconUrl);
+            const data = this.getIconData(img);
+            logger.debug(`Favicon data extracted: ${data.length} chars`);
+            Events.emit('custom-icon-downloaded', data);
+        };
+        img.onerror = (e) => {
+            logger.error('Favicon download error', iconUrl, e);
+            IconSelectState.setDownloadError();
+        };
+    }
+
+    private getIconUrl(websiteUrl: string): string {
+        const domain = websiteUrl.replace(/^.*:\/+/, '').replace(/\/.*/, '');
+        return 'https://services.keeweb.info/favicon/' + domain;
+    }
+
+    private getIconData(img: HTMLImageElement): string {
+        const size = Math.min(img.width, 32);
+        const canvas = document.createElement('canvas');
+        const ctx = canvas.getContext('2d');
+        canvas.width = size;
+        canvas.height = size;
+        ctx?.drawImage(img, 0, 0, size, size);
+
+        return canvas.toDataURL().replace(/^.*,/, '');
+    }
+}
+
+const instance = new IconSelectController();
+
+export { instance as IconSelectController };

app/scripts/comp/app/open-controller.ts

@@ -0,0 +1,314 @@
+import * as kdbxweb from 'kdbxweb';
+import { FileManager } from 'models/file-manager';
+import { Workspace } from 'models/workspace';
+import { AppSettings } from 'models/app-settings';
+import { FileOpener } from 'util/browser/file-opener';
+import { Alerts } from 'comp/ui/alerts';
+import { Locale } from 'util/locale';
+import { errorToString } from 'util/fn';
+import { DropboxChooser } from 'storage/dropbox-chooser';
+import { Logger } from 'util/logger';
+import { FileController } from 'comp/app/file-controller';
+import { OpenState } from 'models/ui/open-state';
+import { StorageBase } from 'storage/storage-base';
+import { BrowserAuthStartedError, OAuthRejectedError, StorageListItem } from 'storage/types';
+import { FunctionComponent, h } from 'preact';
+import { OpenStorageFileList } from 'ui/open/open-storage-file-list';
+import { UrlFormat } from 'util/formatting/url-format';
+
+const logger = new Logger('open');
+
+class OpenController {
+    open(): void {
+        if (OpenState.busy) {
+            return;
+        }
+        if (OpenState.id && FileManager.getFileById(OpenState.id)) {
+            Workspace.showList();
+            return;
+        }
+
+        OpenState.beginOpen();
+
+        FileController.open(OpenState)
+            .then(() => {
+                Workspace.showList();
+            })
+            .catch((err) => {
+                logger.error('Open error', err);
+                const invalidKey =
+                    err instanceof kdbxweb.KdbxError &&
+                    err.code === kdbxweb.Consts.ErrorCodes.InvalidKey;
+                OpenState.setOpenError(invalidKey);
+                if (!invalidKey) {
+                    // } else if (err.userCanceled) { // TODO: yubikey cancellation
+                    // if (err.notFound) { // TODO: handle file not found
+                    //     err = Locale.openErrorFileNotFound;
+                    // }
+                    const alertBody = Locale.openErrorDescription;
+                    // if (err.maybeTouchIdChanged) { // TODO: handle touch ID
+                    //     alertBody += '\n' + Locale.openErrorDescriptionMaybeTouchIdChanged;
+                    // }
+                    Alerts.error({
+                        header: Locale.openError,
+                        body: alertBody,
+                        pre: errorToString(err)
+                    });
+                }
+            });
+    }
+
+    selectKeyFileFromDropbox(): void {
+        if (OpenState.busy || !AppSettings.canOpen) {
+            return;
+        }
+        const dropboxChooser = new DropboxChooser((err, res) => {
+            if (!err && res) {
+                OpenState.setKeyFile(res.name, res.data);
+            }
+        });
+        dropboxChooser.choose();
+    }
+
+    chooseFile(): void {
+        if (OpenState.busy || !AppSettings.canOpen) {
+            return;
+        }
+        FileOpener.open((file) => {
+            this.readFile(file).catch((e) => logger.error('Error selecting file', e));
+        });
+    }
+
+    async readFile(file: File): Promise<void> {
+        const fileData = await FileOpener.readBinary(file);
+        const format = OpenController.getOpenFileFormat(file, fileData);
+        switch (format) {
+            case 'kdbx': {
+                const name = file.name.replace(/\.kdbx$/i, '');
+                OpenState.setFile(
+                    name,
+                    fileData,
+                    file.path || undefined,
+                    file.path ? 'file' : undefined
+                );
+                break;
+            }
+            case 'xml': {
+                const name = file.name.replace(/\.\w+$/i, '');
+                const xml = kdbxweb.ByteUtils.bytesToString(fileData);
+                try {
+                    await Workspace.importFileFromXml(name, xml);
+                } catch (e) {
+                    logger.error('Error importing XML', e);
+                    Alerts.error({
+                        header: Locale.openXml,
+                        body: Locale.openError,
+                        pre: errorToString(e)
+                    });
+                }
+                break;
+            }
+            case 'csv':
+                // TODO: load CSV
+                break;
+            case 'kdb':
+                Alerts.error({
+                    header: Locale.openWrongFile,
+                    body: Locale.openKdbFileBody
+                });
+                break;
+            default:
+                Alerts.error({
+                    header: Locale.openWrongFile,
+                    body: Locale.openWrongFileBody
+                });
+                break;
+        }
+    }
+
+    chooseKeyFile(): void {
+        if (OpenState.busy || !AppSettings.canOpen) {
+            return;
+        }
+        FileOpener.open((file) => {
+            this.readKeyFile(file).catch((e) => logger.error('Error selecting keyfile', e));
+        });
+    }
+
+    async readKeyFile(file: File): Promise<void> {
+        const keyFileData = await FileOpener.readBinary(file);
+        const path = AppSettings.rememberKeyFiles === 'path' && file.path ? file.path : undefined;
+        OpenState.setKeyFile(file.name, keyFileData, path);
+    }
+
+    readFileAndKeyFile(file: File, keyFile?: File): void {
+        this.readFile(file)
+            .then(() => {
+                if (keyFile) {
+                    return this.readKeyFile(keyFile);
+                }
+            })
+            .catch((e) => {
+                logger.error('Error reading file and keyfile', e);
+            });
+    }
+
+    readDroppedFiles(files: File[]): void {
+        if (!files.length) {
+            return;
+        }
+
+        const dataFile = files.find((file) => /\.kdbx$/i.test(file.name));
+        const keyFile = files.find((file) => /\.keyx?$/i.test(file.name));
+
+        if (dataFile) {
+            this.readFileAndKeyFile(dataFile, keyFile);
+            return;
+        }
+
+        this.readFile(files[0]).catch((e) => logger.error('Error reading dropped files', e));
+    }
+
+    listStorage(storage: StorageBase, dir?: string, prevDir?: string): void {
+        if (OpenState.busy || !storage.list) {
+            return;
+        }
+        OpenState.setStorageProgress(storage.name);
+        storage
+            .list(dir)
+            .then((files) => {
+                OpenState.resetStorageProgress();
+
+                if (!files.length) {
+                    Alerts.error({
+                        header: Locale.openNothingFound,
+                        body: Locale.openNothingFoundBody
+                    });
+                    return;
+                }
+
+                const collator = new Intl.Collator(undefined, { sensitivity: 'base' });
+                files.sort((x, y) => {
+                    if (x.dir !== y.dir) {
+                        return (y.dir ? 1 : 0) - (x.dir ? 1 : 0);
+                    }
+                    return collator.compare(x.path, y.path);
+                });
+                if (dir) {
+                    files.unshift({
+                        path: prevDir ?? '',
+                        name: '..',
+                        dir: true
+                    });
+                }
+
+                this.showStorageFileListAlert(storage, files, dir);
+            })
+            .catch((e) => {
+                OpenState.resetStorageProgress();
+                if (e instanceof BrowserAuthStartedError || e instanceof OAuthRejectedError) {
+                    return;
+                }
+                if (!Alerts.alertDisplayed) {
+                    Alerts.error({
+                        header: Locale.openError,
+                        body: Locale.openListErrorBody,
+                        pre: errorToString(e)
+                    });
+                }
+            });
+    }
+
+    private showStorageFileListAlert(
+        storage: StorageBase,
+        files: StorageListItem[],
+        currentDir?: string
+    ) {
+        const listView: FunctionComponent = () => {
+            const fileSelected = (file: StorageListItem) => {
+                if (file.dir) {
+                    this.listStorage(storage, file.path, currentDir);
+                } else {
+                    alert.closeWithResult('');
+                    OpenState.setStorageFile(storage.name, {
+                        path: file.path,
+                        name: UrlFormat.getDataFileName(file.name),
+                        rev: file.rev
+                    });
+                }
+            };
+
+            return h(OpenStorageFileList, {
+                files,
+                fileSelected
+            });
+        };
+
+        const alert = Alerts.alert({
+            header: Locale.openSelectFile,
+            body: Locale.openSelectFileBody,
+            icon: storage.icon || 'file-alt',
+            buttons: [{ result: '', title: Locale.alertCancel }],
+            esc: '',
+            click: '',
+            view: listView
+        });
+    }
+
+    private static getOpenFileFormat(
+        file: File,
+        fileData: ArrayBuffer
+    ): 'kdbx' | 'kdb' | 'xml' | 'csv' | undefined {
+        if (fileData.byteLength < 8) {
+            return undefined;
+        }
+        const fileSig = new Uint32Array(fileData, 0, 2);
+        if (fileSig[0] === kdbxweb.Consts.Signatures.FileMagic) {
+            if (fileSig[1] === kdbxweb.Consts.Signatures.Sig2Kdb) {
+                return 'kdb';
+            } else if (fileSig[1] === kdbxweb.Consts.Signatures.Sig2Kdbx) {
+                return 'kdbx';
+            } else {
+                return undefined;
+            }
+        } else if (AppSettings.canImportXml) {
+            try {
+                const str = kdbxweb.ByteUtils.bytesToString(fileSig).trim();
+                if (str.startsWith('<?xml')) {
+                    return 'xml';
+                }
+            } catch (e) {}
+            return undefined;
+        } else if (AppSettings.canImportCsv && /\.csv$/i.test(file.name)) {
+            return 'csv';
+        } else {
+            return undefined;
+        }
+    }
+
+    private static async showLocalFileAlert(): Promise<void> {
+        if (AppSettings.skipOpenLocalWarn) {
+            return;
+        }
+        const res = await Alerts.alert({
+            header: Locale.openLocalFile,
+            body: Locale.openLocalFileBody,
+            icon: 'file-alt',
+            buttons: [
+                { result: 'skip', title: Locale.openLocalFileDontShow, error: true },
+                { result: 'ok', title: Locale.alertOk }
+            ],
+            click: '',
+            esc: '',
+            enter: ''
+        }).wait();
+
+        if (res === 'skip') {
+            AppSettings.skipOpenLocalWarn = true;
+        }
+    }
+}
+
+const instance = new OpenController();
+
+export { instance as OpenController };

app/scripts/comp/app/otp-qr-reader.ts

@@ -0,0 +1,189 @@
+import { Events } from 'util/events';
+import { Shortcuts } from 'comp/browser/shortcuts';
+import { Alert, Alerts } from 'comp/ui/alerts';
+import { Features } from 'util/features';
+import { Locale } from 'util/locale';
+import { Logger } from 'util/logger';
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const QrCode = require('jsqrcode');
+
+const logger = new Logger('otp-qr-reader');
+
+class OtpQrReader {
+    private _alert?: Alert;
+    private _fileInput?: HTMLInputElement;
+
+    constructor() {
+        this.pasteEvent = this.pasteEvent.bind(this);
+    }
+
+    read() {
+        let screenshotKey = Shortcuts.screenshotToClipboardShortcut();
+        if (screenshotKey) {
+            screenshotKey = Locale.detSetupOtpAlertBodyWith.with(screenshotKey);
+        }
+        const pasteKey = Features.isMobile
+            ? ''
+            : Locale.detSetupOtpAlertBodyWith.with(Shortcuts.actionShortcutSymbol() + 'V');
+        this.startListenClipboard();
+        const buttons = [
+            { result: 'manually', title: Locale.detSetupOtpManualButton, silent: true },
+            Alerts.buttons.cancel
+        ];
+        if (Features.isMobile) {
+            buttons.unshift({ result: 'select', title: Locale.detSetupOtpScanButton });
+        }
+        const line3 = Features.isMobile
+            ? Locale.detSetupOtpAlertBody3Mobile
+            : Locale.detSetupOtpAlertBody3.with(pasteKey || '');
+        this._alert = Alerts.alert({
+            icon: 'qrcode',
+            header: Locale.detSetupOtpAlert,
+            body: [
+                Locale.detSetupOtpAlertBody,
+                Locale.detSetupOtpAlertBody1,
+                Locale.detSetupOtpAlertBody2.with(screenshotKey || ''),
+                line3,
+                Locale.detSetupOtpAlertBody4
+            ].join('\n'),
+            esc: '',
+            click: '',
+            enter: '',
+            buttons,
+            complete: (res) => {
+                this._alert = undefined;
+                this.stopListenClipboard();
+                if (res === 'select') {
+                    this.selectFile();
+                } else if (res === 'manually') {
+                    this.enterManually();
+                }
+            }
+        });
+    }
+
+    selectFile() {
+        if (!this._fileInput) {
+            const input = document.createElement('input');
+            input.setAttribute('type', 'file');
+            input.setAttribute('capture', 'camera');
+            input.setAttribute('accept', 'image/*');
+            input.setAttribute('class', 'hide-by-pos');
+            this._fileInput = input;
+            this._fileInput.onchange = () => this.fileSelected();
+        }
+        this._fileInput.click();
+    }
+
+    private fileSelected() {
+        const file = this._fileInput?.files?.[0];
+        if (!file || file.type.indexOf('image') < 0) {
+            return;
+        }
+        this.readFile(file);
+    }
+
+    private startListenClipboard() {
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        document.addEventListener('paste', this.pasteEvent);
+    }
+
+    private stopListenClipboard() {
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        document.removeEventListener('paste', this.pasteEvent);
+    }
+
+    private pasteEvent(e: ClipboardEvent) {
+        const items = e.clipboardData?.items;
+        if (!items) {
+            logger.info('Empty clipboard data');
+            return;
+        }
+        const item = [...items].find(
+            (item) => item.kind === 'file' && item.type.indexOf('image') !== -1
+        );
+        if (!item) {
+            logger.info('Paste without file');
+            return;
+        }
+        logger.info('Reading pasted image', item.type);
+        if (this._alert) {
+            this._alert.change({
+                header: Locale.detOtpImageReading
+            });
+        }
+        const file = item.getAsFile();
+        if (file) {
+            this.readFile(file);
+        } else {
+            logger.info('Empty file');
+        }
+    }
+
+    private readFile(file: File) {
+        const reader = new FileReader();
+        reader.onload = () => {
+            if (typeof reader.result !== 'string') {
+                logger.info('Read not a string');
+                return;
+            }
+            logger.info('Image data loaded');
+            this.readQr(reader.result);
+        };
+        reader.readAsDataURL(file);
+    }
+
+    private readQr(imageData: string) {
+        const image = new Image();
+        image.onload = () => {
+            logger.info('Image format loaded');
+            try {
+                const ts = logger.ts();
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+                const url = new QrCode(image).decode();
+                logger.info('QR code read', logger.ts(ts));
+                this.removeAlert();
+                if (typeof url === 'string' && url) {
+                    Events.emit('qr-url-read', url);
+                } else {
+                    logger.error('Error reading QR code');
+                    Alerts.error({
+                        header: Locale.detOtpQrWrong,
+                        body: Locale.detOtpQrWrongBody
+                    });
+                }
+            } catch (e) {
+                logger.error('Error reading QR code', e);
+                this.removeAlert();
+                Alerts.error({
+                    header: Locale.detOtpQrError,
+                    body: Locale.detOtpQrErrorBody
+                });
+            }
+        };
+        image.onerror = () => {
+            logger.info('Image load error');
+            this.removeAlert();
+            Alerts.error({
+                header: Locale.detOtpImageError,
+                body: Locale.detOtpImageErrorBody
+            });
+        };
+        image.src = imageData;
+    }
+
+    private enterManually() {
+        Events.emit('qr-enter-manually');
+    }
+
+    private removeAlert() {
+        if (this._alert) {
+            this._alert.closeImmediate();
+        }
+    }
+}
+
+const instance = new OtpQrReader();
+
+export { instance as OtpQrReader };

app/scripts/comp/app/updater.ts

@@ -0,0 +1,472 @@
+import * as kdbxweb from 'kdbxweb';
+import { RuntimeInfo } from 'const/runtime-info';
+import { Launcher } from 'comp/launcher';
+import { Links } from 'const/links';
+import { AppSettings } from 'models/app-settings';
+import { SemVer } from 'util/data/semver';
+import { Logger } from 'util/logger';
+import { SignatureVerifier } from 'util/data/signature-verifier';
+import { Model } from 'util/model';
+import { Timeouts } from 'const/timeouts';
+import { RuntimeData } from 'models/runtime-data';
+import { noop } from 'util/fn';
+import { StringFormat } from 'util/formatting/string-format';
+import { ClientRequestArgs } from 'http';
+import * as fs from 'fs';
+import path from 'path';
+import https from 'https';
+
+const logger = new Logger('updater');
+
+class Updater extends Model {
+    readonly enabled = Launcher?.updaterEnabled() ?? false;
+
+    status: 'unknown' | 'ready' | 'checking' | 'error' | 'ok' = 'unknown';
+
+    updateStatus:
+        | 'unknown'
+        | 'found'
+        | 'ready'
+        | 'downloading'
+        | 'extracting'
+        | 'updating'
+        | 'error' = 'unknown';
+
+    updateError?: string;
+
+    private _nextCheckTimeout?: number;
+    private _updateCheckDate = new Date(0);
+
+    init(): void {
+        this.scheduleNextCheck();
+        if (!Launcher && navigator.serviceWorker && !RuntimeInfo.beta && !RuntimeInfo.devMode) {
+            navigator.serviceWorker
+                .register('service-worker.js')
+                .then((reg) => {
+                    logger.info('Service worker registered');
+                    reg.addEventListener('updatefound', () => {
+                        if (reg.active) {
+                            logger.info('Service worker found an update');
+                            this.updateStatus = 'ready';
+                        }
+                    });
+                })
+                .catch((e) => {
+                    logger.error('Failed to register a service worker', e);
+                });
+        }
+    }
+
+    get updateInProgress(): boolean {
+        return (
+            this.status === 'checking' ||
+            ['downloading', 'extracting', 'updating'].includes(this.updateStatus)
+        );
+    }
+
+    scheduleNextCheck(): void {
+        if (this._nextCheckTimeout) {
+            clearTimeout(this._nextCheckTimeout);
+            this._nextCheckTimeout = undefined;
+        }
+        if (!this.enabled || !AppSettings.autoUpdate) {
+            return;
+        }
+        let timeDiff = Timeouts.MinUpdateTimeout;
+        const lastCheckDate = RuntimeData.lastUpdateCheckDate;
+        if (lastCheckDate) {
+            timeDiff = Math.min(
+                Math.max(
+                    Timeouts.UpdateInterval + (lastCheckDate.getTime() - Date.now()),
+                    Timeouts.MinUpdateTimeout
+                ),
+                Timeouts.UpdateInterval
+            );
+        }
+        this._nextCheckTimeout = window.setTimeout(() => {
+            this.check(false).catch(noop);
+        }, timeDiff);
+        logger.info(`Next update check will happen in ${Math.round(timeDiff / 1000)}s`);
+    }
+
+    async check(startedByUser: boolean) {
+        if (!this.enabled || this.updateInProgress) {
+            return;
+        }
+        this.status = 'checking';
+        if (!startedByUser) {
+            // additional protection from broken program logic, to ensure that auto-checks are not performed more than once an hour
+            const diffMs = Date.now() - this._updateCheckDate.getTime();
+            if (isNaN(diffMs) || diffMs < 1000 * 60 * 60) {
+                logger.error(
+                    'Prevented update check; last check was performed at',
+                    this._updateCheckDate
+                );
+                this.scheduleNextCheck();
+                return;
+            }
+            this._updateCheckDate = new Date();
+        }
+        logger.info('Checking for update...');
+
+        let data: Buffer | undefined;
+        try {
+            const httpRes = await this.httpGet({
+                url: Links.UpdateJson
+            });
+            data = httpRes.data;
+        } catch (e) {
+            logger.error('Update check error', e);
+            RuntimeData.batchSet(() => {
+                RuntimeData.lastUpdateCheckDate = new Date();
+                RuntimeData.lastUpdateCheckError = 'Error checking last version';
+            });
+            this.status = 'error';
+            this.scheduleNextCheck();
+            return;
+        }
+
+        let updateJson: Record<string, unknown>;
+        try {
+            const parsed = JSON.parse(data?.toString() || '') as unknown;
+            if (!parsed || typeof parsed !== 'object') {
+                throw new Error('Empty data');
+            }
+            updateJson = parsed as Record<string, unknown>;
+        } catch (e) {
+            logger.error('Failed to parse JSON', data);
+            return;
+        }
+
+        const updateVersion = updateJson.version;
+        const updateDate = new Date(String(updateJson.date));
+
+        const dt = new Date();
+        logger.info('Update check', updateVersion || 'no version', updateDate);
+
+        if (typeof updateVersion !== 'string' || !updateDate.getTime()) {
+            RuntimeData.batchSet(() => {
+                RuntimeData.lastUpdateCheckDate = dt;
+                RuntimeData.lastUpdateCheckError = 'Failed to parse update information';
+            });
+            this.status = 'error';
+            this.scheduleNextCheck();
+            return;
+        }
+
+        const prevLastVersion = RuntimeData.lastUpdateVersion;
+        RuntimeData.batchSet(() => {
+            RuntimeData.lastUpdateCheckDate = dt;
+            RuntimeData.lastSuccessUpdateCheckDate = dt;
+            RuntimeData.lastUpdateVersionReleaseDate = updateDate;
+            RuntimeData.lastUpdateVersion = updateVersion;
+            RuntimeData.lastUpdateCheckError = undefined;
+        });
+        this.status = 'ok';
+        this.scheduleNextCheck();
+
+        if (prevLastVersion === RuntimeData.lastUpdateVersion && this.updateStatus === 'ready') {
+            logger.info('Waiting for the user to apply downloaded update');
+            return;
+        }
+        if (!startedByUser && AppSettings.autoUpdate === 'install') {
+            await this.update();
+        } else if (SemVer.compareVersions(updateVersion, RuntimeInfo.version) > 0) {
+            this.updateStatus = 'found';
+        }
+    }
+
+    async updateAndRestart() {
+        await this.update();
+        await this.installAndRestart();
+    }
+
+    private async update() {
+        if (!this.enabled) {
+            logger.info('Updater is disabled');
+            return;
+        }
+        const ver = RuntimeData.lastUpdateVersion;
+        if (!ver) {
+            logger.info('No last update version');
+            return;
+        }
+        if (SemVer.compareVersions(RuntimeInfo.version, ver) >= 0) {
+            logger.info('You are using the latest version');
+            return;
+        }
+
+        this.batchSet(() => {
+            this.updateStatus = 'downloading';
+            this.updateError = undefined;
+        });
+
+        logger.info('Downloading update', ver);
+        const updateAssetName = this.getUpdateAssetName(ver);
+        if (!updateAssetName) {
+            logger.error('Empty updater asset name for', process.platform, process.arch);
+            return;
+        }
+
+        const updateUrlBasePath = Links.UpdateBasePath.replace('{ver}', ver);
+        const updateAssetUrl = updateUrlBasePath + updateAssetName;
+
+        let assetFilePath: string;
+        try {
+            const httpRes = await this.httpGet({
+                url: updateAssetUrl,
+                file: updateAssetName,
+                cleanupOldFiles: true,
+                cache: true
+            });
+            if (!httpRes.fileName) {
+                throw new Error('No fileName');
+            }
+            assetFilePath = httpRes.fileName;
+        } catch (e) {
+            logger.error('Error downloading update', e);
+            this.batchSet(() => {
+                this.updateStatus = 'error';
+                this.updateError = 'Error downloading update';
+            });
+            return;
+        }
+
+        logger.info('Downloading update signatures');
+
+        let assetFileSignaturePath: string;
+        try {
+            const httpRes = await this.httpGet({
+                url: updateUrlBasePath + 'Verify.sign.sha256',
+                file: updateAssetName + '.sign',
+                cleanupOldFiles: true,
+                cache: true
+            });
+            if (!httpRes.fileName) {
+                throw new Error('No fileName');
+            }
+            assetFileSignaturePath = httpRes.fileName;
+        } catch (e) {
+            logger.error('Error downloading update signatures', e);
+            this.batchSet(() => {
+                this.updateStatus = 'error';
+                this.updateError = 'Error downloading update signatures';
+            });
+            return;
+        }
+
+        let valid: boolean;
+        try {
+            valid = await this.verifySignature(assetFilePath, updateAssetName);
+        } catch (err) {
+            this.batchSet(() => {
+                this.updateStatus = 'error';
+                this.updateError = 'Error verifying update signature';
+            });
+            return;
+        }
+
+        if (!valid) {
+            this.batchSet(() => {
+                this.updateStatus = 'error';
+                this.updateError = 'Invalid update signature';
+            });
+            fs.unlink(assetFilePath, noop);
+            fs.unlink(assetFileSignaturePath, noop);
+            return;
+        }
+
+        logger.info('Update is ready', assetFilePath);
+        this.batchSet(() => {
+            this.updateStatus = 'ready';
+            this.updateError = undefined;
+        });
+    }
+
+    private async verifySignature(assetFilePath: string, assetName: string): Promise<boolean> {
+        logger.info('Verifying update signature', assetName);
+        const signaturesTxt = await fs.promises.readFile(assetFilePath + '.sign', 'utf8');
+        const assetSignatureLine = signaturesTxt
+            .split('\n')
+            .find((line) => line.endsWith(assetName));
+        if (!assetSignatureLine) {
+            logger.error('Signature not found for asset', assetName);
+            throw new Error('Asset signature not found');
+        }
+        const signature = kdbxweb.ByteUtils.hexToBytes(assetSignatureLine.split(' ')[0]);
+        const fileBytes = fs.readFileSync(assetFilePath);
+        try {
+            const valid = await SignatureVerifier.verify(fileBytes, signature);
+            logger.info(`Update asset signature is ${valid ? 'valid' : 'invalid'}`);
+            return valid;
+        } catch (e) {
+            logger.error('Error verifying signature', e);
+            throw e;
+        }
+    }
+
+    private getUpdateAssetName(ver: string): string | undefined {
+        const platform = process.platform;
+        const arch = process.arch;
+        switch (platform) {
+            case 'win32':
+                switch (arch) {
+                    case 'x64':
+                        return `KeeWeb-${ver}.win.x64.exe`;
+                    case 'ia32':
+                        return `KeeWeb-${ver}.win.ia32.exe`;
+                    case 'arm64':
+                        return `KeeWeb-${ver}.win.arm64.exe`;
+                }
+                break;
+            case 'darwin':
+                switch (arch) {
+                    case 'x64':
+                        return `KeeWeb-${ver}.mac.x64.dmg`;
+                    case 'arm64':
+                        return `KeeWeb-${ver}.mac.arm64.dmg`;
+                }
+                break;
+        }
+        return undefined;
+    }
+
+    async installAndRestart(): Promise<void> {
+        if (!Launcher || !RuntimeData.lastUpdateVersion) {
+            return;
+        }
+        const updateAssetName = this.getUpdateAssetName(RuntimeData.lastUpdateVersion);
+        const updateFilePath = await this.cacheFilePath(updateAssetName);
+        Launcher.requestRestartAndUpdate(updateFilePath);
+    }
+
+    async cacheFilePath(fileName?: string): Promise<string> {
+        const tempPath = await Launcher?.ipcRenderer.invoke('get-temp-path');
+        if (!tempPath) {
+            throw new Error('Failed to get temp path');
+        }
+        return fileName ? path.join(tempPath, fileName) : tempPath;
+    }
+
+    async httpGet(config: {
+        url: string;
+        file?: string;
+        cache?: boolean;
+        cleanupOldFiles?: boolean;
+        noRedirect?: boolean;
+    }): Promise<{ fileName?: string; data?: Buffer }> {
+        let tmpFile: string;
+        if (config.file) {
+            const baseTempPath = await this.cacheFilePath();
+            if (config.cleanupOldFiles) {
+                const allFiles = await fs.promises.readdir(baseTempPath);
+                for (const file of allFiles) {
+                    if (
+                        file !== config.file &&
+                        StringFormat.replaceVersion(file, '0') ===
+                            StringFormat.replaceVersion(config.file, '0')
+                    ) {
+                        await fs.promises.unlink(path.join(baseTempPath, file));
+                    }
+                }
+            }
+            tmpFile = path.join(baseTempPath, config.file);
+            let tmpFileExists = true;
+            try {
+                await fs.promises.access(tmpFile);
+            } catch {
+                tmpFileExists = false;
+            }
+            if (tmpFileExists) {
+                try {
+                    if (config.cache && (await fs.promises.stat(tmpFile)).size > 0) {
+                        logger.info('File already downloaded', config.url);
+                        return Promise.resolve({ fileName: tmpFile });
+                    } else {
+                        await fs.promises.unlink(tmpFile);
+                    }
+                } catch (e) {
+                    fs.promises.unlink(tmpFile).catch(noop);
+                }
+            }
+        }
+
+        logger.info('GET ' + config.url);
+
+        const proxy = await Launcher?.ipcRenderer.invoke('resolve-proxy', config.url);
+
+        const url = new URL(config.url);
+        const opts: ClientRequestArgs = {
+            host: url.host,
+            port: url.port,
+            path: url.pathname + url.search
+        };
+        opts.headers = { 'User-Agent': navigator.userAgent };
+
+        logger.info(
+            'Request to ' +
+                config.url +
+                ' ' +
+                (proxy ? `using proxy ${proxy.host}:${proxy.port}` : 'without proxy')
+        );
+        if (proxy) {
+            opts.headers.Host = url.host;
+            opts.host = proxy.host;
+            opts.port = proxy.port;
+            opts.path = config.url;
+        }
+
+        return new Promise((resolve, reject) => {
+            https
+                .get(opts, (res) => {
+                    logger.info(`Response from ${config.url}: `, res.statusCode);
+                    if (res.statusCode === 200) {
+                        if (config.file) {
+                            const file = fs.createWriteStream(tmpFile);
+                            res.pipe(file);
+                            file.on('finish', () => {
+                                file.on('close', () => {
+                                    resolve({ fileName: tmpFile });
+                                });
+                                file.close();
+                            });
+                            file.on('error', (err) => {
+                                reject(err);
+                            });
+                        } else {
+                            const chunks: Buffer[] = [];
+                            res.on('data', (chunk) => {
+                                chunks.push(chunk);
+                            });
+                            res.on('end', () => {
+                                resolve({ data: Buffer.concat(chunks) });
+                            });
+                        }
+                    } else if (
+                        res.headers.location &&
+                        (res.statusCode === 301 || res.statusCode === 302)
+                    ) {
+                        if (config.noRedirect) {
+                            return reject(new Error('Too many redirects'));
+                        }
+                        config.url = res.headers.location;
+                        config.noRedirect = true;
+                        resolve(this.httpGet(config));
+                    } else {
+                        reject(new Error(`HTTP status ${res.statusCode ?? 0}`));
+                    }
+                })
+                .on('error', (e) => {
+                    logger.error('Cannot GET ' + config.url, e);
+                    if (tmpFile) {
+                        fs.unlink(tmpFile, noop);
+                    }
+                    reject(e);
+                });
+        });
+    }
+}
+
+const instance = new Updater();
+
+export { instance as Updater };

app/scripts/comp/browser/copy-paste.ts

@@ -0,0 +1,79 @@
+import { Events } from 'util/events';
+import { Launcher } from 'comp/launcher';
+import { AppSettings } from 'models/app-settings';
+
+interface CopyPasteResult {
+    success: boolean;
+    seconds?: number;
+}
+
+const CopyPaste = {
+    copy(text: string): CopyPasteResult {
+        if (Launcher) {
+            Launcher.setClipboardText(text);
+            const clipboardSeconds = AppSettings.clipboardSeconds;
+            if (clipboardSeconds > 0) {
+                const clearClipboard = () => {
+                    if (Launcher?.getClipboardText() === text) {
+                        Launcher.clearClipboardText();
+                    }
+                };
+                Events.on('main-window-will-close', clearClipboard);
+                setTimeout(() => {
+                    clearClipboard();
+                    Events.off('main-window-will-close', clearClipboard);
+                }, clipboardSeconds * 1000);
+            }
+            return { success: true, seconds: clipboardSeconds };
+        } else {
+            try {
+                if (document.execCommand('copy')) {
+                    return { success: true };
+                }
+            } catch (e) {}
+            return { success: false };
+        }
+    },
+
+    createHiddenInput(text: string): void {
+        const hiddenInput = document.createElement('input');
+        hiddenInput.value = text;
+        hiddenInput.classList.add('hide-by-pos');
+        document.body.appendChild(hiddenInput);
+        hiddenInput.selectionStart = 0;
+        hiddenInput.selectionEnd = text.length;
+        hiddenInput.focus();
+
+        const onChange = () => {
+            setTimeout(() => hiddenInput.blur(), 0);
+        };
+        hiddenInput.addEventListener('cut', onChange);
+        hiddenInput.addEventListener('copy', onChange);
+        hiddenInput.addEventListener('paste', onChange);
+        hiddenInput.addEventListener('blur', () => hiddenInput.remove());
+    },
+
+    copyHtml(html: string): boolean {
+        const el = document.createElement('div');
+        el.style.userSelect = 'auto';
+        el.innerHTML = html;
+        document.body.appendChild(el);
+
+        const range = document.createRange();
+        range.selectNodeContents(el);
+        const sel = window.getSelection();
+        if (!sel) {
+            el.remove();
+            return false;
+        }
+        sel.removeAllRanges();
+        sel.addRange(range);
+
+        const result = document.execCommand('copy');
+
+        el.remove();
+        return result;
+    }
+};
+
+export { CopyPaste };

app/scripts/comp/browser/focus-detector.ts

@@ -0,0 +1,39 @@
+import { Events } from 'util/events';
+import { Launcher } from 'comp/launcher';
+import { Features } from 'util/features';
+
+const FocusDetector = {
+    isFocused: false,
+    detectsFocusWithEvents: false,
+
+    init(): void {
+        this.isFocused = true;
+        this.detectsFocusWithEvents = !Features.isDesktop && !Features.isMobile;
+        if (this.detectsFocusWithEvents) {
+            window.addEventListener('focus', () => {
+                if (!FocusDetector.isFocused) {
+                    FocusDetector.isFocused = true;
+                    Events.emit('main-window-focus');
+                }
+            });
+            window.addEventListener('blur', () => {
+                if (FocusDetector.isFocused) {
+                    FocusDetector.isFocused = false;
+                    Events.emit('main-window-blur');
+                }
+            });
+        }
+    },
+
+    hasFocus(): Promise<boolean> {
+        if (this.detectsFocusWithEvents) {
+            return Promise.resolve(this.isFocused);
+        } else if (Launcher) {
+            return Launcher.ipcRenderer.invoke('is-app-focused');
+        } else {
+            return Promise.resolve(true);
+        }
+    }
+};
+
+export { FocusDetector };

app/scripts/comp/browser/idle-tracker.ts

@@ -0,0 +1,24 @@
+import { Events } from 'util/events';
+import { AppSettings } from 'models/app-settings';
+
+const IdleTracker = {
+    actionTime: Date.now(),
+    init(): void {
+        setInterval(this.checkIdle.bind(this), 1000 * 60);
+    },
+    checkIdle(): void {
+        const idleMinutes = (Date.now() - this.actionTime) / 1000 / 60;
+        const maxIdleMinutes = AppSettings.idleMinutes;
+        if (maxIdleMinutes && idleMinutes > maxIdleMinutes) {
+            Events.emit('before-user-idle');
+            Events.emit('user-idle');
+        }
+    },
+    regUserAction(): void {
+        this.actionTime = Date.now();
+    }
+};
+
+Events.on('power-monitor-resume', () => IdleTracker.checkIdle());
+
+export { IdleTracker };

app/scripts/comp/browser/key-handler.ts

@@ -0,0 +1,156 @@
+import { Events } from 'util/events';
+import { IdleTracker } from 'comp/browser/idle-tracker';
+import { Keys } from 'const/keys';
+import { FocusManager } from 'comp/app/focus-manager';
+
+const shortcutKeyProp = navigator.platform.indexOf('Mac') >= 0 ? 'metaKey' : 'ctrlKey';
+
+interface ShortcutDef {
+    handler: (e: KeyboardEvent, code: number) => void;
+    shortcut?: number;
+    modal?: string;
+    noPrevent?: boolean;
+}
+
+class KeyHandler {
+    SHORTCUT_ACTION = 1;
+    SHORTCUT_OPT = 2;
+    SHORTCUT_SHIFT = 4;
+
+    shortcuts = new Map<Keys, ShortcutDef[]>();
+
+    init() {
+        document.addEventListener('keypress', (e) => this.keypress(e));
+        document.addEventListener('keydown', (e) => this.keydown(e));
+
+        this.shortcuts.set(Keys.DOM_VK_A, [
+            {
+                handler: (e) => this.handleAKey(e),
+                shortcut: this.SHORTCUT_ACTION,
+                modal: '*',
+                noPrevent: true
+            }
+        ]);
+    }
+
+    onKey(
+        key: Keys,
+        handler: (e: KeyboardEvent) => void,
+        shortcut?: number,
+        modal?: string,
+        noPrevent?: boolean
+    ): () => void {
+        let keyShortcuts = this.shortcuts.get(key);
+        if (!keyShortcuts) {
+            keyShortcuts = [];
+            this.shortcuts.set(key, keyShortcuts);
+        }
+        const def: ShortcutDef = {
+            handler,
+            shortcut,
+            modal,
+            noPrevent
+        };
+        keyShortcuts.push(def);
+
+        return () => {
+            const keyShortcuts = this.shortcuts.get(key);
+            if (keyShortcuts) {
+                const ix = keyShortcuts.indexOf(def);
+                if (ix >= 0) {
+                    keyShortcuts.splice(ix, 1);
+                }
+            }
+        };
+    }
+
+    isActionKey(e: KeyboardEvent): boolean {
+        return e[shortcutKeyProp];
+    }
+
+    keydown(e: KeyboardEvent): void {
+        IdleTracker.regUserAction();
+        const code = e.keyCode || e.which;
+        const keyShortcuts = this.shortcuts.get(code);
+        if (keyShortcuts && keyShortcuts.length) {
+            for (const sh of keyShortcuts) {
+                if (FocusManager.modal && sh.modal !== FocusManager.modal && sh.modal !== '*') {
+                    e.stopPropagation();
+                    continue;
+                }
+                const isActionKey = this.isActionKey(e);
+                switch (sh.shortcut) {
+                    case this.SHORTCUT_ACTION:
+                        if (!isActionKey) {
+                            continue;
+                        }
+                        break;
+                    case this.SHORTCUT_OPT:
+                        if (!e.altKey) {
+                            continue;
+                        }
+                        break;
+                    case this.SHORTCUT_SHIFT:
+                        if (!e.shiftKey) {
+                            continue;
+                        }
+                        break;
+                    case this.SHORTCUT_ACTION + this.SHORTCUT_OPT:
+                        if (!e.altKey || !isActionKey) {
+                            continue;
+                        }
+                        break;
+                    default:
+                        if (e.metaKey || e.ctrlKey || e.altKey || e.shiftKey) {
+                            continue;
+                        }
+                        break;
+                }
+                let immediatePropagationStopped = false;
+                e.stopImmediatePropagation = () => {
+                    immediatePropagationStopped = true;
+                    KeyboardEvent.prototype.stopImmediatePropagation.call(e);
+                };
+                sh.handler(e, code);
+                if (isActionKey && !sh.noPrevent) {
+                    e.preventDefault();
+                }
+                if (immediatePropagationStopped) {
+                    break;
+                }
+            }
+        }
+    }
+
+    keypress(e: KeyboardEvent): void {
+        if (
+            !FocusManager.modal &&
+            e.which !== Keys.DOM_VK_RETURN &&
+            e.which !== Keys.DOM_VK_ESCAPE &&
+            e.which !== Keys.DOM_VK_TAB &&
+            !e.altKey &&
+            !e.ctrlKey &&
+            !e.metaKey
+        ) {
+            Events.emit('keypress', e);
+        } else if (FocusManager.modal) {
+            Events.emit('keypress-modal', e, FocusManager.modal);
+        }
+    }
+
+    reg() {
+        IdleTracker.regUserAction();
+    }
+
+    handleAKey(e: KeyboardEvent): void {
+        if (e.target instanceof HTMLInputElement && ['password', 'text'].includes(e.target.type)) {
+            e.stopImmediatePropagation();
+        } else {
+            e.preventDefault();
+        }
+    }
+}
+
+const instance = new KeyHandler();
+
+export { instance as KeyHandler };

app/scripts/comp/browser/popup-notifier.ts

@@ -0,0 +1,65 @@
+import { Events } from 'util/events';
+import { Launcher } from 'comp/launcher';
+import { Alerts } from 'comp/ui/alerts';
+import { Timeouts } from 'const/timeouts';
+import { Locale } from 'util/locale';
+
+const PopupNotifier = {
+    init(): void {
+        if (Launcher) {
+            window.open = () => null;
+        } else {
+            const windowOpen = window.open;
+            window.open = function (...args) {
+                const win = windowOpen.apply(window, args);
+                if (win) {
+                    PopupNotifier.deferCheckClosed(win);
+                    Events.emit('popup-opened', win);
+                } else if (!Alerts.alertDisplayed) {
+                    Alerts.error({
+                        header: Locale.authPopupRequired,
+                        body: Locale.authPopupRequiredBody
+                    });
+                }
+                return win;
+            };
+        }
+    },
+
+    deferCheckClosed(win: Window): void {
+        setTimeout(PopupNotifier.checkClosed.bind(PopupNotifier, win), Timeouts.CheckWindowClosed);
+    },
+
+    checkClosed(win: Window): void {
+        if (win.closed) {
+            setTimeout(
+                PopupNotifier.triggerClosed.bind(PopupNotifier, win),
+                Timeouts.CheckWindowClosed
+            );
+        } else {
+            const loc = PopupNotifier.tryGetLocationSearch(win);
+            if (loc) {
+                try {
+                    win.close();
+                } catch {}
+                PopupNotifier.triggerClosed(win, loc);
+                return;
+            }
+            PopupNotifier.deferCheckClosed(win);
+        }
+    },
+
+    tryGetLocationSearch(win: Window): string | undefined {
+        try {
+            if (win.location.host === location.host) {
+                return win.location.search;
+            }
+        } catch {}
+    },
+
+    triggerClosed(window: Window, locationSearch?: string): void {
+        Events.emit('popup-closed', window, locationSearch);
+    }
+};
+
+export { PopupNotifier };

app/scripts/comp/browser/shortcuts.ts

@@ -0,0 +1,160 @@
+import { Launcher } from 'comp/launcher';
+import { Keys } from 'const/keys';
+import { AppSettingsFieldName, AppSettings } from 'models/app-settings';
+import { Features } from 'util/features';
+import { Locale } from 'util/locale';
+
+let allowedKeys: Map<number, string>;
+
+function getAllowedKeys(): Map<number, string> {
+    if (!allowedKeys) {
+        allowedKeys = new Map<number, string>();
+        for (const [name, code] of Object.entries(Keys)) {
+            if (typeof code === 'string') {
+                continue;
+            }
+            const keyName = name.replace('DOM_VK_', '');
+            if (/^([0-9A-Z]|F\d{1,2})$/.test(keyName)) {
+                allowedKeys.set(code, keyName);
+            }
+        }
+    }
+    return allowedKeys;
+}
+
+const AllGlobalShortcuts = {
+    copyPassword: { mac: 'Ctrl+Alt+C', all: 'Shift+Alt+C' },
+    copyUser: { mac: 'Ctrl+Alt+B', all: 'Shift+Alt+B' },
+    copyUrl: { mac: 'Ctrl+Alt+U', all: 'Shift+Alt+U' },
+    copyOtp: undefined,
+    autoType: { mac: 'Ctrl+Alt+T', all: 'Shift+Alt+T' },
+    restoreApp: undefined
+};
+
+export type GlobalShortcutType = keyof typeof AllGlobalShortcuts;
+
+const GlobalShortcutAppSettingsFields: Record<GlobalShortcutType, AppSettingsFieldName> = {
+    copyPassword: 'globalShortcutCopyPassword',
+    copyUser: 'globalShortcutCopyUser',
+    copyUrl: 'globalShortcutCopyUrl',
+    copyOtp: 'globalShortcutCopyOtp',
+    autoType: 'globalShortcutAutoType',
+    restoreApp: 'globalShortcutRestoreApp'
+};
+
+const Shortcuts = {
+    keyEventToShortcut(event: KeyboardEvent): { valid: boolean; value: string } {
+        const modifiers = [];
+        if (event.ctrlKey) {
+            modifiers.push('Ctrl');
+        }
+        if (event.altKey) {
+            modifiers.push('Alt');
+        }
+        if (event.shiftKey) {
+            modifiers.push('Shift');
+        }
+        if (Features.isMac && event.metaKey) {
+            modifiers.push('Meta');
+        }
+        const keyName = getAllowedKeys().get(event.which);
+        return {
+            value: modifiers.join('+') + '+' + (keyName || '…'),
+            valid: modifiers.length > 0 && !!keyName
+        };
+    },
+
+    presentShortcut(shortcutValue: string | undefined, formatting?: boolean): string {
+        if (!shortcutValue) {
+            return '-';
+        }
+        return shortcutValue
+            .split(/\+/g)
+            .map((part) => {
+                switch (part) {
+                    case 'Ctrl':
+                        return this.ctrlShortcutSymbol(formatting);
+                    case 'Alt':
+                        return this.altShortcutSymbol(formatting);
+                    case 'Shift':
+                        return this.shiftShortcutSymbol(formatting);
+                    case 'Meta':
+                        return this.actionShortcutSymbol(formatting);
+                    default:
+                        return part;
+                }
+            })
+            .join('');
+    },
+
+    actionShortcutSymbol(formatting?: boolean): string {
+        return Features.isMac ? '⌘' : this.formatShortcut(Locale.ctrlKey, formatting);
+    },
+
+    altShortcutSymbol(formatting?: boolean): string {
+        return Features.isMac ? '⌥' : this.formatShortcut(Locale.altKey, formatting);
+    },
+
+    shiftShortcutSymbol(formatting?: boolean): string {
+        return Features.isMac ? '⇧' : this.formatShortcut(Locale.shiftKey, formatting);
+    },
+
+    ctrlShortcutSymbol(formatting?: boolean): string {
+        return Features.isMac ? '⌃' : this.formatShortcut(Locale.ctrlKey, formatting);
+    },
+
+    formatShortcut(shortcut: string, formatting?: boolean): string {
+        return formatting ? `${shortcut} + ` : `${shortcut}+`;
+    },
+
+    globalShortcutText(type: GlobalShortcutType, formatting?: boolean): string {
+        return this.presentShortcut(this.globalShortcut(type), formatting);
+    },
+
+    globalShortcut(type: GlobalShortcutType): string | undefined {
+        const setting = GlobalShortcutAppSettingsFields[type];
+        const appSettingsShortcut = AppSettings[setting];
+        if (typeof appSettingsShortcut === 'string') {
+            return appSettingsShortcut;
+        }
+        const globalShortcut = AllGlobalShortcuts[type];
+        if (globalShortcut) {
+            if (Features.isMac && globalShortcut.mac) {
+                return globalShortcut.mac;
+            }
+            return globalShortcut.all;
+        }
+        return undefined;
+    },
+
+    setGlobalShortcut(type: GlobalShortcutType, value: string | null): void {
+        if (!AllGlobalShortcuts[type]) {
+            throw new Error('Bad shortcut: ' + type);
+        }
+        const setting = GlobalShortcutAppSettingsFields[type];
+        if (value) {
+            AppSettings.set(setting, value);
+        } else {
+            AppSettings.delete(setting);
+        }
+        Launcher?.ipcRenderer.invoke('set-global-shortcuts', { [setting]: value });
+    },
+
+    screenshotToClipboardShortcut(): string {
+        if (Features.isiOS) {
+            return 'Sleep+Home';
+        }
+        if (Features.isMobile) {
+            return '';
+        }
+        if (Features.isMac) {
+            return 'Command-Shift-Control-4';
+        }
+        if (Features.isWindows) {
+            return 'Alt+PrintScreen';
+        }
+        return '';
+    }
+};
+
+export { Shortcuts };