Bump version

Avoid page reload when triggering actions in bookmark list (#506 )
* Extract bookmark view contexts * Implement basic partial updates for bookmark list and tag cloud * Refactor confirm button JS into web component * Refactor bulk edit JS into web component * Refactor tag autocomplete JS into web component * Refactor bookmark page JS into web component * Refactor global shortcuts JS into web component * Update tests * Add E2E test for partial updates * Add partial updates for archived bookmarks * Add partial updates for shared bookmarks * Cleanup helpers * Improve naming in bulk edit * Refactor shared components into behaviors * Refactor bulk edit components into behaviors * Refactor bookmark list components into behaviors * Update tests * Combine all scripts into bundle * Fix E2E CI
2025-08-15 14:39:24 +02:00 · 2023-08-22 07:51:08 +02:00 · 2023-08-21 23:12:00 +02:00 · 2023-08-20 11:44:53 +02:00 · 2023-08-15 16:49:58 +02:00 · 2023-08-15 00:20:52 +02:00
222 changed files with 12752 additions and 2547 deletions
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -0,0 +1,29 @@
 // For format details, see https://aka.ms/devcontainer.json. For config options, see the
 // README at: https://github.com/devcontainers/templates/tree/main/src/python
 {
 	"name": "Python 3",
 	"image": "mcr.microsoft.com/devcontainers/python:0-3.10",
 	"features": {
 		"ghcr.io/devcontainers/features/node:1": {}
 	},
 	// Features to add to the dev container. More info: https://containers.dev/features.
 	// "features": {},
 	// Use 'forwardPorts' to make a list of ports inside the container available locally.
 	"forwardPorts": [8000],
 	// Use 'postCreateCommand' to run commands after the container is created.
 	"postCreateCommand": "pip3 install --user -r requirements.txt && npm install && mkdir -p data && python3 manage.py migrate",
 	// Configure tool-specific properties.
 	"customizations": {
 		"vscode": {
 			"extensions": [
 				"ms-python.python"
 			]
 		}
 	},
 	"remoteUser": "vscode"
 }
--- a/.dockerignore
+++ b/.dockerignore
@@ -6,10 +6,15 @@
 /tmp
 /docs
 /static
 /scripts
 /build
 /out
 /.git
 /.devcontainer
 /.dockerignore
 /.gitignore
 /.gitattributes
 /Dockerfile
 /docker-compose.yml
 /*.sh
@@ -17,10 +22,13 @@
 /*.patch
 /*.md
 /*.js
 /*.log
 /*.pid
 # Whitelist files needed in build or prod image
 !/rollup.config.js
 !/bootstrap.sh
 !/background-tasks-wrapper.sh
 # Remove development settings
 /siteroot/settings/dev.py
--- a/.env.sample
+++ b/.env.sample
@@ -5,5 +5,45 @@ LD_HOST_PORT=9090
 # Directory on the host system that should be mounted as data dir into the Docker container
 LD_HOST_DATA_DIR=./data
 # Can be used to run linkding under a context path, for example: linkding/
 # Must end with a slash `/`
 LD_CONTEXT_PATH=
 # Username of the initial superuser to create, leave empty to not create one
 LD_SUPERUSER_NAME=
 # Password for the initial superuser, leave empty to disable credentials authentication and rely on proxy authentication instead
 LD_SUPERUSER_PASSWORD=
 # Option to disable background tasks
 LD_DISABLE_BACKGROUND_TASKS=False
 # Option to disable URL validation for bookmarks completely
-LD_DISABLE_URL_VALIDATION=False
+LD_DISABLE_URL_VALIDATION=False
 # Enables support for authentication proxies such as Authelia
 LD_ENABLE_AUTH_PROXY=False
 # Name of the request header that the auth proxy passes to the application to identify the user
 # See docs/Options.md for more details
 LD_AUTH_PROXY_USERNAME_HEADER=
 # The URL that linkding should redirect to after a logout, when using an auth proxy
 # See docs/Options.md for more details
 LD_AUTH_PROXY_LOGOUT_URL=
 # List of trusted origins from which to accept POST requests
 # See docs/Options.md for more details
 LD_CSRF_TRUSTED_ORIGINS=
 # Database settings
 # These are currently only required for configuring PostreSQL.
 # By default, linkding uses SQLite for which you don't need to configure anything.
 # Database engine, can be sqlite (default) or postgres
 LD_DB_ENGINE=
 # Database name (default: linkding)
 LD_DB_DATABASE=
 # Username to connect to the database server  (default: linkding)
 LD_DB_USER=
 # Password to connect to the database server
 LD_DB_PASSWORD=
 # The hostname where the database is hosted (default: localhost)
 LD_DB_HOST=
 # Port use to connect to the database server
 # Should use the default port if not set
 LD_DB_PORT=
 # Any additional options to pass to the database (default: {})
 LD_DB_OPTIONS=
--- a/.gitattributes
+++ b/.gitattributes
@@ -0,0 +1,2 @@
 * text=auto
 *.sh text eol=lf
--- a/.github/workflows/main.yaml
+++ b/.github/workflows/main.yaml
@@ -3,22 +3,48 @@ name: linkding CI
 on: [push]
 jobs:
-  run_tests:
+  unit_tests:
-    name: Run Django Tests
+    name: Unit Tests
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v1
+      - uses: actions/checkout@v3
      - name: Set up Python
-        uses: actions/setup-python@v1
+        uses: actions/setup-python@v4
        with:
-          python-version: 3.7
+          python-version: "3.10"
      - name: Set up Node
-        uses: actions/setup-node@v2
+        uses: actions/setup-node@v3
        with:
-          node-version: 14
+          node-version: 18
      - name: Install Python dependencies
        run: pip install -r requirements.txt
      - name: Install Node dependencies
        run: npm install
      - name: Setup Python environment
        run: pip install -r requirements.txt
      - name: Run tests
-        run: python manage.py test
+        run: python manage.py test bookmarks.tests
  e2e_tests:
    name: E2E Tests
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: "3.10"
      - name: Set up Node
        uses: actions/setup-node@v3
        with:
          node-version: 18
      - name: Install Node dependencies
        run: npm install
      - name: Setup Python environment
        run: |
          pip install -r requirements.txt
          playwright install chromium
      - name: Run build
        run: |
          npm run build
          python manage.py compilescss
          python manage.py collectstatic --ignore=*.scss
      - name: Run tests
        run: python manage.py test bookmarks.e2e --pattern="e2e_test_*.py"
--- a/.gitignore
+++ b/.gitignore
@@ -3,55 +3,14 @@
 # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
 # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
 # User-specific stuff
 .idea/**/workspace.xml
 .idea/**/tasks.xml
 .idea/**/dictionaries
 .idea/**/shelf
 # Sensitive or high-churn files
 .idea/**/dataSources/
 .idea/**/dataSources.ids
 .idea/**/dataSources.local.xml
 .idea/**/sqlDataSources.xml
 .idea/**/dynamic.xml
 .idea/**/uiDesigner.xml
 .idea/**/dbnavigator.xml
 # Gradle
 .idea/**/gradle.xml
 .idea/**/libraries
 # CMake
 cmake-build-debug/
 cmake-build-release/
 # Mongo Explorer plugin
 .idea/**/mongoSettings.xml
 # File-based project format
 *.iws
 # IntelliJ
 .idea
 *.iml
 out/
 # mpeltonen/sbt-idea plugin
 .idea_modules/
 # JIRA plugin
 atlassian-ide-plugin.xml
 # Cursive Clojure plugin
 .idea/replstate.xml
 # Crashlytics plugin (for Android Studio and IntelliJ)
 com_crashlytics_export_strings.xml
 crashlytics.properties
 crashlytics-build.properties
 fabric.properties
 # Editor-based Rest Client
 .idea/httpRequests
 ### Python template
 # Byte-compiled / optimized / DLL files
 __pycache__/
@@ -223,7 +182,9 @@ typings/
 ### Custom
 # Rollup compilation output
-/build
+/bookmarks/static/bundle.js*
 # SASS compilation output
 /bookmarks/static/theme-*.css*
 # Collected static files for deployment
 /static
 # Build output, etc.
--- a/.grenrc.js
+++ b/.grenrc.js
@@ -1,6 +0,0 @@
 module.exports = {
    ignoreIssuesWith: [
        "wontfix",
        "duplicate"
    ]
 }
--- a/.idea/codeStyles/codeStyleConfig.xml
+++ b/.idea/codeStyles/codeStyleConfig.xml
@@ -1,5 +0,0 @@
 <component name="ProjectCodeStyleConfiguration">
  <state>
    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
  </state>
 </component>
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -1,15 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="CompilerConfiguration">
    <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" />
    </wildcardResourcePatterns>
  </component>
 </project>
--- a/.idea/dataSources.xml
+++ b/.idea/dataSources.xml
@@ -1,11 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="DataSourceManagerImpl" format="xml" multifile-model="true">
    <data-source source="LOCAL" name="SQLite - db.sqlite3" uuid="c880bd6d-554c-484d-a5be-45581d9a9377">
      <driver-ref>sqlite.xerial</driver-ref>
      <synchronize>true</synchronize>
      <jdbc-driver>org.sqlite.JDBC</jdbc-driver>
      <jdbc-url>jdbc:sqlite:$PROJECT_DIR$/data/db.sqlite3</jdbc-url>
    </data-source>
  </component>
 </project>
--- a/.idea/encodings.xml
+++ b/.idea/encodings.xml
@@ -1,4 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="Encoding" addBOMForNewFiles="with NO BOM" />
 </project>
--- a/.idea/inspectionProfiles/Project_Default.xml
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -1,12 +0,0 @@
 <component name="InspectionProjectProfileManager">
  <profile version="1.0">
    <option name="myName" value="Project Default" />
    <inspection_tool class="PyPep8Inspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
      <option name="ignoredErrors">
        <list>
          <option value="E402" />
        </list>
      </option>
    </inspection_tool>
  </profile>
 </component>
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,13 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="HaskellBuildOptions">
    <ghcPath>/usr/local/bin/ghc</ghcPath>
    <stackPath>/usr/local/bin/stack</stackPath>
  </component>
  <component name="JavaScriptSettings">
    <option name="languageLevel" value="ES6" />
  </component>
  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_6" default="false" project-jdk-name="Python 3.7 (linkding)" project-jdk-type="Python SDK">
    <output url="file://$PROJECT_DIR$/out" />
  </component>
 </project>
--- a/.idea/modules.xml
+++ b/.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$/linkdings.iml" filepath="$PROJECT_DIR$/linkdings.iml" />
    </modules>
  </component>
 </project>
--- a/.idea/vcs.xml
+++ b/.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>
--- a/.idea/watcherTasks.xml
+++ b/.idea/watcherTasks.xml
@@ -1,4 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="ProjectTasksOptions" suppressed-tasks="SCSS" />
 </project>
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,16 +1,382 @@
 # Changelog
 ## v1.19.0 (20/05/2023)
 ### What's Changed
 * Add notes to bookmarks by @sissbruecker in https://github.com/sissbruecker/linkding/pull/472
 **Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.18.0...v1.19.0
 ---
 ## v1.18.0 (18/05/2023)
 ### What's Changed
 * Make search case-insensitive on Postgres by @sissbruecker in https://github.com/sissbruecker/linkding/pull/432
 * Allow searching for tags without hash character by @sissbruecker in https://github.com/sissbruecker/linkding/pull/449
 * Prevent zoom-in after focusing an input on small viewports on iOS devices by @puresick in https://github.com/sissbruecker/linkding/pull/440
 * Add database options by @plockaby in https://github.com/sissbruecker/linkding/pull/406
 * Allow to log real client ip in logs when using a reverse proxy by @fmenabe in https://github.com/sissbruecker/linkding/pull/398
 * Add option to display URL below title by @bah0 in https://github.com/sissbruecker/linkding/pull/365
 * Add LinkThing iOS app to community section by @amoscardino in https://github.com/sissbruecker/linkding/pull/446
 * Bump django from 4.1.7 to 4.1.9 by @dependabot in https://github.com/sissbruecker/linkding/pull/466
 * Bump sqlparse from 0.4.2 to 0.4.4 by @dependabot in https://github.com/sissbruecker/linkding/pull/455
 ### New Contributors
 * @amoscardino made their first contribution in https://github.com/sissbruecker/linkding/pull/446
 * @puresick made their first contribution in https://github.com/sissbruecker/linkding/pull/440
 * @plockaby made their first contribution in https://github.com/sissbruecker/linkding/pull/406
 * @fmenabe made their first contribution in https://github.com/sissbruecker/linkding/pull/398
 * @bah0 made their first contribution in https://github.com/sissbruecker/linkding/pull/365
 **Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.17.2...v1.18.0
 ---
 ## v1.17.2 (18/02/2023)
 ### What's Changed
 * Escape texts in exported HTML by @sissbruecker in https://github.com/sissbruecker/linkding/pull/429
 * Bump django from 4.1.2 to 4.1.7 by @dependabot in https://github.com/sissbruecker/linkding/pull/427
 * Make health check in Dockerfile honor context path setting by @mrex in https://github.com/sissbruecker/linkding/pull/407
 * Disable autocapitalization for tag input form by @joshdick in https://github.com/sissbruecker/linkding/pull/395
 ### New Contributors
 * @mrex made their first contribution in https://github.com/sissbruecker/linkding/pull/407
 * @joshdick made their first contribution in https://github.com/sissbruecker/linkding/pull/395
 **Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.17.1...v1.17.2
 ---
 ## v1.17.1 (22/01/2023)
 ### What's Changed
 * Fix favicon being cleared by web archive snapshot task by @sissbruecker in https://github.com/sissbruecker/linkding/pull/405
 **Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.17.0...v1.17.1
 ---
 ## v1.17.0 (21/01/2023)
 ### What's Changed
 * Add Health Check endpoint  by @mckennajones in https://github.com/sissbruecker/linkding/pull/392
 * Cache website metadata to avoid duplicate scraping by @sissbruecker in https://github.com/sissbruecker/linkding/pull/401
 * Prefill form if URL is already bookmarked by @sissbruecker in https://github.com/sissbruecker/linkding/pull/402
 * Add option for showing bookmark favicons by @sissbruecker in https://github.com/sissbruecker/linkding/pull/390
 **Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.16.1...v1.17.0
 ---
 ## v1.16.1 (20/01/2023)
 ### What's Changed
 * Fix bookmark website metadata not being updated when URL changes by @sissbruecker in https://github.com/sissbruecker/linkding/pull/400
 * Bump django from 4.1 to 4.1.2 by @dependabot in https://github.com/sissbruecker/linkding/pull/391
 * Bump certifi from 2022.6.15 to 2022.12.7 by @dependabot in https://github.com/sissbruecker/linkding/pull/374
 * Bump minimatch from 3.0.4 to 3.1.2 by @dependabot in https://github.com/sissbruecker/linkding/pull/366
 **Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.16.0...v1.16.1
 ---
 ## v1.16.0 (12/01/2023)
 ### What's Changed
 * Add postgres as database engine by @tomamplius in https://github.com/sissbruecker/linkding/pull/388
 * Gracefully stop docker container when it receives SIGTERM by @mckennajones in https://github.com/sissbruecker/linkding/pull/368
 * Limit document size for website scraper by @sissbruecker in https://github.com/sissbruecker/linkding/pull/354
 * Add error handling for checking latest version by @sissbruecker in https://github.com/sissbruecker/linkding/pull/360
 * Trim website metadata title and description by @luca1197 in https://github.com/sissbruecker/linkding/pull/383
 * Only show admin link for superusers by @AlexanderS in https://github.com/sissbruecker/linkding/pull/384
 * Add apache reverse proxy documentation. by @jhauris in https://github.com/sissbruecker/linkding/pull/371
 * Correct LD_ENABLE_AUTH_PROXY documentation by @jhauris in https://github.com/sissbruecker/linkding/pull/379
 * Android HTTP shortcuts v3 by @kzshantonu in https://github.com/sissbruecker/linkding/pull/387
 ### New Contributors
 * @jhauris made their first contribution in https://github.com/sissbruecker/linkding/pull/371
 * @AlexanderS made their first contribution in https://github.com/sissbruecker/linkding/pull/384
 * @mckennajones made their first contribution in https://github.com/sissbruecker/linkding/pull/368
 * @tomamplius made their first contribution in https://github.com/sissbruecker/linkding/pull/388
 * @luca1197 made their first contribution in https://github.com/sissbruecker/linkding/pull/383
 **Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.15.1...v1.16.0
 ---
 ## v1.15.1 (05/10/2022)
 ### What's Changed
 * Fix static file dir warning by @sissbruecker in https://github.com/sissbruecker/linkding/pull/350
 * Add setting and documentation for fixing CSRF errors by @sissbruecker in https://github.com/sissbruecker/linkding/pull/349
 **Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.15.0...v1.15.1
 ---
 ## v1.15.0 (11/09/2022)
 ### What's Changed
 * Bump Django and other dependencies by @sissbruecker in https://github.com/sissbruecker/linkding/pull/331
 * Add option to create initial superuser by @sissbruecker in https://github.com/sissbruecker/linkding/pull/323
 * Improved Android HTTP Shortcuts doc by @kzshantonu in https://github.com/sissbruecker/linkding/pull/330
 * Minify bookmark list HTML by @sissbruecker in https://github.com/sissbruecker/linkding/pull/332
 * Bump python version to 3.10 by @sissbruecker in https://github.com/sissbruecker/linkding/pull/333
 * Fix error when deleting all bookmarks in admin by @sissbruecker in https://github.com/sissbruecker/linkding/pull/336
 * Improve bookmark query performance by @sissbruecker in https://github.com/sissbruecker/linkding/pull/334
 * Prevent rate limit errors in wayback machine API by @sissbruecker in https://github.com/sissbruecker/linkding/pull/339
 **Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.14.0...v1.15.0
 ---
 ## v1.14.0 (14/08/2022)
 ### What's Changed
 * Add support for context path by @s2marine in https://github.com/sissbruecker/linkding/pull/313
 * Add support for authentication proxies by @sissbruecker in https://github.com/sissbruecker/linkding/pull/321
 * Add bookmark list keyboard navigation by @sissbruecker in https://github.com/sissbruecker/linkding/pull/320
 * Skip updating website metadata on edit unless URL has changed by @sissbruecker in https://github.com/sissbruecker/linkding/pull/318
 * Add simple docs of the new `shared` API parameter by @bachya in https://github.com/sissbruecker/linkding/pull/312
 * Add project linka to community section in README by @cmsax in https://github.com/sissbruecker/linkding/pull/319
 * Order tags in test_should_create_new_bookmark by @RoGryza in https://github.com/sissbruecker/linkding/pull/310
 * Bump django from 3.2.14 to 3.2.15 by @dependabot in https://github.com/sissbruecker/linkding/pull/316
 ### New Contributors
 * @s2marine made their first contribution in https://github.com/sissbruecker/linkding/pull/313
 * @RoGryza made their first contribution in https://github.com/sissbruecker/linkding/pull/310
 * @cmsax made their first contribution in https://github.com/sissbruecker/linkding/pull/319
 **Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.13.0...v1.14.0
 ---
 ## v1.13.0 (04/08/2022)
 ### What's Changed
 * Add bookmark sharing by @sissbruecker in https://github.com/sissbruecker/linkding/pull/311
 * Display selected tags in tag cloud by @sissbruecker and @jhauris in https://github.com/sissbruecker/linkding/pull/307
 * Update unread flag when saving duplicate URL by @sissbruecker in https://github.com/sissbruecker/linkding/pull/306
 **Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.12.0...v1.13.0
 ---
 ## v1.12.0 (23/07/2022)
 ### What's Changed
 * Add read it later functionality by @sissbruecker in https://github.com/sissbruecker/linkding/pull/304
 * Add RSS feeds by @sissbruecker in https://github.com/sissbruecker/linkding/pull/305
 * Add bookmarklet to community by @ukcuddlyguy in https://github.com/sissbruecker/linkding/pull/293
 * Shorten and simplify example bookmarklet in documentation by @FunctionDJ in https://github.com/sissbruecker/linkding/pull/297
 * Fix typo by @kianmeng in https://github.com/sissbruecker/linkding/pull/295
 * Bump django from 3.2.13 to 3.2.14 by @dependabot in https://github.com/sissbruecker/linkding/pull/294
 * Bump svelte from 3.46.4 to 3.49.0 by @dependabot in https://github.com/sissbruecker/linkding/pull/299
 * Bump terser from 5.5.1 to 5.14.2 by @dependabot in https://github.com/sissbruecker/linkding/pull/302
 ### New Contributors
 * @ukcuddlyguy made their first contribution in https://github.com/sissbruecker/linkding/pull/293
 * @FunctionDJ made their first contribution in https://github.com/sissbruecker/linkding/pull/297
 * @kianmeng made their first contribution in https://github.com/sissbruecker/linkding/pull/295
 **Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.11.1...v1.12.0
 ---
 ## v1.11.1 (03/07/2022)
 ### What's Changed
 * Fix duplicate tags on import by @wahlm in https://github.com/sissbruecker/linkding/pull/289
 * Add apple-touch-icon by @daveonkels in https://github.com/sissbruecker/linkding/pull/282
 * Bump waybackpy to 3.0.6 by @dustinblackman in https://github.com/sissbruecker/linkding/pull/281
 ### New Contributors
 * @wahlm made their first contribution in https://github.com/sissbruecker/linkding/pull/289
 * @daveonkels made their first contribution in https://github.com/sissbruecker/linkding/pull/282
 * @dustinblackman made their first contribution in https://github.com/sissbruecker/linkding/pull/281
 **Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.11.0...v1.11.1
 ---
 ## v1.11.0 (26/05/2022)
 ### What's Changed
 * Add background tasks to admin by @sissbruecker in https://github.com/sissbruecker/linkding/pull/264
 * Improve about section by @sissbruecker in https://github.com/sissbruecker/linkding/pull/265
 * Allow creating archived bookmark through REST API by @kencx in https://github.com/sissbruecker/linkding/pull/268
 * Add PATCH support to bookmarks endpoint by @sissbruecker in https://github.com/sissbruecker/linkding/pull/269
 * Add community reference to linkding-cli by @bachya in https://github.com/sissbruecker/linkding/pull/270
 ### New Contributors
 * @kencx made their first contribution in https://github.com/sissbruecker/linkding/pull/268
 **Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.10.1...v1.11.0
 ---
 ## v1.10.1 (21/05/2022)
 ### What's Changed
 * Fake request headers to reduce bot detection by @sissbruecker in https://github.com/sissbruecker/linkding/pull/263
 **Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.10.0...v1.10.1
 ---
 ## v1.10.0 (21/05/2022)
 ### What's Changed
 * Add to managed hosting options by @m3nu in https://github.com/sissbruecker/linkding/pull/253
 * Add community reference to aiolinkding by @bachya in https://github.com/sissbruecker/linkding/pull/259
 * Improve import performance by @sissbruecker in https://github.com/sissbruecker/linkding/pull/261
 * Update how-to.md to fix unclear/paraphrased Safari action in IOS Shortcuts by @feoh in https://github.com/sissbruecker/linkding/pull/260
 * Allow searching for untagged bookmarks by @sissbruecker in https://github.com/sissbruecker/linkding/pull/226
 ### New Contributors
 * @m3nu made their first contribution in https://github.com/sissbruecker/linkding/pull/253
 * @bachya made their first contribution in https://github.com/sissbruecker/linkding/pull/259
 * @feoh made their first contribution in https://github.com/sissbruecker/linkding/pull/260
 **Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.9.0...v1.10.0
 ---
 ## v1.9.0 (14/05/2022)
 ### What's Changed
 * Scroll menu items into view when using keyboard by @sissbruecker in https://github.com/sissbruecker/linkding/pull/248
 * Add whitespace after auto-completed tag by @sissbruecker in https://github.com/sissbruecker/linkding/pull/249
 * Bump django from 3.2.12 to 3.2.13 by @dependabot in https://github.com/sissbruecker/linkding/pull/244
 * Add community helm chart reference to readme by @pascaliske in https://github.com/sissbruecker/linkding/pull/242
 * Feature: Shortcut key for new bookmark by @rithask in https://github.com/sissbruecker/linkding/pull/241
 * Clarify archive.org feature by @clach04 in https://github.com/sissbruecker/linkding/pull/229
 * Make Internet Archive integration opt-in by @sissbruecker in https://github.com/sissbruecker/linkding/pull/250
 ### New Contributors
 * @pascaliske made their first contribution in https://github.com/sissbruecker/linkding/pull/242
 * @rithask made their first contribution in https://github.com/sissbruecker/linkding/pull/241
 * @clach04 made their first contribution in https://github.com/sissbruecker/linkding/pull/229
 **Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.8.8...v1.9.0
 ---
 ## v1.8.8 (27/03/2022)
 - [**bug**] Prevent bookmark actions through get requests
 - [**bug**] Prevent external redirects
 ---
 ## v1.8.7 (26/03/2022)
 - [**bug**] Increase request buffer size [#28](https://github.com/sissbruecker/linkding/issues/28)
 - [**enhancement**]  Allow specifying port through LINKDING_PORT environment variable [#156](https://github.com/sissbruecker/linkding/pull/156)
 - [**chore**] Bump NPM packages [#224](https://github.com/sissbruecker/linkding/pull/224)
 ---
 ## v1.8.6 (25/03/2022)
 - [bug] fix bookmark access restrictions
 - [bug] prevent external redirects
 - [chore] bump dependencies
 ---
 ## v1.8.5 (12/12/2021)
 - [**bug**] Ensure tag names do not contain spaces [#182](https://github.com/sissbruecker/linkding/issues/182)
 - [**bug**] Consider not copying whole GIT repository to Docker image [#174](https://github.com/sissbruecker/linkding/issues/174)
 - [**enhancement**] Make bookmarks count column in admin sortable [#183](https://github.com/sissbruecker/linkding/pull/183)
 ---
 ## v1.8.4 (16/10/2021)
 - [**enhancement**] Allow non-admin users to change their password [#166](https://github.com/sissbruecker/linkding/issues/166)
 ---
 ## v1.8.3 (03/10/2021)
 - [**enhancement**] Enhancement: let user configure to open links in same tab instead on a new window/tab [#27](https://github.com/sissbruecker/linkding/issues/27)
 ---
 ## v1.8.2 (02/10/2021)
 - [**bug**] Fix jumping search box [#163](https://github.com/sissbruecker/linkding/pull/163)
 ---
 ## v1.8.1 (01/10/2021)
 - [**enhancement**] Add global shortcut for search [#161](https://github.com/sissbruecker/linkding/pull/161)
  - allows to press `s` to focus the search input
 ---
 ## v1.8.0 (04/09/2021)
 - [**enhancement**] Wayback Machine Integration [#59](https://github.com/sissbruecker/linkding/issues/59)
  - Automatically creates snapshots of bookmarked websites on [web archive](https://archive.org/web/)
  - This is one of the largest changes yet and adds a task processor that runs as a separate process in the background. If you run into issues with this feature, it can be disabled using the [LD_DISABLE_BACKGROUND_TASKS](https://github.com/sissbruecker/linkding/blob/master/docs/Options.md#ld_disable_background_tasks) option
 ---
 ## v1.7.2 (26/08/2021)
 - [**enhancement**] Add support for nanosecond resolution timestamps for bookmark import (e.g. Google Bookmarks) [#146](https://github.com/sissbruecker/linkding/issues/146)
 ---
 ## v1.7.1 (25/08/2021)
 - [**bug**] umlaut/non-ascii characters broken when using bookmarklet (firefox) [#148](https://github.com/sissbruecker/linkding/issues/148)
 - [**bug**] Bookmark import accepts empty URL values [#124](https://github.com/sissbruecker/linkding/issues/124)
 - [**enhancement**] Show the version in the settings [#104](https://github.com/sissbruecker/linkding/issues/104)
 ---
 ## v1.7.0 (17/08/2021)
 - Upgrade to Django 3
 - Bump other dependencies
 ---
 ## v1.6.5 (15/08/2021)
 - [**enhancement**] query with multiple hashtags very slow [#112](https://github.com/sissbruecker/linkding/issues/112)
 ---
 ## v1.6.4 (13/05/2021)
 - Update dependencies for security fixes
 ---
-## v1.6.3 (07/04/2021)
+## v1.6.3 (06/04/2021)
 - [**bug**] relative names use the wrong "today" after day change [#107](https://github.com/sissbruecker/linkding/issues/107)
 ---
 ## v1.6.2 (04/04/2021)
 - [**enhancement**] Expose `date_added` in UI [#85](https://github.com/sissbruecker/linkding/issues/85)
 - [**closed**] Archived bookmarks - no result when searching for a word which is used only as tag [#83](https://github.com/sissbruecker/linkding/issues/83)
 - [**closed**] Add archive/unarchive button to edit bookmark page [#82](https://github.com/sissbruecker/linkding/issues/82)
@@ -19,46 +385,57 @@
 ---
 ## v1.6.1 (31/03/2021)
 - Expose date_added in UI [#85](https://github.com/sissbruecker/linkding/issues/85)
 ---
-## v1.6.0 (29/03/2021)
+## v1.6.0 (28/03/2021)
 - Bulk edit mode [#101](https://github.com/sissbruecker/linkding/pull/101)
 ---
 ## v1.5.0 (28/03/2021)
 - [**closed**] Add a dark mode [#49](https://github.com/sissbruecker/linkding/issues/49)
 ---
 ## v1.4.1 (20/03/2021)
- Security patches
+
 - Security patches
 - Documentation improvements
 ---
 ## v1.4.0 (24/02/2021)
 - [**enhancement**] Improve admin utilization [#76](https://github.com/sissbruecker/linkding/issues/76)
 ---
 ## v1.3.3 (18/02/2021)
 - [**closed**] Missing "description" request body parameter in API causes 500 [#78](https://github.com/sissbruecker/linkding/issues/78)
 ---
 ## v1.3.2 (18/02/2021)
 - [**closed**] /archive and /unarchive API routes return 404 [#77](https://github.com/sissbruecker/linkding/issues/77)
 - [**closed**] API - /api/check_url?url= with token authetification [#55](https://github.com/sissbruecker/linkding/issues/55)
 ---
 ## v1.3.1 (15/02/2021)
 [enhancement] Enhance delete links with inline confirmation
 ---
 ## v1.3.0 (14/02/2021)
 - [**closed**] Novice help. [#71](https://github.com/sissbruecker/linkding/issues/71)
 - [**closed**] Option to create bookmarks public [#70](https://github.com/sissbruecker/linkding/issues/70)
 - [**enhancement**] Show URL if title is not available [#64](https://github.com/sissbruecker/linkding/issues/64)
@@ -70,27 +447,34 @@
 ---
 ## v1.2.1 (12/01/2021)
 - [**bug**] Bug: Two equal tags with different capitalisation lead to 500 server errors [#65](https://github.com/sissbruecker/linkding/issues/65)
 - [**closed**] Enhancement: category and pagination [#11](https://github.com/sissbruecker/linkding/issues/11)
 ---
 ## v1.2.0 (09/01/2021)
 - [**closed**] Add Favicon [#58](https://github.com/sissbruecker/linkding/issues/58)
 - [**closed**] Make tags case-insensitive [#45](https://github.com/sissbruecker/linkding/issues/45)
 ---
 ## v1.1.1 (01/01/2021)
 - [**enhancement**] Add docker-compose support [#54](https://github.com/sissbruecker/linkding/pull/54)
 ---
 ## v1.1.0 (31/12/2020)
- [**enhancement**] Search autocomplete [#52](https://github.com/sissbruecker/linkding/issues/52)
+
 - [**enhancement**] Search autocomplete [#52](https://github.com/sissbruecker/linkding/issues/52)
 - [**enhancement**] Improve Netscape bookmarks file parsing [#50](https://github.com/sissbruecker/linkding/issues/50)
 ---
 ## v1.0.0 (31/12/2020)
 - [**bug**] Import does not import bookmark descriptions [#47](https://github.com/sissbruecker/linkding/issues/47)
 - [**enhancement**] Enhancement: return to same page we were on after editing a bookmark [#26](https://github.com/sissbruecker/linkding/issues/26)
 - [**bug**] Increase limit on bookmark URL length [#25](https://github.com/sissbruecker/linkding/issues/25)
@@ -99,4 +483,4 @@
 - [**bug**] Error importing bookmarks [#18](https://github.com/sissbruecker/linkding/issues/18)
 - [**enhancement**] Enhancement: better administration page [#4](https://github.com/sissbruecker/linkding/issues/4)
 - [**enhancement**] Bug: Navigation bar active link stays on add bookmark [#3](https://github.com/sissbruecker/linkding/issues/3)
- [**bug**] CSS Stylesheet presented as text/plain [#2](https://github.com/sissbruecker/linkding/issues/2)
+- [**bug**] CSS Stylesheet presented as text/plain [#2](https://github.com/sissbruecker/linkding/issues/2)
--- a/16
+++ b/16
@@ -1,4 +1,4 @@
-FROM node:current-alpine AS node-build
+FROM node:18.13.0-alpine AS node-build
 WORKDIR /etc/linkding
 # install build dependencies
 COPY package.json package-lock.json ./
@@ -9,8 +9,8 @@ COPY . .
 RUN npm run build
-FROM python:3.9-slim AS python-base
+FROM python:3.10.6-slim-buster AS python-base
-RUN apt-get update && apt-get -y install build-essential
+RUN apt-get update && apt-get -y install build-essential libpq-dev
 WORKDIR /etc/linkding
@@ -33,8 +33,8 @@ RUN mkdir /opt/venv && \
    /opt/venv/bin/pip install -Ur requirements.txt
-FROM python:3.9-slim as final
+FROM python:3.10.6-slim-buster as final
-RUN apt-get update && apt-get -y install mime-support
+RUN apt-get update && apt-get -y install mime-support libpq-dev curl
 WORKDIR /etc/linkding
 # copy prod dependencies
 COPY --from=prod-deps /opt/venv /opt/venv
@@ -47,6 +47,12 @@ EXPOSE 9090
 # Activate virtual env
 ENV VIRTUAL_ENV /opt/venv
 ENV PATH /opt/venv/bin:$PATH
 # Allow running containers as an an arbitrary user in the root group, to support deployment scenarios like OpenShift, Podman
 RUN ["chmod", "g+w", "."]
 # Run bootstrap logic
 RUN ["chmod", "+x", "./bootstrap.sh"]
 HEALTHCHECK --interval=30s --retries=3 --timeout=1s \
 CMD curl -f http://localhost:${LD_SERVER_PORT:-9090}/${LD_CONTEXT_PATH}health || exit 1
 CMD ["./bootstrap.sh"]
--- a/README.md
+++ b/README.md
@@ -1,32 +1,53 @@
-#  linkding
+<div align="center">
    <br>
    <a href="https://github.com/sissbruecker/linkding">
        <img src="docs/header.svg" height="50">
    </a>
    <br>
 </div>
-*linkding* is a simple bookmark service that you can host yourself.
+## Overview
-It's designed be to be minimal, fast and easy to set up using Docker. 
+- [Introduction](#introduction)
 - [Installation](#installation)
    - [Using Docker](#using-docker)
    - [Using Docker Compose](#using-docker-compose)
    - [User Setup](#user-setup)
    - [Reverse Proxy Setup](#reverse-proxy-setup)
    - [Managed Hosting Options](#managed-hosting-options)
 - [Documentation](#documentation)
 - [Browser Extension](#browser-extension)
 - [Community](#community)
 - [Acknowledgements](#acknowledgements)
 - [Development](#development)
 ##  Introduction
 linkding is a bookmark manager that you can host yourself.
 It's designed be to be minimal, fast, and easy to set up using Docker.
 The name comes from:
 - *link* which is often used as a synonym for URLs and bookmarks in common language
- *Ding* which is german for *thing*
+- *Ding* which is German for thing
- ...so basically some thing for managing your links
+- ...so basically something for managing your links
 **Feature Overview:**
- Tags for organizing bookmarks
+- Clean UI optimized for readability
- Search by text or tags
+- Organize bookmarks with tags
 - Add notes using Markdown
 - Read it later functionality
 - Share bookmarks with other users
 - Bulk editing
- Bookmark archive
+- Automatically provides titles, descriptions and icons of bookmarked websites
- Automatically provides titles and descriptions from linked websites 
+- Automatically creates snapshots of bookmarked websites on [the Internet Archive Wayback Machine](https://archive.org/web/)
 - Import and export bookmarks in Netscape HTML format
- Extensions for [Firefox](https://addons.mozilla.org/de/firefox/addon/linkding-extension/) and [Chrome](https://chrome.google.com/webstore/detail/linkding-extension/beakmhbijpdhipnjhnclmhgjlddhidpe)
+- Extensions for [Firefox](https://addons.mozilla.org/de/firefox/addon/linkding-extension/) and [Chrome](https://chrome.google.com/webstore/detail/linkding-extension/beakmhbijpdhipnjhnclmhgjlddhidpe), as well as a bookmarklet
- Bookmarklet that should work in most browsers
+- Light and dark themes
 - Dark mode
 - Easy to set up using Docker
 - Uses SQLite as database
 - Works without Javascript
 - ...but has several UI enhancements when Javascript is enabled
 - REST API for developing 3rd party apps
 - Admin panel for user self-service and raw data access
 - Easy setup using Docker and a SQLite database, with PostgreSQL as an option
-**Demo:** https://demo.linkding.link/ (configured with open registration)
+**Demo:** https://demo.linkding.link/ ([see here](https://github.com/sissbruecker/linkding/issues/408) if you have trouble accessing it)
 **Screenshot:**
@@ -34,102 +55,160 @@ The name comes from:
 ## Installation
-The easiest way to run linkding is to use [Docker](https://docs.docker.com/get-started/).  The Docker image is compatible with ARM platforms, so it can be run on a Raspberry Pi.
+linkding is designed to be run with container solutions like [Docker](https://docs.docker.com/get-started/).
 The Docker image is compatible with ARM platforms, so it can be run on a Raspberry Pi.
-There is also the option to set up the installation manually which I do not support, but can give some pointers on below.
+By default, linkding uses SQLite as a database.
 Alternatively linkding supports PostgreSQL, see the [database options](docs/Options.md#LD_DB_ENGINE) for more information.
-###  Docker setup
+###  Using Docker
-To install linkding using Docker you can just run the image from the Docker registry:
+To install linkding using Docker you can just run the [latest image](https://hub.docker.com/repository/docker/sissbruecker/linkding) from Docker Hub:
 ```
 docker run --name linkding -p 9090:9090 -d sissbruecker/linkding:latest
 ```
 By default the application runs on port `9090`, but you can map it to a different host port by modifying the command above.
 However for **production use** you also want to mount a data folder on your system, so that the applications database is not stored in the container, but on your hosts file system. This is safer in case something happens to the container and makes it easier to update the container later on, or to run backups. To do so you can use the following extended command, where you replace `{host-data-folder}` with the absolute path to a folder on your system where you want to store the data:
 ```shell
 docker run --name linkding -p 9090:9090 -v {host-data-folder}:/etc/linkding/data -d sissbruecker/linkding:latest
 ```
-If everything completed successfully the application should now be running and can be accessed at http://localhost:9090, provided you did not change the port mapping. 
+In the command above, replace the `{host-data-folder}` placeholder with an absolute path to a folder on your host system where you want to store the linkding database.
-### Automated Docker setup
+If everything completed successfully, the application should now be running and can be accessed at http://localhost:9090.
-If you are using a Linux system you can use the following [shell script](https://github.com/sissbruecker/linkding/blob/master/install-linkding.sh) for an automated setup. The script does basically everything described above, but also handles updating an existing container to a new application version (technically replaces the existing container with a new container built from a newer image, while mounting the same data folder).
+To upgrade the installation to a new version, remove the existing container, pull the latest version of the linkding Docker image, and then start a new container using the same command that you used above. There is a [shell script](https://github.com/sissbruecker/linkding/blob/master/install-linkding.sh) available to automate these steps. The script can be configured using environment variables, or you can just modify it.
-The script can be configured using shell variables - for more details have a look at the script itself.
+To complete the setup, you still have to [create an initial user](#user-setup), so that you can access your installation.
-###  Docker-compose setup
+###  Using Docker Compose
-To install linkding using docker-compose you can use the `docker-compose.yml` file. Copy the `.env.sample` file to `.env` and set your parameters, then run:
+To install linkding using [Docker Compose](https://docs.docker.com/compose/), you can use the [`docker-compose.yml`](https://github.com/sissbruecker/linkding/blob/master/docker-compose.yml) file. Copy the [`.env.sample`](https://github.com/sissbruecker/linkding/blob/master/.env.sample) file to `.env`, configure the parameters, and then run:
 ```shell
 docker-compose up -d
 ```
 To complete the setup, you still have to [create an initial user](#user-setup), so that you can access your installation.
 ### User setup
-Finally you need to create a user so that you can access the application. Replace the credentials in the following command and run it:
+For security reasons, the linkding Docker image does not provide an initial user, so you have to create one after setting up an installation. To do so, replace the credentials in the following command and run it:
 **Docker**
 ```shell
 docker exec -it linkding python manage.py createsuperuser --username=joe --email=joe@example.com
 ```
-**Docker-compose**
+**Docker Compose**
 ```shell
 docker-compose exec linkding python manage.py createsuperuser --username=joe --email=joe@example.com
 ```
 The command will prompt you for a secure password. After the command has completed you can start using the application by logging into the UI with your credentials.
-### Manual setup
+Alternatively you can automatically create an initial superuser on startup using the [`LD_SUPERUSER_NAME` option](docs/Options.md#LD_SUPERUSER_NAME). 
-If you can not or don't want to use Docker you can install the application manually on your server. To do so you can basically follow the steps from the *Development* section below while cross-referencing the `Dockerfile` and `bootstrap.sh` on how to make the application production-ready.
+### Reverse Proxy Setup
-### Hosting
+When using a reverse proxy, such as Nginx or Apache, you may need to configure your proxy to correctly forward the `Host` header to linkding, otherwise certain requests, such as login, might fail.
-The application runs in a web-server called [uWSGI](https://uwsgi-docs.readthedocs.io/en/latest/) that is production-ready and that you can expose to the web. If you don't know how to configure your server to expose the application to the web there are several more steps involved. I can not support support the process here, but I can give some pointers on what to search for:
+<details>
- first get the app running (described in this document)
+<summary>Apache</summary>
 - open the port that the application is running on in your servers firewall
 - depending on your network configuration, forward the opened port in your network router, so that the application can be addressed from the internet using your public IP address and the opened port
-## Options
+Apache2 does not change the headers by default, and should not
 need additional configuration.
-Check the [options document](docs/Options.md) on how to configure your linkding installation.
+An example virtual host that proxies to linkding might look like:
 ```
 <VirtualHost *:9100>
    <Proxy *>
        Order deny,allow
        Allow from all
    </Proxy>
-## Administration
+    ProxyPass / http://linkding:9090/
    ProxyPassReverse / http://linkding:9090/
 </VirtualHost>
 ```
-Check the [administration document](docs/Admin.md) on how to use the admin app that is bundled with linkding.
+For a full example, see the docker-compose configuration in [jhauris/apache2-reverse-proxy](https://github.com/jhauris/linkding/tree/apache2-reverse-proxy)
-## Backups
+If you still run into CSRF issues, please check out the [`LD_CSRF_TRUSTED_ORIGINS` option](docs/Options.md#LD_CSRF_TRUSTED_ORIGINS).
-Check the [backups document](docs/backup.md) for options on how to create backups.
+</details>
-## How To
+<details>
 <summary>Caddy 2</summary>
-Check the [how-to document](docs/how-to.md) for tips and tricks around using linkding.
+Caddy does not change the headers by default, and should not need any further configuration.
-## API
+If you still run into CSRF issues, please check out the [`LD_CSRF_TRUSTED_ORIGINS` option](docs/Options.md#LD_CSRF_TRUSTED_ORIGINS).
-The application provides a REST API that can be used by 3rd party applications to manage bookmarks. Check the [API docs](docs/API.md) for further information.
+</details>
-## Troubleshooting
+<details>
 <summary>Nginx</summary>
-**Import fails with `502 Bad Gateway`**
+Nginx by default rewrites the `Host` header to whatever URL is used in the `proxy_pass` directive.
 To forward the correct headers to linkding, add the following directives to the location block of your Nginx config:
 ```
 location /linkding {
    ...
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-Proto $scheme;
 }
 ```
-The default timeout for requests is 60 seconds, after which the application server will cancel the request and return the above error.
+</details>
 Depending on the system that the application runs on, and the number of bookmarks that need to be imported, the import may take longer than the default 60 seconds.
-To increase the timeout you can configure the [`LD_REQUEST_TIMEOUT` option](Options.md#LD_REQUEST_TIMEOUT).
+Instead of configuring header forwarding in your proxy, you can also configure the URL from which you want to access your linkding instance with the  [`LD_CSRF_TRUSTED_ORIGINS` option](docs/Options.md#LD_CSRF_TRUSTED_ORIGINS).
-Note that any proxy servers that you are running in front of linkding may have their own timeout settings, which are not affected by the variable.
+### Managed Hosting Options
 Self-hosting web applications still requires a lot of technical know-how, and commitment to maintenance, with regard to keeping everything up-to-date and secure. This can be a huge entry barrier for people who are interested in self-hosting, but lack the technical knowledge to do so. This section is intended to provide alternatives in form of managed hosting solutions. Note that these options are usually commercial offerings, that require paying a fee for the convenience of being managed by another party. The technical knowledge required to make use of individual options is going to vary, and no guarantees can be made that every option is accessible for everyone. That being said, I hope this section helps in making the application accessible to a wider audience.
 - [linkding on fly.io](https://github.com/fspoettel/linkding-on-fly) - Guide for hosting a linkding installation on [fly.io](https://fly.io). By [fspoettel](https://github.com/fspoettel)
 - [PikaPods.com](https://www.pikapods.com/) - Managed hosting for linkding, EU and US regions available. [1-click setup link](https://www.pikapods.com/pods?run=linkding)
 ## Documentation
 | Document                                                                                        | Description                                              |
 |-------------------------------------------------------------------------------------------------|----------------------------------------------------------|
 | [Options](https://github.com/sissbruecker/linkding/blob/master/docs/Options.md)                 | Lists available options, and describes how to apply them |
 | [Backups](https://github.com/sissbruecker/linkding/blob/master/docs/backup.md)                  | How to backup the linkding database                      |
 | [Troubleshooting](https://github.com/sissbruecker/linkding/blob/master/docs/troubleshooting.md) | Advice for troubleshooting common problems               |
 | [How To](https://github.com/sissbruecker/linkding/blob/master/docs/how-to.md)                   | Tips and tricks around using linking                     |
 | [Keyboard shortcuts](https://github.com/sissbruecker/linkding/blob/master/docs/shortcuts.md)    | List of available keyboard shortcuts                     |
 | [Admin documentation](https://github.com/sissbruecker/linkding/blob/master/docs/Admin.md)       | User documentation for the Admin UI                      |
 | [API documentation](https://github.com/sissbruecker/linkding/blob/master/docs/API.md)           | Documentation for the REST API                           |
 ## Browser Extension
 linkding comes with an official browser extension that allows to quickly add bookmarks, and search bookmarks through the browser's address bar. You can get the extension here:
 - [Mozilla Addon Store](https://addons.mozilla.org/de/firefox/addon/linkding-extension/)
 - [Chrome Web Store](https://chrome.google.com/webstore/detail/linkding-extension/beakmhbijpdhipnjhnclmhgjlddhidpe)
 The extension is open-source as well, and can be found [here](https://github.com/sissbruecker/linkding-extension).
 ## Community
 This section lists community projects around using linkding, in alphabetical order. If you have a project that you want to share with the linkding community, feel free to submit a PR to add your project to this section.
 - [aiolinkding](https://github.com/bachya/aiolinkding) A Python3, async library to interact with the linkding REST API. By [bachya](https://github.com/bachya)
 - [Helm Chart](https://charts.pascaliske.dev/charts/linkding/) Helm Chart for deploying linkding inside a Kubernetes cluster. By [pascaliske](https://github.com/pascaliske)
 - [Linka!](https://github.com/cmsax/linka) Web app (also a PWA) for quickly searching & opening bookmarks in linkding, support multi keywords, exclude mode and other advance options. By [cmsax](https://github.com/cmsax)
 - [linkding-cli](https://github.com/bachya/linkding-cli) A command-line interface (CLI) to interact with the linkding REST API. Powered by [aiolinkding](https://github.com/bachya/aiolinkding). By [bachya](https://github.com/bachya)
 - [linkding-extension](https://github.com/jeroenpardon/linkding-extension) Chromium compatible extension that wraps the linkding bookmarklet. Tested with Chrome, Edge, Brave. By [jeroenpardon](https://github.com/jeroenpardon)
 - [linkding-injector](https://github.com/Fivefold/linkding-injector) Injects search results from linkding into the sidebar of search pages like google and duckduckgo. Tested with Firefox and Chrome. By [Fivefold](https://github.com/Fivefold)
 - [LinkThing](https://apps.apple.com/us/app/linkthing/id1666031776) An iOS client for linkding. By [amoscardino](https://github.com/amoscardino)
 - [Open all links bookmarklet](https://gist.github.com/ukcuddlyguy/336dd7339e6d35fc64a75ccfc9323c66) A browser bookmarklet to open all links on the current Linkding page in new tabs. By [ukcuddlyguy](https://github.com/ukcuddlyguy)
 - [Postman collection](https://gist.github.com/gingerbeardman/f0b42502f3bc9344e92ce63afd4360d3) a group of saved request templates for API testing. By [gingerbeardman](https://github.com/gingerbeardman)
 ## Acknowledgements
 JetBrains provides an open-source license of [IntelliJ IDEA](https://www.jetbrains.com/idea/) for the development of linkding.
 ## Development
-The application is open source, so you are free to modify or contribute. The application is built using the Django web framework. You can get started by checking out the excellent Django docs: https://docs.djangoproject.com/en/3.0/. The `bookmarks` folder contains the actual bookmark application, `siteroot` is the Django root application. Other than that the code should be self-explanatory / standard Django stuff 🙂.
+The application is open source, so you are free to modify or contribute. The application is built using the Django web framework. You can get started by checking out the excellent [Django docs](https://docs.djangoproject.com/en/4.1/). The `bookmarks` folder contains the actual bookmark application, `siteroot` is the Django root application. Other than that the code should be self-explanatory / standard Django stuff 🙂.
 ### Prerequisites
- Python 3
+- Python 3.10
 - Node.js
 ### Setup
@@ -169,6 +248,22 @@ python3 manage.py runserver
 ```
 The frontend is now available under http://localhost:8000
-## Community
+### DevContainers
- [linkding-extension](https://github.com/jeroenpardon/linkding-extension) Chromium compatible extension that wraps the linkding bookmarklet. Tested with Chrome, Edge, Brave. By [jeroenpardon](https://github.com/jeroenpardon)
+This repository also supports DevContainers: [![Open in Remote - Containers](https://img.shields.io/static/v1?label=Remote%20-%20Containers&message=Open&color=blue&logo=visualstudiocode)](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=git@github.com:sissbruecker/linkding.git)
 Once checked out, only the following commands are required to get started:
 Create a user for the frontend:
 ```
 python3 manage.py createsuperuser --username=joe --email=joe@example.com
 ```
 Start the Node.js development server (used for compiling JavaScript components like tag auto-completion) with:
 ```
 npm run dev
 ```
 Start the Django development server with:
 ```
 python3 manage.py runserver
 ```
 The frontend is now available under http://localhost:8000
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -0,0 +1,13 @@
 # Security Policy
 ## Supported Versions
 | Version | Supported          |
 | ------- | ------------------ |
 | 1.10.x   | :white_check_mark: |
 ## Reporting a Vulnerability
 To report a vulnerability, please send a mail to: 588ex5zl8@mozmail.com
 I'll try to get back to you as soon as possible.
--- a/assets/logo.afdesign
+++ b/assets/logo.afdesign
--- a/background-tasks-wrapper.sh
+++ b/background-tasks-wrapper.sh
@@ -0,0 +1,5 @@
 #!/usr/bin/env bash
 # Wrapper script used by supervisord to first clear task locks before starting the background task processor
 python manage.py clean_tasks
 exec python manage.py process_tasks
--- a/bookmarks/admin.py
+++ b/bookmarks/admin.py
@@ -1,3 +1,5 @@
 from background_task.admin import TaskAdmin, CompletedTaskAdmin
 from background_task.models import Task, CompletedTask
 from django.contrib import admin, messages
 from django.contrib.admin import AdminSite
 from django.contrib.auth.admin import UserAdmin
@@ -5,9 +7,9 @@ from django.contrib.auth.models import User
 from django.db.models import Count, QuerySet
 from django.utils.translation import ngettext, gettext
 from rest_framework.authtoken.admin import TokenAdmin
-from rest_framework.authtoken.models import Token
+from rest_framework.authtoken.models import TokenProxy
-from bookmarks.models import Bookmark, Tag, UserProfile
+from bookmarks.models import Bookmark, Tag, UserProfile, Toast, FeedToken
 from bookmarks.services.bookmarks import archive_bookmark, unarchive_bookmark
@@ -19,9 +21,27 @@ class LinkdingAdminSite(AdminSite):
 class AdminBookmark(admin.ModelAdmin):
    list_display = ('resolved_title', 'url', 'is_archived', 'owner', 'date_added')
    search_fields = ('title', 'description', 'website_title', 'website_description', 'url', 'tags__name')
-    list_filter = ('owner__username', 'is_archived', 'tags',)
+    list_filter = ('owner__username', 'is_archived', 'unread', 'tags',)
    ordering = ('-date_added',)
-    actions = ['archive_selected_bookmarks', 'unarchive_selected_bookmarks']
+    actions = ['delete_selected_bookmarks', 'archive_selected_bookmarks', 'unarchive_selected_bookmarks', 'mark_as_read', 'mark_as_unread']
    def get_actions(self, request):
        actions = super().get_actions(request)
        # Remove default delete action, which gets replaced by delete_selected_bookmarks below
        # The default action shows a confirmation page which can fail in production when selecting all bookmarks and the
        # number of objects to delete exceeds the value in DATA_UPLOAD_MAX_NUMBER_FIELDS (1000 by default)
        del actions['delete_selected']
        return actions
    def delete_selected_bookmarks(self, request, queryset: QuerySet):
        bookmarks_count = queryset.count()
        for bookmark in queryset:
            bookmark.delete()
        self.message_user(request, ngettext(
            '%d bookmark was successfully deleted.',
            '%d bookmarks were successfully deleted.',
            bookmarks_count,
        ) % bookmarks_count, messages.SUCCESS)
    def archive_selected_bookmarks(self, request, queryset: QuerySet):
        for bookmark in queryset:
@@ -43,6 +63,24 @@ class AdminBookmark(admin.ModelAdmin):
            bookmarks_count,
        ) % bookmarks_count, messages.SUCCESS)
    def mark_as_read(self, request, queryset: QuerySet):
        bookmarks_count = queryset.count()
        queryset.update(unread=False)
        self.message_user(request, ngettext(
            '%d bookmark marked as read.',
            '%d bookmarks marked as read.',
            bookmarks_count,
        ) % bookmarks_count, messages.SUCCESS)
    def mark_as_unread(self, request, queryset: QuerySet):
        bookmarks_count = queryset.count()
        queryset.update(unread=True)
        self.message_user(request, ngettext(
            '%d bookmark marked as unread.',
            '%d bookmarks marked as unread.',
            bookmarks_count,
        ) % bookmarks_count, messages.SUCCESS)
 class AdminTag(admin.ModelAdmin):
    list_display = ('name', 'bookmarks_count', 'owner', 'date_added')
@@ -59,6 +97,8 @@ class AdminTag(admin.ModelAdmin):
    def bookmarks_count(self, obj):
        return obj.bookmarks_count
    bookmarks_count.admin_order_field = 'bookmarks_count'
    def delete_unused_tags(self, request, queryset: QuerySet):
        unused_tags = queryset.filter(bookmark__isnull=True)
        unused_tags_count = unused_tags.count()
@@ -93,8 +133,24 @@ class AdminCustomUser(UserAdmin):
        return super(AdminCustomUser, self).get_inline_instances(request, obj)
 class AdminToast(admin.ModelAdmin):
    list_display = ('key', 'message', 'owner', 'acknowledged')
    search_fields = ('key', 'message')
    list_filter = ('owner__username',)
 class AdminFeedToken(admin.ModelAdmin):
    list_display = ('key', 'user')
    search_fields = ['key']
    list_filter = ('user__username',)
 linkding_admin_site = LinkdingAdminSite()
 linkding_admin_site.register(Bookmark, AdminBookmark)
 linkding_admin_site.register(Tag, AdminTag)
 linkding_admin_site.register(User, AdminCustomUser)
-linkding_admin_site.register(Token, TokenAdmin)
+linkding_admin_site.register(TokenProxy, TokenAdmin)
 linkding_admin_site.register(Toast, AdminToast)
 linkding_admin_site.register(FeedToken, AdminFeedToken)
 linkding_admin_site.register(Task, TaskAdmin)
 linkding_admin_site.register(CompletedTask, CompletedTaskAdmin)
--- a/bookmarks/api/routes.py
+++ b/bookmarks/api/routes.py
@@ -1,14 +1,14 @@
 from django.urls import reverse
 from rest_framework import viewsets, mixins, status
 from rest_framework.decorators import action
 from rest_framework.permissions import AllowAny
 from rest_framework.response import Response
 from rest_framework.routers import DefaultRouter
 from bookmarks import queries
 from bookmarks.api.serializers import BookmarkSerializer, TagSerializer
-from bookmarks.models import Bookmark, Tag
+from bookmarks.models import Bookmark, BookmarkFilters, Tag, User
-from bookmarks.services.bookmarks import archive_bookmark, unarchive_bookmark
+from bookmarks.services.bookmarks import archive_bookmark, unarchive_bookmark, website_loader
-from bookmarks.services.website_loader import load_website_metadata
+from bookmarks.services.website_loader import WebsiteMetadata
 class BookmarkViewSet(viewsets.GenericViewSet,
@@ -19,12 +19,23 @@ class BookmarkViewSet(viewsets.GenericViewSet,
                      mixins.DestroyModelMixin):
    serializer_class = BookmarkSerializer
    def get_permissions(self):
        # Allow unauthenticated access to shared bookmarks.
        # The shared action should still filter bookmarks so that
        # unauthenticated users only see bookmarks from users that have public
        # sharing explicitly enabled
        if self.action == 'shared':
            return [AllowAny()]
        # Otherwise use default permissions which should require authentication
        return super().get_permissions()
    def get_queryset(self):
        user = self.request.user
        # For list action, use query set that applies search and tag projections
        if self.action == 'list':
            query_string = self.request.GET.get('q')
-            return queries.query_bookmarks(user, query_string)
+            return queries.query_bookmarks(user, user.profile, query_string)
        # For single entity actions use default query set without projections
        return Bookmark.objects.all().filter(owner=user)
@@ -36,7 +47,18 @@ class BookmarkViewSet(viewsets.GenericViewSet,
    def archived(self, request):
        user = request.user
        query_string = request.GET.get('q')
-        query_set = queries.query_archived_bookmarks(user, query_string)
+        query_set = queries.query_archived_bookmarks(user, user.profile, query_string)
        page = self.paginate_queryset(query_set)
        serializer = self.get_serializer_class()
        data = serializer(page, many=True).data
        return self.get_paginated_response(data)
    @action(methods=['get'], detail=False)
    def shared(self, request):
        filters = BookmarkFilters(request)
        user = User.objects.filter(username=filters.user).first()
        public_only = not request.user.is_authenticated
        query_set = queries.query_shared_bookmarks(user, request.user_profile, filters.query, public_only)
        page = self.paginate_queryset(query_set)
        serializer = self.get_serializer_class()
        data = serializer(page, many=True).data
@@ -58,15 +80,13 @@ class BookmarkViewSet(viewsets.GenericViewSet,
    def check(self, request):
        url = request.GET.get('url')
        bookmark = Bookmark.objects.filter(owner=request.user, url=url).first()
-        existing_bookmark_data = None
+        existing_bookmark_data = self.get_serializer(bookmark).data if bookmark else None
-        if bookmark is not None:
+        # Either return metadata from existing bookmark, or scrape from URL
-            existing_bookmark_data = {
+        if bookmark:
-                'id': bookmark.id,
+            metadata = WebsiteMetadata(url, bookmark.website_title, bookmark.website_description)
-                'edit_url': reverse('bookmarks:edit', args=[bookmark.id])
+        else:
-            }
+            metadata = website_loader.load_website_metadata(url)
        metadata = load_website_metadata(url)
        return Response({
            'bookmark': existing_bookmark_data,
--- a/bookmarks/api/serializers.py
+++ b/bookmarks/api/serializers.py
@@ -1,4 +1,6 @@
 from django.db.models import prefetch_related_objects
 from rest_framework import serializers
 from rest_framework.serializers import ListSerializer
 from bookmarks.models import Bookmark, Tag, build_tag_string
 from bookmarks.services.bookmarks import create_bookmark, update_bookmark
@@ -9,6 +11,14 @@ class TagListField(serializers.ListField):
    child = serializers.CharField()
 class BookmarkListSerializer(ListSerializer):
    def to_representation(self, data):
        # Prefetch nested relations to avoid n+1 queries
        prefetch_related_objects(data, 'tags')
        return super().to_representation(data)
 class BookmarkSerializer(serializers.ModelSerializer):
    class Meta:
        model = Bookmark
@@ -17,8 +27,12 @@ class BookmarkSerializer(serializers.ModelSerializer):
            'url',
            'title',
            'description',
            'notes',
            'website_title',
            'website_description',
            'is_archived',
            'unread',
            'shared',
            'tag_names',
            'date_added',
            'date_modified'
@@ -29,10 +43,15 @@ class BookmarkSerializer(serializers.ModelSerializer):
            'date_added',
            'date_modified'
        ]
        list_serializer_class = BookmarkListSerializer
    # Override optional char fields to provide default value
    title = serializers.CharField(required=False, allow_blank=True, default='')
    description = serializers.CharField(required=False, allow_blank=True, default='')
    notes = serializers.CharField(required=False, allow_blank=True, default='')
    is_archived = serializers.BooleanField(required=False, default=False)
    unread = serializers.BooleanField(required=False, default=False)
    shared = serializers.BooleanField(required=False, default=False)
    # Override readonly tag_names property to allow passing a list of tag names to create/update
    tag_names = TagListField(required=False, default=[])
@@ -41,14 +60,24 @@ class BookmarkSerializer(serializers.ModelSerializer):
        bookmark.url = validated_data['url']
        bookmark.title = validated_data['title']
        bookmark.description = validated_data['description']
-        tag_string = build_tag_string(validated_data['tag_names'], ' ')
+        bookmark.notes = validated_data['notes']
        bookmark.is_archived = validated_data['is_archived']
        bookmark.unread = validated_data['unread']
        bookmark.shared = validated_data['shared']
        tag_string = build_tag_string(validated_data['tag_names'])
        return create_bookmark(bookmark, tag_string, self.context['user'])
    def update(self, instance: Bookmark, validated_data):
-        instance.url = validated_data['url']
+        # Update fields if they were provided in the payload
-        instance.title = validated_data['title']
+        for key in ['url', 'title', 'description', 'notes', 'unread', 'shared']:
-        instance.description = validated_data['description']
+            if key in validated_data:
-        tag_string = build_tag_string(validated_data['tag_names'], ' ')
+                setattr(instance, key, validated_data[key])
        # Use tag string from payload, or use bookmark's current tags as fallback
        tag_string = build_tag_string(instance.tag_names)
        if 'tag_names' in validated_data:
            tag_string = build_tag_string(validated_data['tag_names'])
        return update_bookmark(instance, tag_string, self.context['user'])
--- a/bookmarks/apps.py
+++ b/bookmarks/apps.py
@@ -3,3 +3,7 @@ from django.apps import AppConfig
 class BookmarksConfig(AppConfig):
    name = 'bookmarks'
    def ready(self):
        # Register signal handlers
        import bookmarks.signals
--- a/bookmarks/components/SearchAutoComplete.svelte
+++ b/bookmarks/components/SearchAutoComplete.svelte
@@ -1,267 +0,0 @@
 <script>
    import {SearchHistory} from "./SearchHistory";
    import {clampText, debounce, getCurrentWord, getCurrentWordBounds} from "./util";
    const searchHistory = new SearchHistory()
    export let name;
    export let placeholder;
    export let value;
    export let tags;
    export let mode = 'default';
    export let apiClient;
    let isFocus = false;
    let isOpen = false;
    let suggestions = []
    let selectedIndex = undefined;
    let input = null;
    // Track current search query after loading the page
    searchHistory.pushCurrent()
    updateSuggestions()
    function handleFocus() {
        isFocus = true;
    }
    function handleBlur() {
        isFocus = false;
        close();
    }
    function handleInput(e) {
        value = e.target.value
        debouncedLoadSuggestions()
    }
    function handleKeyDown(e) {
        // Enter
        if (isOpen && selectedIndex !== undefined && (e.keyCode === 13 || e.keyCode === 9)) {
            const suggestion = suggestions.total[selectedIndex];
            if (suggestion) completeSuggestion(suggestion);
            e.preventDefault();
        }
        // Escape
        if (e.keyCode === 27) {
            close();
            e.preventDefault();
        }
        // Up arrow
        if (e.keyCode === 38) {
            updateSelection(-1);
            e.preventDefault();
        }
        // Down arrow
        if (e.keyCode === 40) {
            if (!isOpen) {
                loadSuggestions()
            } else {
                updateSelection(1);
            }
            e.preventDefault();
        }
    }
    function open() {
        isOpen = true;
    }
    function close() {
        isOpen = false;
        updateSuggestions()
        selectedIndex = undefined
    }
    function hasSuggestions() {
        return suggestions.total.length > 0
    }
    async function loadSuggestions() {
        let suggestionIndex = 0
        function nextIndex() {
            return suggestionIndex++
        }
        // Tag suggestions
        let tagSuggestions = []
        const currentWord = getCurrentWord(input)
        if (currentWord && currentWord.length > 1 && currentWord[0] === '#') {
            const searchTag = currentWord.substring(1, currentWord.length)
            tagSuggestions = (tags || []).filter(tagName => tagName.toLowerCase().indexOf(searchTag.toLowerCase()) === 0)
                .slice(0, 5)
                .map(tagName => ({
                    type: 'tag',
                    index: nextIndex(),
                    label: `#${tagName}`,
                    tagName: tagName
                }))
        }
        // Recent search suggestions
        const search = searchHistory.getRecentSearches(value, 5).map(value => ({
            type: 'search',
            index: nextIndex(),
            label: value,
            value
        }))
        // Bookmark suggestions
        let bookmarks = []
        if (value && value.length >= 3) {
            const fetchedBookmarks = mode === 'archive'
                ? await apiClient.getArchivedBookmarks(value, {limit: 5, offset: 0})
                : await apiClient.getBookmarks(value, {limit: 5, offset: 0})
            bookmarks = fetchedBookmarks.map(bookmark => {
                const fullLabel = bookmark.title || bookmark.website_title || bookmark.url
                const label = clampText(fullLabel, 60)
                return {
                    type: 'bookmark',
                    index: nextIndex(),
                    label,
                    bookmark
                }
            })
        }
        updateSuggestions(search, bookmarks, tagSuggestions)
        if (hasSuggestions()) {
            open()
        } else {
            close()
        }
    }
    const debouncedLoadSuggestions = debounce(loadSuggestions)
    function updateSuggestions(search, bookmarks, tagSuggestions) {
        search = search || []
        bookmarks = bookmarks || []
        tagSuggestions = tagSuggestions || []
        suggestions = {
            search,
            bookmarks,
            tags: tagSuggestions,
            total: [
                ...tagSuggestions,
                ...search,
                ...bookmarks,
            ]
        }
    }
    function completeSuggestion(suggestion) {
        if (suggestion.type === 'search') {
            value = suggestion.value
            close()
        }
        if (suggestion.type === 'bookmark') {
            window.open(suggestion.bookmark.url, '_blank')
            close()
        }
        if (suggestion.type === 'tag') {
            const bounds = getCurrentWordBounds(input);
            const inputValue = input.value;
            input.value = inputValue.substring(0, bounds.start) + `#${suggestion.tagName} ` + inputValue.substring(bounds.end);
            close()
        }
    }
    function updateSelection(dir) {
        const length = suggestions.total.length;
        if (length === 0) return
        if (selectedIndex === undefined) {
            selectedIndex = dir > 0 ? 0 : Math.max(length - 1, 0)
            return
        }
        let newIndex = selectedIndex + dir;
        if (newIndex < 0) newIndex = Math.max(length - 1, 0);
        if (newIndex >= length) newIndex = 0;
        selectedIndex = newIndex;
    }
 </script>
 <div class="form-autocomplete">
    <div class="form-autocomplete-input form-input" class:is-focused={isFocus}>
        <input type="search" class="form-input" name="{name}" placeholder="{placeholder}" autocomplete="off" value="{value}"
               bind:this={input}
               on:input={handleInput} on:keydown={handleKeyDown} on:focus={handleFocus} on:blur={handleBlur}>
    </div>
    <ul class="menu" class:open={isOpen}>
        {#if suggestions.tags.length > 0}
            <li class="menu-item group-item">Tags</li>
        {/if}
        {#each suggestions.tags as suggestion}
            <li class="menu-item" class:selected={selectedIndex === suggestion.index}>
                <a href="#" on:mousedown|preventDefault={() => completeSuggestion(suggestion)}>
                    <div class="tile tile-centered">
                        <div class="tile-content">
                            {suggestion.label}
                        </div>
                    </div>
                </a>
            </li>
        {/each}
        {#if suggestions.search.length > 0}
            <li class="menu-item group-item">Recent Searches</li>
        {/if}
        {#each suggestions.search as suggestion}
            <li class="menu-item" class:selected={selectedIndex === suggestion.index}>
                <a href="#" on:mousedown|preventDefault={() => completeSuggestion(suggestion)}>
                    <div class="tile tile-centered">
                        <div class="tile-content">
                            {suggestion.label}
                        </div>
                    </div>
                </a>
            </li>
        {/each}
        {#if suggestions.bookmarks.length > 0}
            <li class="menu-item group-item">Bookmarks</li>
        {/if}
        {#each suggestions.bookmarks as suggestion}
            <li class="menu-item" class:selected={selectedIndex === suggestion.index}>
                <a href="#" on:mousedown|preventDefault={() => completeSuggestion(suggestion)}>
                    <div class="tile tile-centered">
                        <div class="tile-content">
                            {suggestion.label}
                        </div>
                    </div>
                </a>
            </li>
        {/each}
    </ul>
 </div>
 <style>
    .menu {
        display: none;
        max-height: 400px;
        overflow: auto;
    }
    .menu.open {
        display: block;
    }
    .form-autocomplete-input {
        padding: 0;
    }
    .form-autocomplete-input.is-focused {
        z-index: 2;
    }
 </style>
--- a/bookmarks/components/SearchHistory.js
+++ b/bookmarks/components/SearchHistory.js
@@ -1,48 +0,0 @@
 const SEARCH_HISTORY_KEY = 'searchHistory'
 const MAX_ENTRIES = 30
 export class SearchHistory {
    getHistory() {
        const historyJson = localStorage.getItem(SEARCH_HISTORY_KEY)
        return historyJson ? JSON.parse(historyJson) : {
            recent: []
        }
    }
    pushCurrent() {
        // Skip if browser is not compatible
        if (!window.URLSearchParams) return
        const urlParams = new URLSearchParams(window.location.search);
        const searchParam = urlParams.get('q');
        if (!searchParam) return
        this.push(searchParam)
    }
    push(search) {
        const history = this.getHistory()
        history.recent.unshift(search)
        // Remove duplicates and clamp to max entries
        history.recent = history.recent.reduce((acc, cur) => {
            if (acc.length >= MAX_ENTRIES) return acc
            if (acc.indexOf(cur) >= 0) return acc
            acc.push(cur)
            return acc
        }, [])
        const newHistoryJson = JSON.stringify(history)
        localStorage.setItem(SEARCH_HISTORY_KEY, newHistoryJson)
    }
    getRecentSearches(query, max) {
        const history = this.getHistory()
        return history.recent
            .filter(search => !query || search.toLowerCase().indexOf(query.toLowerCase()) >= 0)
            .slice(0, max)
    }
 }
--- a/bookmarks/components/TagAutocomplete.svelte
+++ b/bookmarks/components/TagAutocomplete.svelte
@@ -1,156 +0,0 @@
 <script>
    import {getCurrentWord, getCurrentWordBounds} from "./util";
    export let id;
    export let name;
    export let value;
    export let apiClient;
    export let variant = 'default';
    let tags = [];
    let isFocus = false;
    let isOpen = false;
    let input = null;
    let suggestions = [];
    let selectedIndex = 0;
    init();
    async function init() {
        // For now we cache all tags on load as the template did before
        try {
            tags = await apiClient.getTags({limit: 1000, offset: 0});
            tags.sort((left, right) => left.name.toLowerCase().localeCompare(right.name.toLowerCase()))
        } catch (e) {
            console.warn('TagAutocomplete: Error loading tag list');
        }
    }
    function handleFocus() {
        isFocus = true;
    }
    function handleBlur() {
        isFocus = false;
        close();
    }
    function handleInput(e) {
        input = e.target;
        const word = getCurrentWord(input);
        suggestions = word
            ? tags.filter(tag => tag.name.toLowerCase().indexOf(word.toLowerCase()) === 0)
            : [];
        if (word && suggestions.length > 0) {
            open();
        } else {
            close();
        }
    }
    function handleKeyDown(e) {
        if (isOpen && (e.keyCode === 13 || e.keyCode === 9)) {
            const suggestion = suggestions[selectedIndex];
            complete(suggestion);
            e.preventDefault();
        }
        if (e.keyCode === 27) {
            close();
            e.preventDefault();
        }
        if (e.keyCode === 38) {
            updateSelection(-1);
            e.preventDefault();
        }
        if (e.keyCode === 40) {
            updateSelection(1);
            e.preventDefault();
        }
    }
    function open() {
        isOpen = true;
        selectedIndex = 0;
    }
    function close() {
        isOpen = false;
        suggestions = [];
        selectedIndex = 0;
    }
    function complete(suggestion) {
        const bounds = getCurrentWordBounds(input);
        const value = input.value;
        input.value = value.substring(0, bounds.start) + suggestion.name + value.substring(bounds.end);
        close();
    }
    function updateSelection(dir) {
        const length = suggestions.length;
        let newIndex = selectedIndex + dir;
        if (newIndex < 0) newIndex = Math.max(length - 1, 0);
        if (newIndex >= length) newIndex = 0;
        selectedIndex = newIndex;
    }
 </script>
 <div class="form-autocomplete" class:small={variant === 'small'}>
    <!-- autocomplete input container -->
    <div class="form-autocomplete-input form-input" class:is-focused={isFocus}>
        <!-- autocomplete real input box -->
        <input id="{id}" name="{name}" value="{value ||''}" placeholder="&nbsp;"
               class="form-input" type="text" autocomplete="off"
               on:input={handleInput} on:keydown={handleKeyDown}
               on:focus={handleFocus} on:blur={handleBlur}>
    </div>
    <!-- autocomplete suggestion list -->
    <ul class="menu" class:open={isOpen && suggestions.length > 0}>
        <!-- menu list items -->
        {#each suggestions as tag,i}
            <li class="menu-item" class:selected={selectedIndex === i}>
                <a href="#" on:mousedown|preventDefault={() => complete(tag)}>
                    <div class="tile tile-centered">
                        <div class="tile-content">
                            {tag.name}
                        </div>
                    </div>
                </a>
            </li>
        {/each}
    </ul>
 </div>
 <style>
    .menu {
        display: none;
        max-height: 200px;
        overflow: auto;
    }
    .menu.open {
        display: block;
    }
    .form-autocomplete.small .form-autocomplete-input {
        height: 1.4rem;
        min-height: 1.4rem;
    }
    .form-autocomplete.small .form-autocomplete-input input {
        margin: 0;
        padding: 0;
        font-size: 0.7rem;
    }
    .form-autocomplete.small .menu .menu-item {
        font-size: 0.7rem;
    }
 </style>
--- a/bookmarks/components/api.js
+++ b/bookmarks/components/api.js
@@ -1,31 +0,0 @@
 export class ApiClient {
    constructor(baseUrl) {
        this.baseUrl = baseUrl
    }
    getBookmarks(query, options = {limit: 100, offset: 0}) {
        const encodedQuery = encodeURIComponent(query)
        const url = `${this.baseUrl}bookmarks/?q=${encodedQuery}&limit=${options.limit}&offset=${options.offset}`
        return fetch(url)
            .then(response => response.json())
            .then(data => data.results)
    }
    getArchivedBookmarks(query, options = {limit: 100, offset: 0}) {
        const encodedQuery = encodeURIComponent(query)
        const url = `${this.baseUrl}bookmarks/archived/?q=${encodedQuery}&limit=${options.limit}&offset=${options.offset}`
        return fetch(url)
            .then(response => response.json())
            .then(data => data.results)
    }
    getTags(options = {limit: 100, offset: 0}) {
        const url = `${this.baseUrl}tags/?limit=${options.limit}&offset=${options.offset}`
        return fetch(url)
            .then(response => response.json())
            .then(data => data.results)
    }
 }
--- a/bookmarks/components/index.js
+++ b/bookmarks/components/index.js
@@ -1,10 +0,0 @@
 import TagAutoComplete from './TagAutocomplete.svelte'
 import SearchAutoComplete from './SearchAutoComplete.svelte'
 import {ApiClient} from './api'
 export default {
    ApiClient,
    TagAutoComplete,
    SearchAutoComplete
 }
--- a/bookmarks/components/util.js
+++ b/bookmarks/components/util.js
@@ -1,37 +0,0 @@
 export function debounce(callback, delay = 250) {
    let timeoutId
    return (...args) => {
        clearTimeout(timeoutId)
        timeoutId = setTimeout(() => {
            timeoutId = null
            callback(...args)
        }, delay)
    }
 }
 export function clampText(text, maxChars = 30) {
    if(!text || text.length <= 30) return text
    return text.substr(0, maxChars) + '...'
 }
 export function getCurrentWordBounds(input) {
    const text = input.value;
    const end = input.selectionStart;
    let start = end;
    let currentChar = text.charAt(start - 1);
    while (currentChar && currentChar !== ' ' && start > 0) {
        start--;
        currentChar = text.charAt(start - 1);
    }
    return {start, end};
 }
 export function getCurrentWord(input) {
    const bounds = getCurrentWordBounds(input);
    return input.value.substring(bounds.start, bounds.end);
 }
--- a/bookmarks/context_processors.py
+++ b/bookmarks/context_processors.py
@@ -0,0 +1,25 @@
 from bookmarks import queries
 from bookmarks.models import Toast
 def toasts(request):
    user = request.user
    toast_messages = Toast.objects.filter(owner=user, acknowledged=False) if user.is_authenticated else []
    has_toasts = len(toast_messages) > 0
    return {
        'has_toasts': has_toasts,
        'toast_messages': toast_messages,
    }
 def public_shares(request):
    # Only check for public shares for anonymous users
    if not request.user.is_authenticated:
        query_set = queries.query_shared_bookmarks(None, request.user_profile, '', True)
        has_public_shares = query_set.count() > 0
        return {
            'has_public_shares': has_public_shares,
        }
    return {}
--- a/bookmarks/e2e/init.py
+++ b/bookmarks/e2e/init.py
--- a/bookmarks/e2e/e2e_test_bookmark_form.py
+++ b/bookmarks/e2e/e2e_test_bookmark_form.py
@@ -0,0 +1,67 @@
 from django.urls import reverse
 from playwright.sync_api import sync_playwright, expect
 from bookmarks.e2e.helpers import LinkdingE2ETestCase
 class BookmarkFormE2ETestCase(LinkdingE2ETestCase):
    def test_create_should_check_for_existing_bookmark(self):
        existing_bookmark = self.setup_bookmark(title='Existing title',
                                                description='Existing description',
                                                notes='Existing notes',
                                                tags=[self.setup_tag(name='tag1'), self.setup_tag(name='tag2')],
                                                website_title='Existing website title',
                                                website_description='Existing website description',
                                                unread=True)
        tag_names = ' '.join(existing_bookmark.tag_names)
        with sync_playwright() as p:
            browser = self.setup_browser(p)
            page = browser.new_page()
            page.goto(self.live_server_url + reverse('bookmarks:new'))
            # Enter bookmarked URL
            page.get_by_label('URL').fill(existing_bookmark.url)
            # Already bookmarked hint should be visible
            page.get_by_text('This URL is already bookmarked.').wait_for(timeout=2000)
            # Form should be pre-filled with data from existing bookmark
            self.assertEqual(existing_bookmark.title, page.get_by_label('Title').input_value())
            self.assertEqual(existing_bookmark.description, page.get_by_label('Description').input_value())
            self.assertEqual(existing_bookmark.notes, page.get_by_label('Notes').input_value())
            self.assertEqual(existing_bookmark.website_title, page.get_by_label('Title').get_attribute('placeholder'))
            self.assertEqual(existing_bookmark.website_description,
                             page.get_by_label('Description').get_attribute('placeholder'))
            self.assertEqual(tag_names, page.get_by_label('Tags').input_value())
            self.assertTrue(tag_names, page.get_by_label('Mark as unread').is_checked())
            # Enter non-bookmarked URL
            page.get_by_label('URL').fill('https://example.com/unknown')
            # Already bookmarked hint should be hidden
            page.get_by_text('This URL is already bookmarked.').wait_for(state='hidden', timeout=2000)
            browser.close()
    def test_edit_should_not_check_for_existing_bookmark(self):
        bookmark = self.setup_bookmark()
        with sync_playwright() as p:
            browser = self.setup_browser(p)
            page = browser.new_page()
            page.goto(self.live_server_url + reverse('bookmarks:edit', args=[bookmark.id]))
            page.wait_for_timeout(timeout=1000)
            page.get_by_text('This URL is already bookmarked.').wait_for(state='hidden')
    def test_enter_url_of_existing_bookmark_should_show_notes(self):
        bookmark = self.setup_bookmark(notes='Existing notes', description='Existing description')
        with sync_playwright() as p:
            browser = self.setup_browser(p)
            page = browser.new_page()
            page.goto(self.live_server_url + reverse('bookmarks:new'))
            details = page.locator('details.notes')
            expect(details).not_to_have_attribute('open', value='')
            page.get_by_label('URL').fill(bookmark.url)
            expect(details).to_have_attribute('open', value='')
--- a/bookmarks/e2e/e2e_test_bookmark_item.py
+++ b/bookmarks/e2e/e2e_test_bookmark_item.py
@@ -0,0 +1,25 @@
 from unittest import skip
 from django.urls import reverse
 from playwright.sync_api import sync_playwright, expect
 from bookmarks.e2e.helpers import LinkdingE2ETestCase
 class BookmarkItemE2ETestCase(LinkdingE2ETestCase):
    @skip("Fails in CI, needs investigation")
    def test_toggle_notes_should_show_hide_notes(self):
        bookmark = self.setup_bookmark(notes='Test notes')
        with sync_playwright() as p:
            page = self.open(reverse('bookmarks:index'), p)
            notes = self.locate_bookmark(bookmark.title).locator('.notes')
            expect(notes).to_be_hidden()
            toggle_notes = page.locator('li button.toggle-notes')
            toggle_notes.click()
            expect(notes).to_be_visible()
            toggle_notes.click()
            expect(notes).to_be_hidden()
--- a/bookmarks/e2e/e2e_test_bookmark_page_partial_updates.py
+++ b/bookmarks/e2e/e2e_test_bookmark_page_partial_updates.py
@@ -0,0 +1,252 @@
 from typing import List
 from django.urls import reverse
 from playwright.sync_api import sync_playwright, expect
 from bookmarks.e2e.helpers import LinkdingE2ETestCase
 class BookmarkPagePartialUpdatesE2ETestCase(LinkdingE2ETestCase):
    def setup_fixture(self):
        profile = self.get_or_create_test_user().profile
        profile.enable_sharing = True
        profile.save()
        # create a number of bookmarks with different states / visibility to
        # verify correct data is loaded on update
        self.setup_numbered_bookmarks(3, with_tags=True)
        self.setup_numbered_bookmarks(3, with_tags=True, archived=True)
        self.setup_numbered_bookmarks(3,
                                      shared=True,
                                      prefix="Joe's Bookmark",
                                      user=self.setup_user(enable_sharing=True))
    def assertVisibleBookmarks(self, titles: List[str]):
        bookmark_tags = self.page.locator('li[ld-bookmark-item]')
        expect(bookmark_tags).to_have_count(len(titles))
        for title in titles:
            matching_tag = bookmark_tags.filter(has_text=title)
            expect(matching_tag).to_be_visible()
    def assertVisibleTags(self, titles: List[str]):
        tag_tags = self.page.locator('.tag-cloud .unselected-tags a')
        expect(tag_tags).to_have_count(len(titles))
        for title in titles:
            matching_tag = tag_tags.filter(has_text=title)
            expect(matching_tag).to_be_visible()
    def test_partial_update_respects_query(self):
        self.setup_numbered_bookmarks(5, prefix='foo')
        self.setup_numbered_bookmarks(5, prefix='bar')
        with sync_playwright() as p:
            url = reverse('bookmarks:index') + '?q=foo'
            self.open(url, p)
            self.assertVisibleBookmarks(['foo 1', 'foo 2', 'foo 3', 'foo 4', 'foo 5'])
            self.locate_bookmark('foo 2').get_by_text('Archive').click()
            self.assertVisibleBookmarks(['foo 1', 'foo 3', 'foo 4', 'foo 5'])
    def test_partial_update_respects_page(self):
        # add a suffix, otherwise 'foo 1' also matches 'foo 10'
        self.setup_numbered_bookmarks(50, prefix='foo', suffix='-')
        with sync_playwright() as p:
            url = reverse('bookmarks:index') + '?q=foo&page=2'
            self.open(url, p)
            # with descending sort, page two has 'foo 1' to 'foo 20'
            expected_titles = [f'foo {i}-' for i in range(1, 21)]
            self.assertVisibleBookmarks(expected_titles)
            self.locate_bookmark('foo 20-').get_by_text('Archive').click()
            expected_titles = [f'foo {i}-' for i in range(1, 20)]
            self.assertVisibleBookmarks(expected_titles)
    def test_multiple_partial_updates(self):
        self.setup_numbered_bookmarks(5)
        with sync_playwright() as p:
            url = reverse('bookmarks:index')
            self.open(url, p)
            self.locate_bookmark('Bookmark 1').get_by_text('Archive').click()
            self.assertVisibleBookmarks(['Bookmark 2', 'Bookmark 3', 'Bookmark 4', 'Bookmark 5'])
            self.locate_bookmark('Bookmark 2').get_by_text('Archive').click()
            self.assertVisibleBookmarks(['Bookmark 3', 'Bookmark 4', 'Bookmark 5'])
            self.locate_bookmark('Bookmark 3').get_by_text('Archive').click()
            self.assertVisibleBookmarks(['Bookmark 4', 'Bookmark 5'])
            self.assertReloads(0)
    def test_active_bookmarks_partial_update_on_archive(self):
        self.setup_fixture()
        with sync_playwright() as p:
            self.open(reverse('bookmarks:index'), p)
            self.locate_bookmark('Bookmark 2').get_by_text('Archive').click()
            self.assertVisibleBookmarks(['Bookmark 1', 'Bookmark 3'])
            self.assertVisibleTags(['Tag 1', 'Tag 3'])
            self.assertReloads(0)
    def test_active_bookmarks_partial_update_on_delete(self):
        self.setup_fixture()
        with sync_playwright() as p:
            self.open(reverse('bookmarks:index'), p)
            self.locate_bookmark('Bookmark 2').get_by_text('Remove').click()
            self.locate_bookmark('Bookmark 2').get_by_text('Confirm').click()
            self.assertVisibleBookmarks(['Bookmark 1', 'Bookmark 3'])
            self.assertVisibleTags(['Tag 1', 'Tag 3'])
            self.assertReloads(0)
    def test_active_bookmarks_partial_update_on_mark_as_read(self):
        self.setup_fixture()
        bookmark2 = self.get_numbered_bookmark('Bookmark 2')
        bookmark2.unread = True
        bookmark2.save()
        with sync_playwright() as p:
            self.open(reverse('bookmarks:index'), p)
            expect(self.locate_bookmark('Bookmark 2').get_by_text('Bookmark 2')).to_have_class('text-italic')
            self.locate_bookmark('Bookmark 2').get_by_text('Mark as read').click()
            expect(self.locate_bookmark('Bookmark 2').get_by_text('Bookmark 2')).not_to_have_class('text-italic')
            self.assertReloads(0)
    def test_active_bookmarks_partial_update_on_bulk_archive(self):
        self.setup_fixture()
        with sync_playwright() as p:
            self.open(reverse('bookmarks:index'), p)
            self.locate_bulk_edit_toggle().click()
            self.locate_bookmark('Bookmark 2').locator('label[ld-bulk-edit-checkbox]').click()
            self.locate_bulk_edit_bar().get_by_text('Archive').click()
            self.locate_bulk_edit_bar().get_by_text('Confirm').click()
            self.assertVisibleBookmarks(['Bookmark 1', 'Bookmark 3'])
            self.assertVisibleTags(['Tag 1', 'Tag 3'])
            self.assertReloads(0)
    def test_active_bookmarks_partial_update_on_bulk_delete(self):
        self.setup_fixture()
        with sync_playwright() as p:
            self.open(reverse('bookmarks:index'), p)
            self.locate_bulk_edit_toggle().click()
            self.locate_bookmark('Bookmark 2').locator('label[ld-bulk-edit-checkbox]').click()
            self.locate_bulk_edit_bar().get_by_text('Delete').click()
            self.locate_bulk_edit_bar().get_by_text('Confirm').click()
            self.assertVisibleBookmarks(['Bookmark 1', 'Bookmark 3'])
            self.assertVisibleTags(['Tag 1', 'Tag 3'])
            self.assertReloads(0)
    def test_archived_bookmarks_partial_update_on_unarchive(self):
        self.setup_fixture()
        with sync_playwright() as p:
            self.open(reverse('bookmarks:archived'), p)
            self.locate_bookmark('Archived Bookmark 2').get_by_text('Unarchive').click()
            self.assertVisibleBookmarks(['Archived Bookmark 1', 'Archived Bookmark 3'])
            self.assertVisibleTags(['Archived Tag 1', 'Archived Tag 3'])
            self.assertReloads(0)
    def test_archived_bookmarks_partial_update_on_delete(self):
        self.setup_fixture()
        with sync_playwright() as p:
            self.open(reverse('bookmarks:archived'), p)
            self.locate_bookmark('Archived Bookmark 2').get_by_text('Remove').click()
            self.locate_bookmark('Archived Bookmark 2').get_by_text('Confirm').click()
            self.assertVisibleBookmarks(['Archived Bookmark 1', 'Archived Bookmark 3'])
            self.assertVisibleTags(['Archived Tag 1', 'Archived Tag 3'])
            self.assertReloads(0)
    def test_archived_bookmarks_partial_update_on_bulk_archive(self):
        self.setup_fixture()
        with sync_playwright() as p:
            self.open(reverse('bookmarks:archived'), p)
            self.locate_bulk_edit_toggle().click()
            self.locate_bookmark('Archived Bookmark 2').locator('label[ld-bulk-edit-checkbox]').click()
            self.locate_bulk_edit_bar().get_by_text('Archive').click()
            self.locate_bulk_edit_bar().get_by_text('Confirm').click()
            self.assertVisibleBookmarks(['Archived Bookmark 1', 'Archived Bookmark 3'])
            self.assertVisibleTags(['Archived Tag 1', 'Archived Tag 3'])
            self.assertReloads(0)
    def test_archived_bookmarks_partial_update_on_bulk_delete(self):
        self.setup_fixture()
        with sync_playwright() as p:
            self.open(reverse('bookmarks:archived'), p)
            self.locate_bulk_edit_toggle().click()
            self.locate_bookmark('Archived Bookmark 2').locator('label[ld-bulk-edit-checkbox]').click()
            self.locate_bulk_edit_bar().get_by_text('Delete').click()
            self.locate_bulk_edit_bar().get_by_text('Confirm').click()
            self.assertVisibleBookmarks(['Archived Bookmark 1', 'Archived Bookmark 3'])
            self.assertVisibleTags(['Archived Tag 1', 'Archived Tag 3'])
            self.assertReloads(0)
    def test_shared_bookmarks_partial_update_on_unarchive(self):
        self.setup_fixture()
        self.setup_numbered_bookmarks(3, shared=True, prefix="My Bookmark", with_tags=True)
        with sync_playwright() as p:
            self.open(reverse('bookmarks:shared'), p)
            self.locate_bookmark('My Bookmark 2').get_by_text('Archive').click()
            # Shared bookmarks page also shows archived bookmarks, though it probably shouldn't
            self.assertVisibleBookmarks([
                'My Bookmark 1',
                'My Bookmark 2',
                'My Bookmark 3',
                "Joe's Bookmark 1",
                "Joe's Bookmark 2",
                "Joe's Bookmark 3",
            ])
            self.assertVisibleTags(['Shared Tag 1', 'Shared Tag 2', 'Shared Tag 3'])
            self.assertReloads(0)
    def test_shared_bookmarks_partial_update_on_delete(self):
        self.setup_fixture()
        self.setup_numbered_bookmarks(3, shared=True, prefix="My Bookmark", with_tags=True)
        with sync_playwright() as p:
            self.open(reverse('bookmarks:shared'), p)
            self.locate_bookmark('My Bookmark 2').get_by_text('Remove').click()
            self.locate_bookmark('My Bookmark 2').get_by_text('Confirm').click()
            self.assertVisibleBookmarks([
                'My Bookmark 1',
                'My Bookmark 3',
                "Joe's Bookmark 1",
                "Joe's Bookmark 2",
                "Joe's Bookmark 3",
            ])
            self.assertVisibleTags(['Shared Tag 1', 'Shared Tag 3'])
            self.assertReloads(0)
--- a/bookmarks/e2e/e2e_test_global_shortcuts.py
+++ b/bookmarks/e2e/e2e_test_global_shortcuts.py
@@ -0,0 +1,30 @@
 from django.urls import reverse
 from playwright.sync_api import sync_playwright, expect
 from bookmarks.e2e.helpers import LinkdingE2ETestCase
 class GlobalShortcutsE2ETestCase(LinkdingE2ETestCase):
    def test_focus_search(self):
        with sync_playwright() as p:
            browser = self.setup_browser(p)
            page = browser.new_page()
            page.goto(self.live_server_url + reverse('bookmarks:index'))
            page.press('body', 's')
            expect(page.get_by_placeholder('Search for words or #tags')).to_be_focused()
            browser.close()
    def test_add_bookmark(self):
        with sync_playwright() as p:
            browser = self.setup_browser(p)
            page = browser.new_page()
            page.goto(self.live_server_url + reverse('bookmarks:index'))
            page.press('body', 'n')
            expect(page).to_have_url(self.live_server_url + reverse('bookmarks:new'))
            browser.close()
--- a/bookmarks/e2e/e2e_test_settings_general.py
+++ b/bookmarks/e2e/e2e_test_settings_general.py
@@ -0,0 +1,39 @@
 from django.urls import reverse
 from playwright.sync_api import sync_playwright, expect
 from bookmarks.e2e.helpers import LinkdingE2ETestCase
 class SettingsGeneralE2ETestCase(LinkdingE2ETestCase):
    def test_should_only_enable_public_sharing_if_sharing_is_enabled(self):
        with sync_playwright() as p:
            browser = self.setup_browser(p)
            page = browser.new_page()
            page.goto(self.live_server_url + reverse('bookmarks:settings.general'))
            enable_sharing = page.get_by_label('Enable bookmark sharing')
            enable_sharing_label = page.get_by_text('Enable bookmark sharing')
            enable_public_sharing = page.get_by_label('Enable public bookmark sharing')
            enable_public_sharing_label = page.get_by_text('Enable public bookmark sharing')
            # Public sharing is disabled by default
            expect(enable_sharing).not_to_be_checked()
            expect(enable_public_sharing).not_to_be_checked()
            expect(enable_public_sharing).to_be_disabled()
            # Enable sharing
            enable_sharing_label.click()
            expect(enable_sharing).to_be_checked()
            expect(enable_public_sharing).not_to_be_checked()
            expect(enable_public_sharing).to_be_enabled()
            # Enable public sharing
            enable_public_sharing_label.click()
            expect(enable_public_sharing).to_be_checked()
            expect(enable_public_sharing).to_be_enabled()
            # Disable sharing
            enable_sharing_label.click()
            expect(enable_sharing).not_to_be_checked()
            expect(enable_public_sharing).not_to_be_checked()
            expect(enable_public_sharing).to_be_disabled()
--- a/bookmarks/e2e/helpers.py
+++ b/bookmarks/e2e/helpers.py
@@ -0,0 +1,45 @@
 from django.contrib.staticfiles.testing import LiveServerTestCase
 from playwright.sync_api import BrowserContext, Playwright, Page
 from bookmarks.tests.helpers import BookmarkFactoryMixin
 class LinkdingE2ETestCase(LiveServerTestCase, BookmarkFactoryMixin):
    def setUp(self) -> None:
        self.client.force_login(self.get_or_create_test_user())
        self.cookie = self.client.cookies['sessionid']
    def setup_browser(self, playwright) -> BrowserContext:
        browser = playwright.chromium.launch(headless=True)
        context = browser.new_context()
        context.add_cookies([{
            'name': 'sessionid',
            'value': self.cookie.value,
            'domain': self.live_server_url.replace('http:', ''),
            'path': '/'
        }])
        return context
    def open(self, url: str, playwright: Playwright) -> Page:
        browser = self.setup_browser(playwright)
        self.page = browser.new_page()
        self.page.goto(self.live_server_url + url)
        self.page.on('load', self.on_load)
        self.num_loads = 0
        return self.page
    def on_load(self):
        self.num_loads += 1
    def assertReloads(self, count: int):
        self.assertEqual(self.num_loads, count)
    def locate_bookmark(self, title: str):
        bookmark_tags = self.page.locator('li[ld-bookmark-item]')
        return bookmark_tags.filter(has_text=title)
    def locate_bulk_edit_bar(self):
        return self.page.locator('.bulk-edit-bar')
    def locate_bulk_edit_toggle(self):
        return self.page.get_by_title('Bulk edit')
--- a/bookmarks/feeds.py
+++ b/bookmarks/feeds.py
@@ -0,0 +1,56 @@
 from dataclasses import dataclass
 from django.contrib.syndication.views import Feed
 from django.db.models import QuerySet
 from django.urls import reverse
 from bookmarks.models import Bookmark, FeedToken
 from bookmarks import queries
@dataclass
 class FeedContext:
    feed_token: FeedToken
    query_set: QuerySet[Bookmark]
 class BaseBookmarksFeed(Feed):
    def get_object(self, request, feed_key: str):
        feed_token = FeedToken.objects.get(key__exact=feed_key)
        query_string = request.GET.get('q')
        query_set = queries.query_bookmarks(feed_token.user, feed_token.user.profile, query_string)
        return FeedContext(feed_token, query_set)
    def item_title(self, item: Bookmark):
        return item.resolved_title
    def item_description(self, item: Bookmark):
        return item.resolved_description
    def item_link(self, item: Bookmark):
        return item.url
    def item_pubdate(self, item: Bookmark):
        return item.date_added
 class AllBookmarksFeed(BaseBookmarksFeed):
    title = 'All bookmarks'
    description = 'All bookmarks'
    def link(self, context: FeedContext):
        return reverse('bookmarks:feeds.all', args=[context.feed_token.key])
    def items(self, context: FeedContext):
        return context.query_set
 class UnreadBookmarksFeed(BaseBookmarksFeed):
    title = 'Unread bookmarks'
    description = 'All unread bookmarks'
    def link(self, context: FeedContext):
        return reverse('bookmarks:feeds.unread', args=[context.feed_token.key])
    def items(self, context: FeedContext):
        return context.query_set.filter(unread=True)
--- a/bookmarks/frontend/api.js
+++ b/bookmarks/frontend/api.js
@@ -0,0 +1,29 @@
 export class ApiClient {
  constructor(baseUrl) {
    this.baseUrl = baseUrl;
  }
  listBookmarks(filters, options = { limit: 100, offset: 0, path: "" }) {
    const query = [`limit=${options.limit}`, `offset=${options.offset}`];
    Object.keys(filters).forEach((key) => {
      const value = filters[key];
      if (value) {
        query.push(`${key}=${encodeURIComponent(value)}`);
      }
    });
    const queryString = query.join("&");
    const url = `${this.baseUrl}bookmarks${options.path}/?${queryString}`;
    return fetch(url)
      .then((response) => response.json())
      .then((data) => data.results);
  }
  getTags(options = { limit: 100, offset: 0 }) {
    const url = `${this.baseUrl}tags/?limit=${options.limit}&offset=${options.offset}`;
    return fetch(url)
      .then((response) => response.json())
      .then((data) => data.results);
  }
 }
--- a/bookmarks/frontend/behaviors/bookmark-page.js
+++ b/bookmarks/frontend/behaviors/bookmark-page.js
@@ -0,0 +1,65 @@
 import { registerBehavior, swap } from "./index";
 class BookmarkPage {
  constructor(element) {
    this.element = element;
    this.form = element.querySelector("form.bookmark-actions");
    this.form.addEventListener("submit", this.onFormSubmit.bind(this));
    this.bookmarkList = element.querySelector(".bookmark-list-container");
    this.tagCloud = element.querySelector(".tag-cloud-container");
  }
  async onFormSubmit(event) {
    event.preventDefault();
    const url = this.form.action;
    const formData = new FormData(this.form);
    formData.append(event.submitter.name, event.submitter.value);
    await fetch(url, {
      method: "POST",
      body: formData,
      redirect: "manual", // ignore redirect
    });
    await this.refresh();
  }
  async refresh() {
    const query = window.location.search;
    const bookmarksUrl = this.element.getAttribute("bookmarks-url");
    const tagsUrl = this.element.getAttribute("tags-url");
    Promise.all([
      fetch(`${bookmarksUrl}${query}`).then((response) => response.text()),
      fetch(`${tagsUrl}${query}`).then((response) => response.text()),
    ]).then(([bookmarkListHtml, tagCloudHtml]) => {
      swap(this.bookmarkList, bookmarkListHtml);
      swap(this.tagCloud, tagCloudHtml);
      this.bookmarkList.dispatchEvent(
        new CustomEvent("bookmark-list-updated", { bubbles: true }),
      );
    });
  }
 }
 registerBehavior("ld-bookmark-page", BookmarkPage);
 class BookmarkItem {
  constructor(element) {
    this.element = element;
    const notesToggle = element.querySelector(".toggle-notes");
    if (notesToggle) {
      notesToggle.addEventListener("click", this.onToggleNotes.bind(this));
    }
  }
  onToggleNotes(event) {
    event.preventDefault();
    event.stopPropagation();
    this.element.classList.toggle("show-notes");
  }
 }
 registerBehavior("ld-bookmark-item", BookmarkItem);
--- a/bookmarks/frontend/behaviors/bulk-edit.js
+++ b/bookmarks/frontend/behaviors/bulk-edit.js
@@ -0,0 +1,100 @@
 import { registerBehavior } from "./index";
 class BulkEdit {
  constructor(element) {
    this.element = element;
    this.active = false;
    element.addEventListener(
      "bulk-edit-toggle-active",
      this.onToggleActive.bind(this),
    );
    element.addEventListener(
      "bulk-edit-toggle-all",
      this.onToggleAll.bind(this),
    );
    element.addEventListener(
      "bulk-edit-toggle-bookmark",
      this.onToggleBookmark.bind(this),
    );
    element.addEventListener(
      "bookmark-list-updated",
      this.onListUpdated.bind(this),
    );
  }
  get allCheckbox() {
    return this.element.querySelector("[ld-bulk-edit-checkbox][all] input");
  }
  get bookmarkCheckboxes() {
    return [
      ...this.element.querySelectorAll(
        "[ld-bulk-edit-checkbox]:not([all]) input",
      ),
    ];
  }
  onToggleActive() {
    this.active = !this.active;
    if (this.active) {
      this.element.classList.add("active", "activating");
      setTimeout(() => {
        this.element.classList.remove("activating");
      }, 500);
    } else {
      this.element.classList.remove("active");
    }
  }
  onToggleBookmark() {
    this.allCheckbox.checked = this.bookmarkCheckboxes.every((checkbox) => {
      return checkbox.checked;
    });
  }
  onToggleAll() {
    const checked = this.allCheckbox.checked;
    this.bookmarkCheckboxes.forEach((checkbox) => {
      checkbox.checked = checked;
    });
  }
  onListUpdated() {
    this.allCheckbox.checked = false;
    this.bookmarkCheckboxes.forEach((checkbox) => {
      checkbox.checked = false;
    });
  }
 }
 class BulkEditActiveToggle {
  constructor(element) {
    this.element = element;
    element.addEventListener("click", this.onClick.bind(this));
  }
  onClick() {
    this.element.dispatchEvent(
      new CustomEvent("bulk-edit-toggle-active", { bubbles: true }),
    );
  }
 }
 class BulkEditCheckbox {
  constructor(element) {
    this.element = element;
    element.addEventListener("change", this.onChange.bind(this));
  }
  onChange() {
    const type = this.element.hasAttribute("all") ? "all" : "bookmark";
    this.element.dispatchEvent(
      new CustomEvent(`bulk-edit-toggle-${type}`, { bubbles: true }),
    );
  }
 }
 registerBehavior("ld-bulk-edit", BulkEdit);
 registerBehavior("ld-bulk-edit-active-toggle", BulkEditActiveToggle);
 registerBehavior("ld-bulk-edit-checkbox", BulkEditCheckbox);
--- a/bookmarks/frontend/behaviors/confirm-button.js
+++ b/bookmarks/frontend/behaviors/confirm-button.js
@@ -0,0 +1,50 @@
 import { registerBehavior } from "./index";
 class ConfirmButtonBehavior {
  constructor(element) {
    const button = element;
    button.dataset.type = button.type;
    button.dataset.name = button.name;
    button.dataset.value = button.value;
    button.removeAttribute("type");
    button.removeAttribute("name");
    button.removeAttribute("value");
    button.addEventListener("click", this.onClick.bind(this));
    this.button = button;
  }
  onClick(event) {
    event.preventDefault();
    const cancelButton = document.createElement(this.button.nodeName);
    cancelButton.type = "button";
    cancelButton.innerText = "Cancel";
    cancelButton.className = "btn btn-link btn-sm mr-1";
    cancelButton.addEventListener("click", this.reset.bind(this));
    const confirmButton = document.createElement(this.button.nodeName);
    confirmButton.type = this.button.dataset.type;
    confirmButton.name = this.button.dataset.name;
    confirmButton.value = this.button.dataset.value;
    confirmButton.innerText = "Confirm";
    confirmButton.className = "btn btn-link btn-sm";
    confirmButton.addEventListener("click", this.reset.bind(this));
    const container = document.createElement("span");
    container.className = "confirmation";
    container.append(cancelButton, confirmButton);
    this.container = container;
    this.button.before(container);
    this.button.classList.add("d-none");
  }
  reset() {
    setTimeout(() => {
      this.container.remove();
      this.button.classList.remove("d-none");
    });
  }
 }
 registerBehavior("ld-confirm-button", ConfirmButtonBehavior);
--- a/bookmarks/frontend/behaviors/global-shortcuts.js
+++ b/bookmarks/frontend/behaviors/global-shortcuts.js
@@ -0,0 +1,73 @@
 import { registerBehavior } from "./index";
 class GlobalShortcuts {
  constructor() {
    document.addEventListener("keydown", this.onKeyDown.bind(this));
  }
  onKeyDown(event) {
    // Skip if event occurred within an input element
    const targetNodeName = event.target.nodeName;
    const isInputTarget =
      targetNodeName === "INPUT" ||
      targetNodeName === "SELECT" ||
      targetNodeName === "TEXTAREA";
    if (isInputTarget) {
      return;
    }
    // Handle shortcuts for navigating bookmarks with arrow keys
    const isArrowUp = event.key === "ArrowUp";
    const isArrowDown = event.key === "ArrowDown";
    if (isArrowUp || isArrowDown) {
      event.preventDefault();
      // Detect current bookmark list item
      const path = event.composedPath();
      const currentItem = path.find(
        (item) => item.hasAttribute && item.hasAttribute("ld-bookmark-item"),
      );
      // Find next item
      let nextItem;
      if (currentItem) {
        nextItem = isArrowUp
          ? currentItem.previousElementSibling
          : currentItem.nextElementSibling;
      } else {
        // Select first item
        nextItem = document.querySelector("[ld-bookmark-item]");
      }
      // Focus first link
      if (nextItem) {
        nextItem.querySelector("a").focus();
      }
    }
    // Handle shortcut for toggling all notes
    if (event.key === "e") {
      const list = document.querySelector(".bookmark-list");
      if (list) {
        list.classList.toggle("show-notes");
      }
    }
    // Handle shortcut for focusing search input
    if (event.key === "s") {
      const searchInput = document.querySelector('input[type="search"]');
      if (searchInput) {
        searchInput.focus();
        event.preventDefault();
      }
    }
    // Handle shortcut for adding new bookmark
    if (event.key === "n") {
      window.location.assign("/bookmarks/new");
    }
  }
 }
 registerBehavior("ld-global-shortcuts", GlobalShortcuts);
--- a/bookmarks/frontend/behaviors/index.js
+++ b/bookmarks/frontend/behaviors/index.js
@@ -0,0 +1,36 @@
 const behaviorRegistry = {};
 export function registerBehavior(name, behavior) {
  behaviorRegistry[name] = behavior;
  applyBehaviors(document, [name]);
 }
 export function applyBehaviors(container, behaviorNames = null) {
  if (!behaviorNames) {
    behaviorNames = Object.keys(behaviorRegistry);
  }
  behaviorNames.forEach((behaviorName) => {
    const behavior = behaviorRegistry[behaviorName];
    const elements = container.querySelectorAll(`[${behaviorName}]`);
    elements.forEach((element) => {
      element.__behaviors = element.__behaviors || [];
      const hasBehavior = element.__behaviors.some(
        (b) => b instanceof behavior,
      );
      if (hasBehavior) {
        return;
      }
      const behaviorInstance = new behavior(element);
      element.__behaviors.push(behaviorInstance);
    });
  });
 }
 export function swap(element, html) {
  element.innerHTML = html;
  applyBehaviors(element);
 }
--- a/bookmarks/frontend/behaviors/tag-autocomplete.js
+++ b/bookmarks/frontend/behaviors/tag-autocomplete.js
@@ -0,0 +1,26 @@
 import { registerBehavior } from "./index";
 import TagAutoCompleteComponent from "../components/TagAutocomplete.svelte";
 import { ApiClient } from "../api";
 class TagAutocomplete {
  constructor(element) {
    const wrapper = document.createElement("div");
    const apiBaseUrl = document.documentElement.dataset.apiBaseUrl || "";
    const apiClient = new ApiClient(apiBaseUrl);
    new TagAutoCompleteComponent({
      target: wrapper,
      props: {
        id: element.id,
        name: element.name,
        value: element.value,
        apiClient: apiClient,
        variant: element.getAttribute("variant"),
      },
    });
    element.replaceWith(wrapper);
  }
 }
 registerBehavior("ld-tag-autocomplete", TagAutocomplete);
--- a/bookmarks/frontend/components/SearchAutoComplete.svelte
+++ b/bookmarks/frontend/components/SearchAutoComplete.svelte
@@ -0,0 +1,272 @@
 <script>
  import {SearchHistory} from "./SearchHistory";
  import {clampText, debounce, getCurrentWord, getCurrentWordBounds} from "../util";
  const searchHistory = new SearchHistory()
  export let name;
  export let placeholder;
  export let value;
  export let tags;
  export let mode = '';
  export let apiClient;
  export let filters;
  let isFocus = false;
  let isOpen = false;
  let suggestions = []
  let selectedIndex = undefined;
  let input = null;
  // Track current search query after loading the page
  searchHistory.pushCurrent()
  updateSuggestions()
  function handleFocus() {
    isFocus = true;
  }
  function handleBlur() {
    isFocus = false;
    close();
  }
  function handleInput(e) {
    value = e.target.value
    debouncedLoadSuggestions()
  }
  function handleKeyDown(e) {
    // Enter
    if (isOpen && selectedIndex !== undefined && (e.keyCode === 13 || e.keyCode === 9)) {
      const suggestion = suggestions.total[selectedIndex];
      if (suggestion) completeSuggestion(suggestion);
      e.preventDefault();
    }
    // Escape
    if (e.keyCode === 27) {
      close();
      e.preventDefault();
    }
    // Up arrow
    if (e.keyCode === 38) {
      updateSelection(-1);
      e.preventDefault();
    }
    // Down arrow
    if (e.keyCode === 40) {
      if (!isOpen) {
        loadSuggestions()
      } else {
        updateSelection(1);
      }
      e.preventDefault();
    }
  }
  function open() {
    isOpen = true;
  }
  function close() {
    isOpen = false;
    updateSuggestions()
    selectedIndex = undefined
  }
  function hasSuggestions() {
    return suggestions.total.length > 0
  }
  async function loadSuggestions() {
    let suggestionIndex = 0
    function nextIndex() {
      return suggestionIndex++
    }
    // Tag suggestions
    let tagSuggestions = []
    const currentWord = getCurrentWord(input)
    if (currentWord && currentWord.length > 1 && currentWord[0] === '#') {
      const searchTag = currentWord.substring(1, currentWord.length)
      tagSuggestions = (tags || []).filter(tagName => tagName.toLowerCase().indexOf(searchTag.toLowerCase()) === 0)
        .slice(0, 5)
        .map(tagName => ({
          type: 'tag',
          index: nextIndex(),
          label: `#${tagName}`,
          tagName: tagName
        }))
    }
    // Recent search suggestions
    const search = searchHistory.getRecentSearches(value, 5).map(value => ({
      type: 'search',
      index: nextIndex(),
      label: value,
      value
    }))
    // Bookmark suggestions
    let bookmarks = []
    if (value && value.length >= 3) {
      const path = mode ? `/${mode}` : ''
      const suggestionFilters = {
        ...filters,
        q: value
      }
      const fetchedBookmarks = await apiClient.listBookmarks(suggestionFilters, {limit: 5, offset: 0, path})
      bookmarks = fetchedBookmarks.map(bookmark => {
        const fullLabel = bookmark.title || bookmark.website_title || bookmark.url
        const label = clampText(fullLabel, 60)
        return {
          type: 'bookmark',
          index: nextIndex(),
          label,
          bookmark
        }
      })
    }
    updateSuggestions(search, bookmarks, tagSuggestions)
    if (hasSuggestions()) {
      open()
    } else {
      close()
    }
  }
  const debouncedLoadSuggestions = debounce(loadSuggestions)
  function updateSuggestions(search, bookmarks, tagSuggestions) {
    search = search || []
    bookmarks = bookmarks || []
    tagSuggestions = tagSuggestions || []
    suggestions = {
      search,
      bookmarks,
      tags: tagSuggestions,
      total: [
        ...tagSuggestions,
        ...search,
        ...bookmarks,
      ]
    }
  }
  function completeSuggestion(suggestion) {
    if (suggestion.type === 'search') {
      value = suggestion.value
      close()
    }
    if (suggestion.type === 'bookmark') {
      window.open(suggestion.bookmark.url, '_blank')
      close()
    }
    if (suggestion.type === 'tag') {
      const bounds = getCurrentWordBounds(input);
      const inputValue = input.value;
      input.value = inputValue.substring(0, bounds.start) + `#${suggestion.tagName} ` + inputValue.substring(bounds.end);
      close()
    }
  }
  function updateSelection(dir) {
    const length = suggestions.total.length;
    if (length === 0) return
    if (selectedIndex === undefined) {
      selectedIndex = dir > 0 ? 0 : Math.max(length - 1, 0)
      return
    }
    let newIndex = selectedIndex + dir;
    if (newIndex < 0) newIndex = Math.max(length - 1, 0);
    if (newIndex >= length) newIndex = 0;
    selectedIndex = newIndex;
  }
 </script>
 <div class="form-autocomplete">
  <div class="form-autocomplete-input form-input" class:is-focused={isFocus}>
    <input type="search" class="form-input" name="{name}" placeholder="{placeholder}" autocomplete="off" value="{value}"
           bind:this={input}
           on:input={handleInput} on:keydown={handleKeyDown} on:focus={handleFocus} on:blur={handleBlur}>
  </div>
  <ul class="menu" class:open={isOpen}>
    {#if suggestions.tags.length > 0}
      <li class="menu-item group-item">Tags</li>
    {/if}
    {#each suggestions.tags as suggestion}
      <li class="menu-item" class:selected={selectedIndex === suggestion.index}>
        <a href="#" on:mousedown|preventDefault={() => completeSuggestion(suggestion)}>
          <div class="tile tile-centered">
            <div class="tile-content">
              {suggestion.label}
            </div>
          </div>
        </a>
      </li>
    {/each}
    {#if suggestions.search.length > 0}
      <li class="menu-item group-item">Recent Searches</li>
    {/if}
    {#each suggestions.search as suggestion}
      <li class="menu-item" class:selected={selectedIndex === suggestion.index}>
        <a href="#" on:mousedown|preventDefault={() => completeSuggestion(suggestion)}>
          <div class="tile tile-centered">
            <div class="tile-content">
              {suggestion.label}
            </div>
          </div>
        </a>
      </li>
    {/each}
    {#if suggestions.bookmarks.length > 0}
      <li class="menu-item group-item">Bookmarks</li>
    {/if}
    {#each suggestions.bookmarks as suggestion}
      <li class="menu-item" class:selected={selectedIndex === suggestion.index}>
        <a href="#" on:mousedown|preventDefault={() => completeSuggestion(suggestion)}>
          <div class="tile tile-centered">
            <div class="tile-content">
              {suggestion.label}
            </div>
          </div>
        </a>
      </li>
    {/each}
  </ul>
 </div>
 <style>
    .menu {
        display: none;
        max-height: 400px;
        overflow: auto;
    }
    .menu.open {
        display: block;
    }
    .form-autocomplete-input {
        padding: 0;
    }
    .form-autocomplete-input.is-focused {
        z-index: 2;
    }
 </style>
--- a/bookmarks/frontend/components/SearchHistory.js
+++ b/bookmarks/frontend/components/SearchHistory.js
@@ -0,0 +1,52 @@
 const SEARCH_HISTORY_KEY = "searchHistory";
 const MAX_ENTRIES = 30;
 export class SearchHistory {
  getHistory() {
    const historyJson = localStorage.getItem(SEARCH_HISTORY_KEY);
    return historyJson
      ? JSON.parse(historyJson)
      : {
          recent: [],
        };
  }
  pushCurrent() {
    // Skip if browser is not compatible
    if (!window.URLSearchParams) return;
    const urlParams = new URLSearchParams(window.location.search);
    const searchParam = urlParams.get("q");
    if (!searchParam) return;
    this.push(searchParam);
  }
  push(search) {
    const history = this.getHistory();
    history.recent.unshift(search);
    // Remove duplicates and clamp to max entries
    history.recent = history.recent.reduce((acc, cur) => {
      if (acc.length >= MAX_ENTRIES) return acc;
      if (acc.indexOf(cur) >= 0) return acc;
      acc.push(cur);
      return acc;
    }, []);
    const newHistoryJson = JSON.stringify(history);
    localStorage.setItem(SEARCH_HISTORY_KEY, newHistoryJson);
  }
  getRecentSearches(query, max) {
    const history = this.getHistory();
    return history.recent
      .filter(
        (search) =>
          !query || search.toLowerCase().indexOf(query.toLowerCase()) >= 0,
      )
      .slice(0, max);
  }
 }
--- a/bookmarks/frontend/components/TagAutocomplete.svelte
+++ b/bookmarks/frontend/components/TagAutocomplete.svelte
@@ -0,0 +1,170 @@
 <script>
  import {getCurrentWord, getCurrentWordBounds} from "../util";
  export let id;
  export let name;
  export let value;
  export let apiClient;
  export let variant = 'default';
  let tags = [];
  let isFocus = false;
  let isOpen = false;
  let input = null;
  let suggestionList = null;
  let suggestions = [];
  let selectedIndex = 0;
  init();
  async function init() {
    // For now we cache all tags on load as the template did before
    try {
      tags = await apiClient.getTags({limit: 1000, offset: 0});
      tags.sort((left, right) => left.name.toLowerCase().localeCompare(right.name.toLowerCase()))
    } catch (e) {
      console.warn('TagAutocomplete: Error loading tag list');
    }
  }
  function handleFocus() {
    isFocus = true;
  }
  function handleBlur() {
    isFocus = false;
    close();
  }
  function handleInput(e) {
    input = e.target;
    const word = getCurrentWord(input);
    suggestions = word
      ? tags.filter(tag => tag.name.toLowerCase().indexOf(word.toLowerCase()) === 0)
      : [];
    if (word && suggestions.length > 0) {
      open();
    } else {
      close();
    }
  }
  function handleKeyDown(e) {
    if (isOpen && (e.keyCode === 13 || e.keyCode === 9)) {
      const suggestion = suggestions[selectedIndex];
      complete(suggestion);
      e.preventDefault();
    }
    if (e.keyCode === 27) {
      close();
      e.preventDefault();
    }
    if (e.keyCode === 38) {
      updateSelection(-1);
      e.preventDefault();
    }
    if (e.keyCode === 40) {
      updateSelection(1);
      e.preventDefault();
    }
  }
  function open() {
    isOpen = true;
    selectedIndex = 0;
  }
  function close() {
    isOpen = false;
    suggestions = [];
    selectedIndex = 0;
  }
  function complete(suggestion) {
    const bounds = getCurrentWordBounds(input);
    const value = input.value;
    input.value = value.substring(0, bounds.start) + suggestion.name + ' ' + value.substring(bounds.end);
    close();
  }
  function updateSelection(dir) {
    const length = suggestions.length;
    let newIndex = selectedIndex + dir;
    if (newIndex < 0) newIndex = Math.max(length - 1, 0);
    if (newIndex >= length) newIndex = 0;
    selectedIndex = newIndex;
    // Scroll to selected list item
    setTimeout(() => {
      if (suggestionList) {
        const selectedListItem = suggestionList.querySelector('li.selected');
        if (selectedListItem) {
          selectedListItem.scrollIntoView({block: 'center'});
        }
      }
    }, 0);
  }
 </script>
 <div class="form-autocomplete" class:small={variant === 'small'}>
  <!-- autocomplete input container -->
  <div class="form-autocomplete-input form-input" class:is-focused={isFocus}>
    <!-- autocomplete real input box -->
    <input id="{id}" name="{name}" value="{value ||''}" placeholder="&nbsp;"
           class="form-input" type="text" autocomplete="off" autocapitalize="off"
           on:input={handleInput} on:keydown={handleKeyDown}
           on:focus={handleFocus} on:blur={handleBlur}>
  </div>
  <!-- autocomplete suggestion list -->
  <ul class="menu" class:open={isOpen && suggestions.length > 0}
      bind:this={suggestionList}>
    <!-- menu list items -->
    {#each suggestions as tag,i}
      <li class="menu-item" class:selected={selectedIndex === i}>
        <a href="#" on:mousedown|preventDefault={() => complete(tag)}>
          <div class="tile tile-centered">
            <div class="tile-content">
              {tag.name}
            </div>
          </div>
        </a>
      </li>
    {/each}
  </ul>
 </div>
 <style>
    .menu {
        display: none;
        max-height: 200px;
        overflow: auto;
    }
    .menu.open {
        display: block;
    }
    .form-autocomplete.small .form-autocomplete-input {
        height: 1.4rem;
        min-height: 1.4rem;
    }
    .form-autocomplete.small .form-autocomplete-input input {
        margin: 0;
        padding: 0;
        font-size: 0.7rem;
    }
    .form-autocomplete.small .menu .menu-item {
        font-size: 0.7rem;
    }
 </style>
--- a/bookmarks/frontend/index.js
+++ b/bookmarks/frontend/index.js
@@ -0,0 +1,14 @@
 import TagAutoComplete from "./components/TagAutocomplete.svelte";
 import SearchAutoComplete from "./components/SearchAutoComplete.svelte";
 import { ApiClient } from "./api";
 import "./behaviors/bookmark-page";
 import "./behaviors/bulk-edit";
 import "./behaviors/confirm-button";
 import "./behaviors/global-shortcuts";
 import "./behaviors/tag-autocomplete";
 export default {
  ApiClient,
  TagAutoComplete,
  SearchAutoComplete,
 };
--- a/bookmarks/frontend/util.js
+++ b/bookmarks/frontend/util.js
@@ -0,0 +1,37 @@
 export function debounce(callback, delay = 250) {
  let timeoutId;
  return (...args) => {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => {
      timeoutId = null;
      callback(...args);
    }, delay);
  };
 }
 export function clampText(text, maxChars = 30) {
  if (!text || text.length <= 30) return text;
  return text.substr(0, maxChars) + "...";
 }
 export function getCurrentWordBounds(input) {
  const text = input.value;
  const end = input.selectionStart;
  let start = end;
  let currentChar = text.charAt(start - 1);
  while (currentChar && currentChar !== " " && start > 0) {
    start--;
    currentChar = text.charAt(start - 1);
  }
  return { start, end };
 }
 export function getCurrentWord(input) {
  const bounds = getCurrentWordBounds(input);
  return input.value.substring(bounds.start, bounds.end);
 }
--- a/bookmarks/management/commands/clean_tasks.py
+++ b/bookmarks/management/commands/clean_tasks.py
@@ -0,0 +1,15 @@
 from background_task.models import Task, CompletedTask
 from django.core.management.base import BaseCommand
 class Command(BaseCommand):
    help = "Remove task locks and clear completed task history"
    def handle(self, *args, **options):
        # Remove task locks
        # If the background task processor exited while executing tasks, these tasks would still be marked as locked,
        # even though no process is working on them, and would prevent the task processor from picking the next task in
        # the queue
        Task.objects.all().update(locked_by=None, locked_at=None)
        # Clear task history to prevent them from bloating the DB
        CompletedTask.objects.all().delete()
--- a/bookmarks/management/commands/create_initial_superuser.py
+++ b/bookmarks/management/commands/create_initial_superuser.py
@@ -0,0 +1,37 @@
 import os
 import logging
 from django.core.management.base import BaseCommand
 from django.contrib.auth import get_user_model
 logger = logging.getLogger(__name__)
 class Command(BaseCommand):
    help = "Creates an initial superuser for a deployment using env variables"
    def handle(self, *args, **options):
        User = get_user_model()
        superuser_name = os.getenv('LD_SUPERUSER_NAME', None)
        superuser_password = os.getenv('LD_SUPERUSER_PASSWORD', None)
        # Skip if option is undefined
        if not superuser_name:
            logger.info('Skip creating initial superuser, LD_SUPERUSER_NAME option is not defined')
            return
        # Skip if user already exists
        user_exists = User.objects.filter(username=superuser_name).exists()
        if user_exists:
            logger.info('Skip creating initial superuser, user already exists')
            return
        user = User(username=superuser_name, is_superuser=True, is_staff=True)
        if superuser_password:
            user.set_password(superuser_password)
        else:
            user.set_unusable_password()
        user.save()
        logger.info('Created initial superuser')
--- a/bookmarks/management/commands/enable_wal.py
+++ b/bookmarks/management/commands/enable_wal.py
@@ -0,0 +1,24 @@
 import logging
 from django.conf import settings
 from django.core.management.base import BaseCommand
 from django.db import connections
 logger = logging.getLogger(__name__)
 class Command(BaseCommand):
    help = "Enable WAL journal mode when using an SQLite database"
    def handle(self, *args, **options):
        if settings.DATABASES['default']['ENGINE'] != 'django.db.backends.sqlite3':
            return
        connection = connections['default']
        with connection.cursor() as cursor:
            cursor.execute("PRAGMA journal_mode")
            current_mode = cursor.fetchone()[0]
            logger.info(f'Current journal mode: {current_mode}')
            if current_mode != 'wal':
                cursor.execute("PRAGMA journal_mode=wal;")
                logger.info('Switched to WAL journal mode')
--- a/bookmarks/middlewares.py
+++ b/bookmarks/middlewares.py
@@ -0,0 +1,24 @@
 from django.conf import settings
 from django.contrib.auth.middleware import RemoteUserMiddleware
 from bookmarks.models import UserProfile
 class CustomRemoteUserMiddleware(RemoteUserMiddleware):
    header = settings.LD_AUTH_PROXY_USERNAME_HEADER
 class UserProfileMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response
    def __call__(self, request):
        if request.user.is_authenticated:
            request.user_profile = request.user.profile
        else:
            request.user_profile = UserProfile()
            request.user_profile.enable_favicons = True
        response = self.get_response(request)
        return response
--- a/bookmarks/migrations/0009_bookmark_web_archive_snapshot_url.py
+++ b/bookmarks/migrations/0009_bookmark_web_archive_snapshot_url.py
@@ -0,0 +1,18 @@
 # Generated by Django 2.2.20 on 2021-05-16 14:35
 from django.db import migrations, models
 class Migration(migrations.Migration):
    dependencies = [
        ('bookmarks', '0008_userprofile_bookmark_date_display'),
    ]
    operations = [
        migrations.AddField(
            model_name='bookmark',
            name='web_archive_snapshot_url',
            field=models.CharField(blank=True, max_length=2048),
        ),
    ]
--- a/bookmarks/migrations/0010_userprofile_bookmark_link_target.py
+++ b/bookmarks/migrations/0010_userprofile_bookmark_link_target.py
@@ -0,0 +1,18 @@
 # Generated by Django 3.2.6 on 2021-10-03 06:35
 from django.db import migrations, models
 class Migration(migrations.Migration):
    dependencies = [
        ('bookmarks', '0009_bookmark_web_archive_snapshot_url'),
    ]
    operations = [
        migrations.AddField(
            model_name='userprofile',
            name='bookmark_link_target',
            field=models.CharField(choices=[('_blank', 'New page'), ('_self', 'Same page')], default='_blank', max_length=10),
        ),
    ]
--- a/bookmarks/migrations/0011_userprofile_web_archive_integration.py
+++ b/bookmarks/migrations/0011_userprofile_web_archive_integration.py
@@ -0,0 +1,18 @@
 # Generated by Django 3.2.6 on 2022-01-08 12:39
 from django.db import migrations, models
 class Migration(migrations.Migration):
    dependencies = [
        ('bookmarks', '0010_userprofile_bookmark_link_target'),
    ]
    operations = [
        migrations.AddField(
            model_name='userprofile',
            name='web_archive_integration',
            field=models.CharField(choices=[('disabled', 'Disabled'), ('enabled', 'Enabled')], default='disabled', max_length=10),
        ),
    ]
--- a/bookmarks/migrations/0012_toast.py
+++ b/bookmarks/migrations/0012_toast.py
@@ -0,0 +1,26 @@
 # Generated by Django 3.2.6 on 2022-01-08 19:24
 from django.conf import settings
 from django.db import migrations, models
 import django.db.models.deletion
 class Migration(migrations.Migration):
    dependencies = [
        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
        ('bookmarks', '0011_userprofile_web_archive_integration'),
    ]
    operations = [
        migrations.CreateModel(
            name='Toast',
            fields=[
                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('key', models.CharField(max_length=50)),
                ('message', models.TextField()),
                ('acknowledged', models.BooleanField(default=False)),
                ('owner', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
            ],
        ),
    ]
--- a/bookmarks/migrations/0013_web_archive_optin_toast.py
+++ b/bookmarks/migrations/0013_web_archive_optin_toast.py
@@ -0,0 +1,30 @@
 # Generated by Django 3.2.6 on 2022-01-08 19:27
 from django.db import migrations
 from django.contrib.auth import get_user_model
 from bookmarks.models import Toast
 User = get_user_model()
 def forwards(apps, schema_editor):
    for user in User.objects.all():
        toast = Toast(key='web_archive_opt_in_hint',
                      message='The Internet Archive Wayback Machine integration has been disabled by default. Check the Settings to re-enable it.',
                      owner=user)
        toast.save()
 def reverse(apps, schema_editor):
    Toast.objects.filter(key='web_archive_opt_in_hint').delete()
 class Migration(migrations.Migration):
    dependencies = [
        ('bookmarks', '0012_toast'),
    ]
    operations = [
        migrations.RunPython(forwards, reverse),
    ]
--- a/bookmarks/migrations/0014_alter_bookmark_unread.py
+++ b/bookmarks/migrations/0014_alter_bookmark_unread.py
@@ -0,0 +1,27 @@
 # Generated by Django 3.2.13 on 2022-07-23 12:30
 from django.db import migrations, models
 def forwards(apps, schema_editor):
    Bookmark = apps.get_model('bookmarks', 'Bookmark')
    Bookmark.objects.update(unread=False)
 def reverse(apps, schema_editor):
    pass
 class Migration(migrations.Migration):
    dependencies = [
        ('bookmarks', '0013_web_archive_optin_toast'),
    ]
    operations = [
        migrations.AlterField(
            model_name='bookmark',
            name='unread',
            field=models.BooleanField(default=False),
        ),
        migrations.RunPython(forwards, reverse),
    ]
--- a/bookmarks/migrations/0015_feedtoken.py
+++ b/bookmarks/migrations/0015_feedtoken.py
@@ -0,0 +1,24 @@
 # Generated by Django 3.2.13 on 2022-07-23 20:35
 from django.conf import settings
 from django.db import migrations, models
 import django.db.models.deletion
 class Migration(migrations.Migration):
    dependencies = [
        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
        ('bookmarks', '0014_alter_bookmark_unread'),
    ]
    operations = [
        migrations.CreateModel(
            name='FeedToken',
            fields=[
                ('key', models.CharField(max_length=40, primary_key=True, serialize=False)),
                ('created', models.DateTimeField(auto_now_add=True)),
                ('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='feed_token', to=settings.AUTH_USER_MODEL)),
            ],
        ),
    ]
--- a/bookmarks/migrations/0016_bookmark_shared.py
+++ b/bookmarks/migrations/0016_bookmark_shared.py
@@ -0,0 +1,18 @@
 # Generated by Django 3.2.14 on 2022-08-02 18:42
 from django.db import migrations, models
 class Migration(migrations.Migration):
    dependencies = [
        ('bookmarks', '0015_feedtoken'),
    ]
    operations = [
        migrations.AddField(
            model_name='bookmark',
            name='shared',
            field=models.BooleanField(default=False),
        ),
    ]
--- a/bookmarks/migrations/0017_userprofile_enable_sharing.py
+++ b/bookmarks/migrations/0017_userprofile_enable_sharing.py
@@ -0,0 +1,18 @@
 # Generated by Django 3.2.14 on 2022-08-04 09:08
 from django.db import migrations, models
 class Migration(migrations.Migration):
    dependencies = [
        ('bookmarks', '0016_bookmark_shared'),
    ]
    operations = [
        migrations.AddField(
            model_name='userprofile',
            name='enable_sharing',
            field=models.BooleanField(default=False),
        ),
    ]
--- a/bookmarks/migrations/0018_bookmark_favicon_file.py
+++ b/bookmarks/migrations/0018_bookmark_favicon_file.py
@@ -0,0 +1,18 @@
 # Generated by Django 4.1 on 2023-01-07 23:42
 from django.db import migrations, models
 class Migration(migrations.Migration):
    dependencies = [
        ('bookmarks', '0017_userprofile_enable_sharing'),
    ]
    operations = [
        migrations.AddField(
            model_name='bookmark',
            name='favicon_file',
            field=models.CharField(blank=True, max_length=512),
        ),
    ]
--- a/bookmarks/migrations/0019_userprofile_enable_favicons.py
+++ b/bookmarks/migrations/0019_userprofile_enable_favicons.py
@@ -0,0 +1,18 @@
 # Generated by Django 4.1 on 2023-01-09 21:16
 from django.db import migrations, models
 class Migration(migrations.Migration):
    dependencies = [
        ('bookmarks', '0018_bookmark_favicon_file'),
    ]
    operations = [
        migrations.AddField(
            model_name='userprofile',
            name='enable_favicons',
            field=models.BooleanField(default=False),
        ),
    ]
--- a/bookmarks/migrations/0020_userprofile_tag_search.py
+++ b/bookmarks/migrations/0020_userprofile_tag_search.py
@@ -0,0 +1,18 @@
 # Generated by Django 4.1.7 on 2023-04-10 01:55
 from django.db import migrations, models
 class Migration(migrations.Migration):
    dependencies = [
        ('bookmarks', '0019_userprofile_enable_favicons'),
    ]
    operations = [
        migrations.AddField(
            model_name='userprofile',
            name='tag_search',
            field=models.CharField(choices=[('strict', 'Strict'), ('lax', 'Lax')], default='strict', max_length=10),
        ),
    ]
--- a/bookmarks/migrations/0021_userprofile_display_url.py
+++ b/bookmarks/migrations/0021_userprofile_display_url.py
@@ -0,0 +1,18 @@
 # Generated by Django 4.1.7 on 2023-05-18 07:58
 from django.db import migrations, models
 class Migration(migrations.Migration):
    dependencies = [
        ('bookmarks', '0020_userprofile_tag_search'),
    ]
    operations = [
        migrations.AddField(
            model_name='userprofile',
            name='display_url',
            field=models.BooleanField(default=False),
        ),
    ]
--- a/bookmarks/migrations/0022_bookmark_notes.py
+++ b/bookmarks/migrations/0022_bookmark_notes.py
@@ -0,0 +1,18 @@
 # Generated by Django 4.1.7 on 2023-05-19 10:52
 from django.db import migrations, models
 class Migration(migrations.Migration):
    dependencies = [
        ('bookmarks', '0021_userprofile_display_url'),
    ]
    operations = [
        migrations.AddField(
            model_name='bookmark',
            name='notes',
            field=models.TextField(blank=True),
        ),
    ]
--- a/bookmarks/migrations/0023_userprofile_permanent_notes.py
+++ b/bookmarks/migrations/0023_userprofile_permanent_notes.py
@@ -0,0 +1,18 @@
 # Generated by Django 4.1.9 on 2023-05-20 08:00
 from django.db import migrations, models
 class Migration(migrations.Migration):
    dependencies = [
        ('bookmarks', '0022_bookmark_notes'),
    ]
    operations = [
        migrations.AddField(
            model_name='userprofile',
            name='permanent_notes',
            field=models.BooleanField(default=False),
        ),
    ]
--- a/bookmarks/migrations/0024_userprofile_enable_public_sharing.py
+++ b/bookmarks/migrations/0024_userprofile_enable_public_sharing.py
@@ -0,0 +1,18 @@
 # Generated by Django 4.1.9 on 2023-08-14 07:08
 from django.db import migrations, models
 class Migration(migrations.Migration):
    dependencies = [
        ('bookmarks', '0023_userprofile_permanent_notes'),
    ]
    operations = [
        migrations.AddField(
            model_name='userprofile',
            name='enable_public_sharing',
            field=models.BooleanField(default=False),
        ),
    ]
--- a/bookmarks/models.py
+++ b/bookmarks/models.py
@@ -1,8 +1,11 @@
 import binascii
 import os
 from typing import List
 from django import forms
 from django.contrib.auth import get_user_model
 from django.contrib.auth.models import User
 from django.core.handlers.wsgi import WSGIRequest
 from django.db import models
 from django.db.models.signals import post_save
 from django.dispatch import receiver
@@ -20,11 +23,19 @@ class Tag(models.Model):
        return self.name
 def sanitize_tag_name(tag_name: str):
    # strip leading/trailing spaces
    # replace inner spaces with replacement char
    return tag_name.strip().replace(' ', '-')
 def parse_tag_string(tag_string: str, delimiter: str = ','):
    if not tag_string:
        return []
    names = tag_string.strip().split(delimiter)
-    names = [name.strip() for name in names if name]
+    # remove empty names, sanitize remaining names
    names = [sanitize_tag_name(name) for name in names if name]
    # remove duplicates
    names = unique(names, str.lower)
    names.sort(key=str.lower)
@@ -39,21 +50,20 @@ class Bookmark(models.Model):
    url = models.CharField(max_length=2048, validators=[BookmarkURLValidator()])
    title = models.CharField(max_length=512, blank=True)
    description = models.TextField(blank=True)
    notes = models.TextField(blank=True)
    website_title = models.CharField(max_length=512, blank=True, null=True)
    website_description = models.TextField(blank=True, null=True)
-    unread = models.BooleanField(default=True)
+    web_archive_snapshot_url = models.CharField(max_length=2048, blank=True)
    favicon_file = models.CharField(max_length=512, blank=True)
    unread = models.BooleanField(default=False)
    is_archived = models.BooleanField(default=False)
    shared = models.BooleanField(default=False)
    date_added = models.DateTimeField()
    date_modified = models.DateTimeField()
    date_accessed = models.DateTimeField(blank=True, null=True)
    owner = models.ForeignKey(get_user_model(), on_delete=models.CASCADE)
    tags = models.ManyToManyField(Tag)
    # Attributes might be calculated in query
    tag_count = 0  # Projection for number of associated tags
    tag_string = ''  # Projection for list of tag names, comma-separated
    tag_projection = False  # Tracks if the above projections were loaded
    @property
    def resolved_title(self):
        if self.title:
@@ -69,11 +79,7 @@ class Bookmark(models.Model):
    @property
    def tag_names(self):
-        # If tag projections were loaded then avoid querying all tags (=executing further selects)
+        return [tag.name for tag in self.tags.all()]
        if self.tag_projection:
            return parse_tag_string(self.tag_string)
        else:
            return [tag.name for tag in self.tags.all()]
    def __str__(self):
        return self.resolved_title + ' (' + self.url[:30] + '...)'
@@ -88,14 +94,40 @@ class BookmarkForm(forms.ModelForm):
                            required=False)
    description = forms.CharField(required=False,
                                  widget=forms.Textarea())
    # Include website title and description as hidden field as they only provide info when editing bookmarks
    website_title = forms.CharField(max_length=512,
                                    required=False, widget=forms.HiddenInput())
    website_description = forms.CharField(required=False,
                                          widget=forms.HiddenInput())
    unread = forms.BooleanField(required=False)
    shared = forms.BooleanField(required=False)
    # Hidden field that determines whether to close window/tab after saving the bookmark
    auto_close = forms.CharField(required=False)
    # Hidden field that determines where to redirect after saving the form
    return_url = forms.CharField(required=False)
    class Meta:
        model = Bookmark
-        fields = ['url', 'tag_string', 'title', 'description', 'auto_close', 'return_url']
+        fields = [
            'url',
            'tag_string',
            'title',
            'description',
            'notes',
            'website_title',
            'website_description',
            'unread',
            'shared',
            'auto_close',
        ]
    @property
    def has_notes(self):
        return self.instance and self.instance.notes
 class BookmarkFilters:
    def __init__(self, request: WSGIRequest):
        self.query = request.GET.get('q') or ''
        self.user = request.GET.get('user') or ''
 class UserProfile(models.Model):
@@ -115,16 +147,46 @@ class UserProfile(models.Model):
        (BOOKMARK_DATE_DISPLAY_ABSOLUTE, 'Absolute'),
        (BOOKMARK_DATE_DISPLAY_HIDDEN, 'Hidden'),
    ]
    BOOKMARK_LINK_TARGET_BLANK = '_blank'
    BOOKMARK_LINK_TARGET_SELF = '_self'
    BOOKMARK_LINK_TARGET_CHOICES = [
        (BOOKMARK_LINK_TARGET_BLANK, 'New page'),
        (BOOKMARK_LINK_TARGET_SELF, 'Same page'),
    ]
    WEB_ARCHIVE_INTEGRATION_DISABLED = 'disabled'
    WEB_ARCHIVE_INTEGRATION_ENABLED = 'enabled'
    WEB_ARCHIVE_INTEGRATION_CHOICES = [
        (WEB_ARCHIVE_INTEGRATION_DISABLED, 'Disabled'),
        (WEB_ARCHIVE_INTEGRATION_ENABLED, 'Enabled'),
    ]
    TAG_SEARCH_STRICT = 'strict'
    TAG_SEARCH_LAX = 'lax'
    TAG_SEARCH_CHOICES = [
        (TAG_SEARCH_STRICT, 'Strict'),
        (TAG_SEARCH_LAX, 'Lax'),
    ]
    user = models.OneToOneField(get_user_model(), related_name='profile', on_delete=models.CASCADE)
    theme = models.CharField(max_length=10, choices=THEME_CHOICES, blank=False, default=THEME_AUTO)
    bookmark_date_display = models.CharField(max_length=10, choices=BOOKMARK_DATE_DISPLAY_CHOICES, blank=False,
                                             default=BOOKMARK_DATE_DISPLAY_RELATIVE)
    bookmark_link_target = models.CharField(max_length=10, choices=BOOKMARK_LINK_TARGET_CHOICES, blank=False,
                                            default=BOOKMARK_LINK_TARGET_BLANK)
    web_archive_integration = models.CharField(max_length=10, choices=WEB_ARCHIVE_INTEGRATION_CHOICES, blank=False,
                                               default=WEB_ARCHIVE_INTEGRATION_DISABLED)
    tag_search = models.CharField(max_length=10, choices=TAG_SEARCH_CHOICES, blank=False,
                                  default=TAG_SEARCH_STRICT)
    enable_sharing = models.BooleanField(default=False, null=False)
    enable_public_sharing = models.BooleanField(default=False, null=False)
    enable_favicons = models.BooleanField(default=False, null=False)
    display_url = models.BooleanField(default=False, null=False)
    permanent_notes = models.BooleanField(default=False, null=False)
 class UserProfileForm(forms.ModelForm):
    class Meta:
        model = UserProfile
-        fields = ['theme', 'bookmark_date_display']
+        fields = ['theme', 'bookmark_date_display', 'bookmark_link_target', 'web_archive_integration', 'tag_search',
                  'enable_sharing', 'enable_public_sharing', 'enable_favicons', 'display_url', 'permanent_notes']
@receiver(post_save, sender=get_user_model())
@@ -136,3 +198,34 @@ def create_user_profile(sender, instance, created, **kwargs):
@receiver(post_save, sender=get_user_model())
 def save_user_profile(sender, instance, **kwargs):
    instance.profile.save()
 class Toast(models.Model):
    key = models.CharField(max_length=50)
    message = models.TextField()
    acknowledged = models.BooleanField(default=False)
    owner = models.ForeignKey(get_user_model(), on_delete=models.CASCADE)
 class FeedToken(models.Model):
    """
    Adapted from authtoken.models.Token
    """
    key = models.CharField(max_length=40, primary_key=True)
    user = models.OneToOneField(get_user_model(),
                                related_name='feed_token',
                                on_delete=models.CASCADE,
                                )
    created = models.DateTimeField(auto_now_add=True)
    def save(self, *args, **kwargs):
        if not self.key:
            self.key = self.generate_key()
        return super().save(*args, **kwargs)
    @classmethod
    def generate_key(cls):
        return binascii.hexlify(os.urandom(20)).decode()
    def __str__(self):
        return self.key
--- a/bookmarks/queries.py
+++ b/bookmarks/queries.py
@@ -1,87 +1,115 @@
-from django.contrib.auth.models import User
+from typing import Optional
 from django.db.models import Q, Count, Aggregate, CharField, Value, BooleanField, QuerySet
-from bookmarks.models import Bookmark, Tag
+from django.contrib.auth.models import User
 from django.db.models import Q, QuerySet, Exists, OuterRef
 from bookmarks.models import Bookmark, Tag, UserProfile
 from bookmarks.utils import unique
-class Concat(Aggregate):
+def query_bookmarks(user: User, profile: UserProfile, query_string: str) -> QuerySet:
-    function = 'GROUP_CONCAT'
+    return _base_bookmarks_query(user, profile, query_string) \
    template = '%(function)s(%(distinct)s%(expressions)s)'
    def __init__(self, expression, distinct=False, **extra):
        super(Concat, self).__init__(
            expression,
            distinct='DISTINCT ' if distinct else '',
            output_field=CharField(),
            **extra)
 def query_bookmarks(user: User, query_string: str) -> QuerySet:
    return _base_bookmarks_query(user, query_string) \
        .filter(is_archived=False)
-def query_archived_bookmarks(user: User, query_string: str) -> QuerySet:
+def query_archived_bookmarks(user: User, profile: UserProfile, query_string: str) -> QuerySet:
-    return _base_bookmarks_query(user, query_string) \
+    return _base_bookmarks_query(user, profile, query_string) \
        .filter(is_archived=True)
-def _base_bookmarks_query(user: User, query_string: str) -> QuerySet:
+def query_shared_bookmarks(user: Optional[User], profile: UserProfile, query_string: str,
-    # Add aggregated tag info to bookmark instances
+                           public_only: bool) -> QuerySet:
-    query_set = Bookmark.objects \
+    conditions = Q(shared=True) & Q(owner__profile__enable_sharing=True)
-        .annotate(tag_count=Count('tags'),
+    if public_only:
-                  tag_string=Concat('tags__name'),
+        conditions = conditions & Q(owner__profile__enable_public_sharing=True)
-                  tag_projection=Value(True, BooleanField()))
+
    return _base_bookmarks_query(user, profile, query_string).filter(conditions)
 def _base_bookmarks_query(user: Optional[User], profile: UserProfile, query_string: str) -> QuerySet:
    query_set = Bookmark.objects
    # Filter for user
-    query_set = query_set.filter(owner=user)
+    if user:
        query_set = query_set.filter(owner=user)
    # Split query into search terms and tags
-    query = _parse_query_string(query_string)
+    query = parse_query_string(query_string)
    # Filter for search terms and tags
    for term in query['search_terms']:
-        query_set = query_set.filter(
+        conditions = Q(title__icontains=term) \
-            Q(title__contains=term)
+                     | Q(description__icontains=term) \
-            | Q(description__contains=term)
+                     | Q(notes__icontains=term) \
-            | Q(website_title__contains=term)
+                     | Q(website_title__icontains=term) \
-            | Q(website_description__contains=term)
+                     | Q(website_description__icontains=term) \
-            | Q(url__contains=term)
+                     | Q(url__icontains=term)
-        )
+
        if profile.tag_search == UserProfile.TAG_SEARCH_LAX:
            conditions = conditions | Exists(Bookmark.objects.filter(id=OuterRef('id'), tags__name__iexact=term))
        query_set = query_set.filter(conditions)
    for tag_name in query['tag_names']:
        query_set = query_set.filter(
            tags__name__iexact=tag_name
        )
    # Untagged bookmarks
    if query['untagged']:
        query_set = query_set.filter(
            tags=None
        )
    # Unread bookmarks
    if query['unread']:
        query_set = query_set.filter(
            unread=True
        )
    # Sort by date added
    query_set = query_set.order_by('-date_added')
    return query_set
-def query_bookmark_tags(user: User, query_string: str) -> QuerySet:
+def query_bookmark_tags(user: User, profile: UserProfile, query_string: str) -> QuerySet:
-    bookmarks_query = query_bookmarks(user, query_string)
+    bookmarks_query = query_bookmarks(user, profile, query_string)
    query_set = Tag.objects.filter(bookmark__in=bookmarks_query)
    return query_set.distinct()
-def query_archived_bookmark_tags(user: User, query_string: str) -> QuerySet:
+def query_archived_bookmark_tags(user: User, profile: UserProfile, query_string: str) -> QuerySet:
-    bookmarks_query = query_archived_bookmarks(user, query_string)
+    bookmarks_query = query_archived_bookmarks(user, profile, query_string)
    query_set = Tag.objects.filter(bookmark__in=bookmarks_query)
    return query_set.distinct()
 def query_shared_bookmark_tags(user: Optional[User], profile: UserProfile, query_string: str,
                               public_only: bool) -> QuerySet:
    bookmarks_query = query_shared_bookmarks(user, profile, query_string, public_only)
    query_set = Tag.objects.filter(bookmark__in=bookmarks_query)
    return query_set.distinct()
 def query_shared_bookmark_users(profile: UserProfile, query_string: str, public_only: bool) -> QuerySet:
    bookmarks_query = query_shared_bookmarks(None, profile, query_string, public_only)
    query_set = User.objects.filter(bookmark__in=bookmarks_query)
    return query_set.distinct()
 def get_user_tags(user: User):
    return Tag.objects.filter(owner=user).all()
-def _parse_query_string(query_string):
+def parse_query_string(query_string):
    # Sanitize query params
    if not query_string:
        query_string = ''
@@ -90,11 +118,17 @@ def _parse_query_string(query_string):
    keywords = query_string.strip().split(' ')
    keywords = [word for word in keywords if word]
-    search_terms = [word for word in keywords if word[0] != '#']
+    search_terms = [word for word in keywords if word[0] != '#' and word[0] != '!']
    tag_names = [word[1:] for word in keywords if word[0] == '#']
    tag_names = unique(tag_names, str.lower)
    # Special search commands
    untagged = '!untagged' in keywords
    unread = '!unread' in keywords
    return {
        'search_terms': search_terms,
        'tag_names': tag_names,
        'untagged': untagged,
        'unread': unread,
    }
--- a/bookmarks/services/bookmarks.py
+++ b/bookmarks/services/bookmarks.py
@@ -5,7 +5,8 @@ from django.utils import timezone
 from bookmarks.models import Bookmark, parse_tag_string
 from bookmarks.services.tags import get_or_create_tags
-from bookmarks.services.website_loader import load_website_metadata
+from bookmarks.services import website_loader
 from bookmarks.services import tasks
 def create_bookmark(bookmark: Bookmark, tag_string: str, current_user: User):
@@ -27,17 +28,33 @@ def create_bookmark(bookmark: Bookmark, tag_string: str, current_user: User):
    # Update tag list
    _update_bookmark_tags(bookmark, tag_string, current_user)
    bookmark.save()
    # Create snapshot on web archive
    tasks.create_web_archive_snapshot(current_user, bookmark, False)
    # Load favicon
    tasks.load_favicon(current_user, bookmark)
    return bookmark
 def update_bookmark(bookmark: Bookmark, tag_string, current_user: User):
-    # Update website info
+    # Detect URL change
-    _update_website_metadata(bookmark)
+    original_bookmark = Bookmark.objects.get(id=bookmark.id)
    has_url_changed = original_bookmark.url != bookmark.url
    # Update tag list
    _update_bookmark_tags(bookmark, tag_string, current_user)
    # Update dates
    bookmark.date_modified = timezone.now()
    bookmark.save()
    # Update favicon
    tasks.load_favicon(current_user, bookmark)
    if has_url_changed:
        # Update web archive snapshot, if URL changed
        tasks.create_web_archive_snapshot(current_user, bookmark, True)
        # Only update website metadata if URL changed
        _update_website_metadata(bookmark)
        bookmark.save()
    return bookmark
@@ -79,7 +96,7 @@ def delete_bookmarks(bookmark_ids: [Union[int, str]], current_user: User):
 def tag_bookmarks(bookmark_ids: [Union[int, str]], tag_string: str, current_user: User):
    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)
-    tag_names = parse_tag_string(tag_string, ' ')
+    tag_names = parse_tag_string(tag_string)
    tags = get_or_create_tags(tag_names, current_user)
    for bookmark in bookmarks:
@@ -92,7 +109,7 @@ def tag_bookmarks(bookmark_ids: [Union[int, str]], tag_string: str, current_user
 def untag_bookmarks(bookmark_ids: [Union[int, str]], tag_string: str, current_user: User):
    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)
-    tag_names = parse_tag_string(tag_string, ' ')
+    tag_names = parse_tag_string(tag_string)
    tags = get_or_create_tags(tag_names, current_user)
    for bookmark in bookmarks:
@@ -105,16 +122,19 @@ def untag_bookmarks(bookmark_ids: [Union[int, str]], tag_string: str, current_us
 def _merge_bookmark_data(from_bookmark: Bookmark, to_bookmark: Bookmark):
    to_bookmark.title = from_bookmark.title
    to_bookmark.description = from_bookmark.description
    to_bookmark.notes = from_bookmark.notes
    to_bookmark.unread = from_bookmark.unread
    to_bookmark.shared = from_bookmark.shared
 def _update_website_metadata(bookmark: Bookmark):
-    metadata = load_website_metadata(bookmark.url)
+    metadata = website_loader.load_website_metadata(bookmark.url)
    bookmark.website_title = metadata.title
    bookmark.website_description = metadata.description
 def _update_bookmark_tags(bookmark: Bookmark, tag_string: str, user: User):
-    tag_names = parse_tag_string(tag_string, ' ')
+    tag_names = parse_tag_string(tag_string)
    tags = get_or_create_tags(tag_names, user)
    bookmark.tags.set(tags)
--- a/bookmarks/services/exporter.py
+++ b/bookmarks/services/exporter.py
@@ -1,3 +1,4 @@
 import html
 from typing import List
 from bookmarks.models import Bookmark
@@ -28,13 +29,14 @@ def append_list_start(doc: BookmarkDocument):
 def append_bookmark(doc: BookmarkDocument, bookmark: Bookmark):
    url = bookmark.url
-    title = bookmark.resolved_title
+    title = html.escape(bookmark.resolved_title or '')
-    desc = bookmark.resolved_description
+    desc = html.escape(bookmark.resolved_description or '')
    tags = ','.join(bookmark.tag_names)
    toread = '1' if bookmark.unread else '0'
    private = '0' if bookmark.shared else '1'
    added = int(bookmark.date_added.timestamp())
-    doc.append(f'<DT><A HREF="{url}" ADD_DATE="{added}" PRIVATE="0" TOREAD="{toread}" TAGS="{tags}">{title}</A>')
+    doc.append(f'<DT><A HREF="{url}" ADD_DATE="{added}" PRIVATE="{private}" TOREAD="{toread}" TAGS="{tags}">{title}</A>')
    if desc:
        doc.append(f'<DD>{desc}')
--- a/bookmarks/services/favicon_loader.py
+++ b/bookmarks/services/favicon_loader.py
@@ -0,0 +1,83 @@
 import logging
 import mimetypes
 import os.path
 import re
 import time
 from pathlib import Path
 from urllib.parse import urlparse
 import requests
 from django.conf import settings
 max_file_age = 60 * 60 * 24  # 1 day
 logger = logging.getLogger(__name__)
 # register mime type for .ico files, which is not included in the default
 # mimetypes of the Docker image
 mimetypes.add_type('image/x-icon', '.ico')
 def _ensure_favicon_folder():
    Path(settings.LD_FAVICON_FOLDER).mkdir(parents=True, exist_ok=True)
 def _url_to_filename(url: str) -> str:
    return re.sub(r'\W+', '_', url)
 def _get_url_parameters(url: str) -> dict:
    parsed_uri = urlparse(url)
    return {
        # https://example.com/foo?bar -> https://example.com
        'url': f'{parsed_uri.scheme}://{parsed_uri.hostname}',
        # https://example.com/foo?bar -> example.com
        'domain': parsed_uri.hostname,
    }
 def _get_favicon_path(favicon_file: str) -> Path:
    return Path(os.path.join(settings.LD_FAVICON_FOLDER, favicon_file))
 def _check_existing_favicon(favicon_name: str):
    # return existing file if a file with the same name, ignoring extension,
    # exists and is not stale
    for filename in os.listdir(settings.LD_FAVICON_FOLDER):
        file_base_name, _ = os.path.splitext(filename)
        if file_base_name == favicon_name:
            favicon_path = _get_favicon_path(filename)
            return filename if not _is_stale(favicon_path) else None
    return None
 def _is_stale(path: Path) -> bool:
    stat = path.stat()
    file_age = time.time() - stat.st_mtime
    return file_age >= max_file_age
 def load_favicon(url: str) -> str:
    url_parameters = _get_url_parameters(url)
    # Create favicon folder if not exists
    _ensure_favicon_folder()
    # Use scheme+hostname as favicon filename to reuse icon for all pages on the same domain
    favicon_name = _url_to_filename(url_parameters['url'])
    favicon_file = _check_existing_favicon(favicon_name)
    if not favicon_file:
        # Load favicon from provider, save to file
        favicon_url = settings.LD_FAVICON_PROVIDER.format(**url_parameters)
        logger.debug(f'Loading favicon from: {favicon_url}')
        with requests.get(favicon_url, stream=True) as response:
            content_type = response.headers['Content-Type']
            file_extension = mimetypes.guess_extension(content_type)
            favicon_file = f'{favicon_name}{file_extension}'
            favicon_path = _get_favicon_path(favicon_file)
            with open(favicon_path, 'wb') as file:
                for chunk in response.iter_content(chunk_size=8192):
                    file.write(chunk)
        logger.debug(f'Saved favicon as: {favicon_path}')
    return favicon_file
--- a/bookmarks/services/importer.py
+++ b/bookmarks/services/importer.py
@@ -1,13 +1,14 @@
 import logging
 from dataclasses import dataclass
-from datetime import datetime
+from typing import List
 from django.contrib.auth.models import User
 from django.utils import timezone
-from bookmarks.models import Bookmark, parse_tag_string
+from bookmarks.models import Bookmark, Tag, parse_tag_string
 from bookmarks.services import tasks
 from bookmarks.services.parser import parse, NetscapeBookmark
-from bookmarks.services.tags import get_or_create_tags
+from bookmarks.utils import parse_timestamp
 logger = logging.getLogger(__name__)
@@ -19,8 +20,44 @@ class ImportResult:
    failed: int = 0
-def import_netscape_html(html: str, user: User):
+@dataclass
 class ImportOptions:
    map_private_flag: bool = False
 class TagCache:
    def __init__(self, user: User):
        self.user = user
        self.cache = dict()
        # Init cache with all existing tags for that user
        tags = Tag.objects.filter(owner=user)
        for tag in tags:
            self.put(tag)
    def get(self, tag_name: str):
        tag_name_lowercase = tag_name.lower()
        if tag_name_lowercase in self.cache:
            return self.cache[tag_name_lowercase]
        else:
            return None
    def get_all(self, tag_names: List[str]):
        result = []
        for tag_name in tag_names:
            tag = self.get(tag_name)
            # Prevent returning duplicates
            if not (tag in result):
                result.append(tag)
        return result
    def put(self, tag: Tag):
        self.cache[tag.name.lower()] = tag
 def import_netscape_html(html: str, user: User, options: ImportOptions = ImportOptions()) -> ImportResult:
    result = ImportResult()
    import_start = timezone.now()
    try:
        netscape_bookmarks = parse(html)
@@ -28,47 +65,154 @@ def import_netscape_html(html: str, user: User):
        logging.exception('Could not read bookmarks file.')
        raise
    parse_end = timezone.now()
    logger.debug(f'Parse duration: {parse_end - import_start}')
    # Create and cache all tags beforehand
    _create_missing_tags(netscape_bookmarks, user)
    tag_cache = TagCache(user)
    # Split bookmarks to import into batches, to keep memory usage for bulk operations manageable
    batches = _get_batches(netscape_bookmarks, 200)
    for batch in batches:
        _import_batch(batch, user, options, tag_cache, result)
    # Create snapshots for newly imported bookmarks
    tasks.schedule_bookmarks_without_snapshots(user)
    # Load favicons for newly imported bookmarks
    tasks.schedule_bookmarks_without_favicons(user)
    end = timezone.now()
    logger.debug(f'Import duration: {end - import_start}')
    return result
 def _create_missing_tags(netscape_bookmarks: List[NetscapeBookmark], user: User):
    tag_cache = TagCache(user)
    tags_to_create = []
    for netscape_bookmark in netscape_bookmarks:
        tag_names = parse_tag_string(netscape_bookmark.tag_string)
        for tag_name in tag_names:
            tag = tag_cache.get(tag_name)
            if not tag:
                tag = Tag(name=tag_name, owner=user)
                tag.date_added = timezone.now()
                tags_to_create.append(tag)
                tag_cache.put(tag)
    Tag.objects.bulk_create(tags_to_create)
 def _get_batches(items: List, batch_size: int):
    batches = []
    offset = 0
    num_items = len(items)
    while offset < num_items:
        batch = items[offset:min(offset + batch_size, num_items)]
        if len(batch) > 0:
            batches.append(batch)
        offset = offset + batch_size
    return batches
 def _import_batch(netscape_bookmarks: List[NetscapeBookmark],
                  user: User,
                  options: ImportOptions,
                  tag_cache: TagCache,
                  result: ImportResult):
    # Query existing bookmarks
    batch_urls = [bookmark.href for bookmark in netscape_bookmarks]
    existing_bookmarks = Bookmark.objects.filter(owner=user, url__in=batch_urls)
    # Create or update bookmarks from parsed Netscape bookmarks
    bookmarks_to_create = []
    bookmarks_to_update = []
    for netscape_bookmark in netscape_bookmarks:
        result.total = result.total + 1
        try:
-            _import_bookmark_tag(netscape_bookmark, user)
+            # Lookup existing bookmark by URL, or create new bookmark if there is no bookmark for that URL yet
            bookmark = next(
                (bookmark for bookmark in existing_bookmarks if bookmark.url == netscape_bookmark.href), None)
            if not bookmark:
                bookmark = Bookmark(owner=user)
                is_update = False
            else:
                is_update = True
            # Copy data from parsed bookmark
            _copy_bookmark_data(netscape_bookmark, bookmark, options)
            # Validate bookmark fields, exclude owner to prevent n+1 database query,
            # also there is no specific validation on owner
            bookmark.clean_fields(exclude=['owner'])
            # Schedule for update or insert
            if is_update:
                bookmarks_to_update.append(bookmark)
            else:
                bookmarks_to_create.append(bookmark)
            result.success = result.success + 1
        except:
            shortened_bookmark_tag_str = str(netscape_bookmark)[:100] + '...'
            logging.exception('Error importing bookmark: ' + shortened_bookmark_tag_str)
            result.failed = result.failed + 1
-    return result
+    # Bulk update bookmarks in DB
    Bookmark.objects.bulk_update(bookmarks_to_update, ['url',
                                                       'date_added',
                                                       'date_modified',
                                                       'unread',
                                                       'shared',
                                                       'title',
                                                       'description',
                                                       'owner'])
    # Bulk insert new bookmarks into DB
    Bookmark.objects.bulk_create(bookmarks_to_create)
    # Bulk assign tags
    # In Django 3, bulk_create does not return the auto-generated IDs when bulk inserting,
    # so we have to reload the inserted bookmarks, and match them to the parsed bookmarks by URL
    existing_bookmarks = Bookmark.objects.filter(owner=user, url__in=batch_urls)
    BookmarkToTagRelationShip = Bookmark.tags.through
    relationships = []
    for netscape_bookmark in netscape_bookmarks:
        # Lookup bookmark by URL again
        bookmark = next(
            (bookmark for bookmark in existing_bookmarks if bookmark.url == netscape_bookmark.href), None)
        if not bookmark:
            # Something is wrong, we should have just created this bookmark
            shortened_bookmark_tag_str = str(netscape_bookmark)[:100] + '...'
            logging.warning(
                f'Failed to assign tags to the bookmark: {shortened_bookmark_tag_str}. Could not find bookmark by URL.')
            continue
        # Get tag models by string, schedule inserts for bookmark -> tag associations
        tag_names = parse_tag_string(netscape_bookmark.tag_string)
        tags = tag_cache.get_all(tag_names)
        for tag in tags:
            relationships.append(BookmarkToTagRelationShip(bookmark=bookmark, tag=tag))
    # Insert all bookmark -> tag associations at once, should ignore errors if association already exists
    BookmarkToTagRelationShip.objects.bulk_create(relationships, ignore_conflicts=True)
-def _import_bookmark_tag(netscape_bookmark: NetscapeBookmark, user: User):
+def _copy_bookmark_data(netscape_bookmark: NetscapeBookmark, bookmark: Bookmark, options: ImportOptions):
    # Either modify existing bookmark for the URL or create new one
    bookmark = _get_or_create_bookmark(netscape_bookmark.href, user)
    bookmark.url = netscape_bookmark.href
    if netscape_bookmark.date_added:
-        bookmark.date_added = datetime.utcfromtimestamp(int(netscape_bookmark.date_added)).astimezone()
+        bookmark.date_added = parse_timestamp(netscape_bookmark.date_added)
    else:
        bookmark.date_added = timezone.now()
    bookmark.date_modified = bookmark.date_added
-    bookmark.unread = False
+    bookmark.unread = netscape_bookmark.to_read
-    bookmark.title = netscape_bookmark.title
+    if netscape_bookmark.title:
        bookmark.title = netscape_bookmark.title
    if netscape_bookmark.description:
        bookmark.description = netscape_bookmark.description
-    bookmark.owner = user
+    if options.map_private_flag and not netscape_bookmark.private:
-
+        bookmark.shared = True
    bookmark.save()
    # Set tags
    tag_names = parse_tag_string(netscape_bookmark.tag_string)
    tags = get_or_create_tags(tag_names, user)
    bookmark.tags.set(tags)
    bookmark.save()
 def _get_or_create_bookmark(url: str, user: User):
    try:
        return Bookmark.objects.get(url=url, owner=user)
    except Bookmark.DoesNotExist:
        return Bookmark()
--- a/bookmarks/services/parser.py
+++ b/bookmarks/services/parser.py
@@ -1,6 +1,6 @@
 from dataclasses import dataclass
-
+from html.parser import HTMLParser
-import pyparsing as pp
+from typing import Dict, List
@dataclass
@@ -10,62 +10,83 @@ class NetscapeBookmark:
    description: str
    date_added: str
    tag_string: str
    to_read: bool
    private: bool
-def extract_bookmark_link(tag):
+class BookmarkParser(HTMLParser):
-    href = tag[0].href
+    def __init__(self):
-    title = tag[0].text
+        super().__init__()
-    tag_string = tag[0].tags
+        self.bookmarks = []
    date_added = tag[0].add_date
-    return {
+        self.current_tag = None
-        'href': href,
+        self.bookmark = None
-        'title': title,
+        self.href = ''
-        'tag_string': tag_string,
+        self.add_date = ''
-        'date_added': date_added
+        self.tags = ''
-    }
+        self.title = ''
        self.description = ''
        self.toread = ''
        self.private = ''
    def handle_starttag(self, tag: str, attrs: list):
        name = 'handle_start_' + tag.lower()
        if name in dir(self):
            getattr(self, name)({k.lower(): v for k, v in attrs})
        self.current_tag = tag
-def extract_bookmark(tag):
+    def handle_endtag(self, tag: str):
-    link = tag[0].link
+        name = 'handle_end_' + tag.lower()
-    description = tag[0].description
+        if name in dir(self):
-    description = description[0] if description else ''
+            getattr(self, name)()
        self.current_tag = None
-    return {
+    def handle_data(self, data):
-        'link': link,
+        name = f'handle_{self.current_tag}_data'
-        'description': description,
+        if name in dir(self):
-    }
+            getattr(self, name)(data)
    def handle_end_dl(self):
        self.add_bookmark()
-def extract_description(tag):
+    def handle_start_dt(self, attrs: Dict[str, str]):
-    return tag[0].strip()
+        self.add_bookmark()
-
+    def handle_start_a(self, attrs: Dict[str, str]):
-# define grammar
+        vars(self).update(attrs)
-dt_start, _ = pp.makeHTMLTags("DT")
+        self.bookmark = NetscapeBookmark(
-dd_start, _ = pp.makeHTMLTags("DD")
+            href=self.href,
-a_start, a_end = pp.makeHTMLTags("A")
+            title='',
-bookmark_link_tag = pp.Group(a_start + a_start.tag_body("text") + a_end.suppress())
+            description='',
-bookmark_link_tag.addParseAction(extract_bookmark_link)
+            date_added=self.add_date,
-bookmark_description_tag = dd_start.suppress() + pp.SkipTo(pp.anyOpenTag | pp.anyCloseTag)("description")
+            tag_string=self.tags,
-bookmark_description_tag.addParseAction(extract_description)
+            to_read=self.toread == '1',
-bookmark_tag = pp.Group(dt_start + bookmark_link_tag("link") + pp.ZeroOrMore(bookmark_description_tag)("description"))
+            # Mark as private by default, also when attribute is not specified
-bookmark_tag.addParseAction(extract_bookmark)
+            private=self.private != '0',
 def parse(html: str) -> [NetscapeBookmark]:
    matches = bookmark_tag.searchString(html)
    bookmarks = []
    for match in matches:
        bookmark_match = match[0]
        bookmark = NetscapeBookmark(
            href=bookmark_match['link']['href'],
            title=bookmark_match['link']['title'],
            description=bookmark_match['description'],
            tag_string=bookmark_match['link']['tag_string'],
            date_added=bookmark_match['link']['date_added'],
        )
        bookmarks.append(bookmark)
-    return bookmarks
+    def handle_a_data(self, data):
        self.title = data.strip()
    def handle_dd_data(self, data):
        self.description = data.strip()
    def add_bookmark(self):
        if self.bookmark:
            self.bookmark.title = self.title
            self.bookmark.description = self.description
            self.bookmarks.append(self.bookmark)
        self.bookmark = None
        self.href = ''
        self.add_date = ''
        self.tags = ''
        self.title = ''
        self.description = ''
        self.toread = ''
        self.private = ''
 def parse(html: str) -> List[NetscapeBookmark]:
    parser = BookmarkParser()
    parser.feed(html)
    return parser.bookmarks
--- a/bookmarks/services/tasks.py
+++ b/bookmarks/services/tasks.py
@@ -0,0 +1,174 @@
 import logging
 import waybackpy
 from background_task import background
 from background_task.models import Task
 from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.contrib.auth.models import User
 from waybackpy.exceptions import WaybackError, TooManyRequestsError, NoCDXRecordFound
 import bookmarks.services.wayback
 from bookmarks.models import Bookmark, UserProfile
 from bookmarks.services import favicon_loader
 from bookmarks.services.website_loader import DEFAULT_USER_AGENT
 logger = logging.getLogger(__name__)
 def is_web_archive_integration_active(user: User) -> bool:
    background_tasks_enabled = not settings.LD_DISABLE_BACKGROUND_TASKS
    web_archive_integration_enabled = \
        user.profile.web_archive_integration == UserProfile.WEB_ARCHIVE_INTEGRATION_ENABLED
    return background_tasks_enabled and web_archive_integration_enabled
 def create_web_archive_snapshot(user: User, bookmark: Bookmark, force_update: bool):
    if is_web_archive_integration_active(user):
        _create_web_archive_snapshot_task(bookmark.id, force_update)
 def _load_newest_snapshot(bookmark: Bookmark):
    try:
        logger.info(f'Load existing snapshot for bookmark. url={bookmark.url}')
        cdx_api = bookmarks.services.wayback.CustomWaybackMachineCDXServerAPI(bookmark.url)
        existing_snapshot = cdx_api.newest()
        if existing_snapshot:
            bookmark.web_archive_snapshot_url = existing_snapshot.archive_url
            bookmark.save(update_fields=['web_archive_snapshot_url'])
            logger.info(f'Using newest snapshot. url={bookmark.url} from={existing_snapshot.datetime_timestamp}')
    except NoCDXRecordFound:
        logger.info(f'Could not find any snapshots for bookmark. url={bookmark.url}')
    except WaybackError as error:
        logger.error(f'Failed to load existing snapshot. url={bookmark.url}', exc_info=error)
 def _create_snapshot(bookmark: Bookmark):
    logger.info(f'Create new snapshot for bookmark. url={bookmark.url}...')
    archive = waybackpy.WaybackMachineSaveAPI(bookmark.url, DEFAULT_USER_AGENT, max_tries=1)
    archive.save()
    bookmark.web_archive_snapshot_url = archive.archive_url
    bookmark.save(update_fields=['web_archive_snapshot_url'])
    logger.info(f'Successfully created new snapshot for bookmark:. url={bookmark.url}')
@background()
 def _create_web_archive_snapshot_task(bookmark_id: int, force_update: bool):
    try:
        bookmark = Bookmark.objects.get(id=bookmark_id)
    except Bookmark.DoesNotExist:
        return
    # Skip if snapshot exists and update is not explicitly requested
    if bookmark.web_archive_snapshot_url and not force_update:
        return
    # Create new snapshot
    try:
        _create_snapshot(bookmark)
        return
    except TooManyRequestsError:
        logger.error(
            f'Failed to create snapshot due to rate limiting, trying to load newest snapshot as fallback. url={bookmark.url}')
    except WaybackError as error:
        logger.error(f'Failed to create snapshot, trying to load newest snapshot as fallback. url={bookmark.url}',
                     exc_info=error)
    # Load the newest snapshot as fallback
    _load_newest_snapshot(bookmark)
@background()
 def _load_web_archive_snapshot_task(bookmark_id: int):
    try:
        bookmark = Bookmark.objects.get(id=bookmark_id)
    except Bookmark.DoesNotExist:
        return
    # Skip if snapshot exists
    if bookmark.web_archive_snapshot_url:
        return
    # Load the newest snapshot
    _load_newest_snapshot(bookmark)
 def schedule_bookmarks_without_snapshots(user: User):
    if is_web_archive_integration_active(user):
        _schedule_bookmarks_without_snapshots_task(user.id)
@background()
 def _schedule_bookmarks_without_snapshots_task(user_id: int):
    user = get_user_model().objects.get(id=user_id)
    bookmarks_without_snapshots = Bookmark.objects.filter(web_archive_snapshot_url__exact='', owner=user)
    for bookmark in bookmarks_without_snapshots:
        # To prevent rate limit errors from the Wayback API only try to load the latest snapshots instead of creating
        # new ones when processing bookmarks in bulk
        _load_web_archive_snapshot_task(bookmark.id)
 def is_favicon_feature_active(user: User) -> bool:
    background_tasks_enabled = not settings.LD_DISABLE_BACKGROUND_TASKS
    return background_tasks_enabled and user.profile.enable_favicons
 def load_favicon(user: User, bookmark: Bookmark):
    if is_favicon_feature_active(user):
        _load_favicon_task(bookmark.id)
@background()
 def _load_favicon_task(bookmark_id: int):
    try:
        bookmark = Bookmark.objects.get(id=bookmark_id)
    except Bookmark.DoesNotExist:
        return
    logger.info(f'Load favicon for bookmark. url={bookmark.url}')
    new_favicon_file = favicon_loader.load_favicon(bookmark.url)
    if new_favicon_file != bookmark.favicon_file:
        bookmark.favicon_file = new_favicon_file
        bookmark.save(update_fields=['favicon_file'])
        logger.info(f'Successfully updated favicon for bookmark. url={bookmark.url} icon={new_favicon_file}')
 def schedule_bookmarks_without_favicons(user: User):
    if is_favicon_feature_active(user):
        _schedule_bookmarks_without_favicons_task(user.id)
@background()
 def _schedule_bookmarks_without_favicons_task(user_id: int):
    user = get_user_model().objects.get(id=user_id)
    bookmarks = Bookmark.objects.filter(favicon_file__exact='', owner=user)
    tasks = []
    for bookmark in bookmarks:
        task = Task.objects.new_task(task_name='bookmarks.services.tasks._load_favicon_task', args=(bookmark.id,))
        tasks.append(task)
    Task.objects.bulk_create(tasks)
 def schedule_refresh_favicons(user: User):
    if is_favicon_feature_active(user) and settings.LD_ENABLE_REFRESH_FAVICONS:
        _schedule_refresh_favicons_task(user.id)
@background()
 def _schedule_refresh_favicons_task(user_id: int):
    user = get_user_model().objects.get(id=user_id)
    bookmarks = Bookmark.objects.filter(owner=user)
    tasks = []
    for bookmark in bookmarks:
        task = Task.objects.new_task(task_name='bookmarks.services.tasks._load_favicon_task', args=(bookmark.id,))
        tasks.append(task)
    Task.objects.bulk_create(tasks)
--- a/bookmarks/services/wayback.py
+++ b/bookmarks/services/wayback.py
@@ -0,0 +1,40 @@
 import time
 from typing import Dict
 import waybackpy
 import waybackpy.utils
 from waybackpy.exceptions import NoCDXRecordFound
 class CustomWaybackMachineCDXServerAPI(waybackpy.WaybackMachineCDXServerAPI):
    """
    Customized WaybackMachineCDXServerAPI to work around some issues with retrieving the newest snapshot.
    See https://github.com/akamhy/waybackpy/issues/176
    """
    def newest(self):
        unix_timestamp = int(time.time())
        self.closest = waybackpy.utils.unix_timestamp_to_wayback_timestamp(unix_timestamp)
        self.sort = 'closest'
        self.limit = -5
        newest_snapshot = None
        for snapshot in self.snapshots():
            newest_snapshot = snapshot
            break
        if not newest_snapshot:
            raise NoCDXRecordFound(
                "Wayback Machine's CDX server did not return any records "
                + "for the query. The URL may not have any archives "
                + " on the Wayback Machine or the URL may have been recently "
                + "archived and is still not available on the CDX server."
            )
        return newest_snapshot
    def add_payload(self, payload: Dict[str, str]) -> None:
        super().add_payload(payload)
        # Set fastLatest query param, as we are only using this API to get the latest snapshot and using fastLatest
        # makes searching for latest snapshots faster
        payload['fastLatest'] = 'true'
--- a/bookmarks/services/website_loader.py
+++ b/bookmarks/services/website_loader.py
@@ -1,7 +1,13 @@
 import logging
 from dataclasses import dataclass
 from functools import lru_cache
 import requests
 from bs4 import BeautifulSoup
 from charset_normalizer import from_bytes
 from django.utils import timezone
 logger = logging.getLogger(__name__)
@dataclass
@@ -18,20 +24,81 @@ class WebsiteMetadata:
        }
 # Caching metadata avoids scraping again when saving bookmarks, in case the
 # metadata was already scraped to show preview values in the bookmark form
@lru_cache(maxsize=10)
 def load_website_metadata(url: str):
    title = None
    description = None
    try:
        start = timezone.now()
        page_text = load_page(url)
        end = timezone.now()
        logger.debug(f'Load duration: {end - start}')
        start = timezone.now()
        soup = BeautifulSoup(page_text, 'html.parser')
-        title = soup.title.string if soup.title is not None else None
+        title = soup.title.string.strip() if soup.title is not None else None
        description_tag = soup.find('meta', attrs={'name': 'description'})
-        description = description_tag['content'] if description_tag is not None else None
+        description = description = description_tag['content'].strip() if description_tag and description_tag[
            'content'] else None
        end = timezone.now()
        logger.debug(f'Parsing duration: {end - start}')
    finally:
        return WebsiteMetadata(url=url, title=title, description=description)
 CHUNK_SIZE = 50 * 1024
 MAX_CONTENT_LIMIT = 5000 * 1024
 def load_page(url: str):
-    r = requests.get(url)
+    headers = fake_request_headers()
-    return r.text
+    size = 0
    content = None
    iteration = 0
    # Use with to ensure request gets closed even if it's only read partially
    with requests.get(url, timeout=10, headers=headers, stream=True) as r:
        for chunk in r.iter_content(chunk_size=CHUNK_SIZE):
            size += len(chunk)
            iteration = iteration + 1
            if content is None:
                content = chunk
            else:
                content = content + chunk
            logger.debug(f'Loaded chunk (iteration={iteration}, total={size / 1024})')
            # Stop reading if we have parsed end of head tag
            end_of_head = '</head>'.encode('utf-8')
            if end_of_head in content:
                logger.debug(f'Found closing head tag after {size} bytes')
                content = content.split(end_of_head)[0] + end_of_head
                break
            # Stop reading if we exceed limit
            if size > MAX_CONTENT_LIMIT:
                logger.debug(f'Cancel reading document after {size} bytes')
                break
        if hasattr(r, '_content_consumed'):
            logger.debug(f'Request consumed: {r._content_consumed}')
    # Use charset_normalizer to determine encoding that best matches the response content
    # Several sites seem to specify the response encoding incorrectly, so we ignore it and use custom logic instead
    # This is different from Response.text which does respect the encoding specified in the response first,
    # before trying to determine one
    results = from_bytes(content or '')
    return str(results.best())
 DEFAULT_USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.0.0 Safari/537.36'
 def fake_request_headers():
    return {
        "Accept": "text/html,application/xhtml+xml,application/xml",
        "Accept-Encoding": "gzip, deflate",
        "Dnt": "1",
        "Upgrade-Insecure-Requests": "1",
        "User-Agent": DEFAULT_USER_AGENT,
    }
--- a/bookmarks/signals.py
+++ b/bookmarks/signals.py
@@ -0,0 +1,8 @@
 from django.contrib.auth import user_logged_in
 from django.dispatch import receiver
 from bookmarks.services import tasks
@receiver(user_logged_in)
 def user_logged_in(sender, request, user, **kwargs):
    tasks.schedule_bookmarks_without_snapshots(user)
--- a/bookmarks/static/apple-touch-icon.png
+++ b/bookmarks/static/apple-touch-icon.png
--- a/bookmarks/static/bulk_edit.js
+++ b/bookmarks/static/bulk_edit.js
@@ -1,86 +0,0 @@
 (function () {
    const bulkEditToggle = document.getElementById('bulk-edit-mode')
    const bulkEditBar = document.querySelector('.bulk-edit-bar')
    const singleToggles = document.querySelectorAll('.bulk-edit-toggle input')
    const allToggle = document.querySelector('.bulk-edit-all-toggle input')
    function isAllSelected() {
        let result = true
        singleToggles.forEach(function (toggle) {
            result = result && toggle.checked
        })
        return result
    }
    function selectAll() {
        singleToggles.forEach(function (toggle) {
            toggle.checked = true
        })
    }
    function deselectAll() {
        singleToggles.forEach(function (toggle) {
            toggle.checked = false
        })
    }
    // Toggle all
    allToggle.addEventListener('change', function (e) {
        if (e.target.checked) {
            selectAll()
        } else {
            deselectAll()
        }
    })
    // Toggle single
    singleToggles.forEach(function (toggle) {
        toggle.addEventListener('change', function () {
            allToggle.checked = isAllSelected()
        })
    })
    // Allow overflow when bulk edit mode is active to be able to display tag auto complete menu
    let bulkEditToggleTimeout
    if (bulkEditToggle.checked) {
        bulkEditBar.style.overflow = 'visible';
    }
    bulkEditToggle.addEventListener('change', function (e) {
        if (bulkEditToggleTimeout) {
            clearTimeout(bulkEditToggleTimeout);
            bulkEditToggleTimeout = null;
        }
        if (e.target.checked) {
            bulkEditToggleTimeout = setTimeout(function () {
                bulkEditBar.style.overflow = 'visible';
            }, 500);
        } else {
            bulkEditBar.style.overflow = 'hidden';
        }
    });
    // Init tag auto-complete
    function initTagAutoComplete() {
        const wrapper = document.createElement('div');
        const tagInput = document.getElementById('bulk-edit-tags-input');
        const apiBaseUrl = document.documentElement.dataset.apiBaseUrl || '';
        const apiClient = new linkding.ApiClient(apiBaseUrl)
        new linkding.TagAutoComplete({
            target: wrapper,
            props: {
                id: 'bulk-edit-tags-input',
                name: tagInput.name,
                value: tagInput.value,
                apiClient: apiClient,
                variant: 'small'
            }
        });
        tagInput.parentElement.replaceChild(wrapper, tagInput);
    }
    initTagAutoComplete();
 })()
--- a/bookmarks/static/shared.js
+++ b/bookmarks/static/shared.js
@@ -1,45 +0,0 @@
 (function () {
    function initConfirmationButtons() {
        const buttonEls = document.querySelectorAll('.btn-confirmation');
        function showConfirmation(buttonEl) {
            const cancelEl = document.createElement(buttonEl.nodeName);
            cancelEl.innerText = 'Cancel';
            cancelEl.className = 'btn btn-link btn-sm btn-confirmation-action mr-1';
            cancelEl.addEventListener('click', function () {
                container.remove();
                buttonEl.style = '';
            });
            const confirmEl = document.createElement(buttonEl.nodeName);
            confirmEl.innerText = 'Confirm';
            confirmEl.className = 'btn btn-link btn-delete btn-sm btn-confirmation-action';
            if (buttonEl.nodeName === 'BUTTON') {
                confirmEl.type = buttonEl.type;
                confirmEl.name = buttonEl.name;
            }
            if (buttonEl.nodeName === 'A') {
                confirmEl.href = buttonEl.href;
            }
            const container = document.createElement('span');
            container.className = 'confirmation'
            container.appendChild(cancelEl);
            container.appendChild(confirmEl);
            buttonEl.parentElement.insertBefore(container, buttonEl);
            buttonEl.style = 'display: none';
        }
        buttonEls.forEach(function (linkEl) {
            linkEl.addEventListener('click', function (e) {
                e.preventDefault();
                showConfirmation(linkEl);
            });
        });
    }
    initConfirmationButtons()
 })()
--- a/bookmarks/styles/base.scss
+++ b/bookmarks/styles/base.scss
@@ -11,6 +11,18 @@ header {
  margin-bottom: 40px;
 }
 header .toasts {
  margin-bottom: 20px;
  .toast {
    margin-bottom: 0.4rem;
  }
  .toast a.btn-clear:visited {
    color: currentColor;
  }
 }
 .navbar {
  .navbar-brand {
@@ -60,6 +72,12 @@ a:visited:hover {
  color: $link-color-dark;
 }
 code {
  color: $gray-color-dark;
  background-color: $code-bg-color;
  box-shadow: 1px 1px 0 $code-shadow-color;
 }
 // Increase spacing between columns
 .container > .columns > .column:not(:first-child) {
  padding-left: 2rem;
@@ -90,3 +108,12 @@ a:visited:hover {
    font-weight: bold;
  }
 }
 // Increase input font size on small viewports to prevent zooming on focus the input
 // on mobile devices. 430px relates to the "normalized" iPhone 14 Pro Max
 // viewport size
@media screen and (max-width: 430px) {
  .form-input {
    font-size: 16px;
  }
 }
--- a/bookmarks/styles/bookmarks.scss
+++ b/bookmarks/styles/bookmarks.scss
@@ -1,14 +1,17 @@
 /* Bookmark search box */
 .bookmarks-page .search {
  $searchbox-width: 180px;
  $searchbox-width-md: 300px;
  $searchbox-height: 1.8rem;
  // Regular input
  input[type='search'] {
-    width: 180px;
+    width: $searchbox-width;
    height: $searchbox-height;
    -webkit-appearance: none;
    @media (min-width: $control-width-md) {
-      width: 300px;
+      width: $searchbox-width-md;
    }
  }
@@ -18,29 +21,56 @@
    height: $searchbox-height;
    .form-autocomplete-input {
      width: $searchbox-width;
      height: $searchbox-height;
      width: 100%;
      input[type='search'] {
        width: 100%;
        height: 100%;
        margin: 0;
        border: none;
      }
      @media (min-width: $control-width-md) {
        width: $searchbox-width-md;
      }
    }
  }
 }
-.bookmarks-page .content-area-header {
+/* Bookmark list */
  span.btn {
    margin-left: 8px;
  }
 }
 ul.bookmark-list {
  list-style: none;
  margin: 0;
  padding: 0;
 }
 /* Bookmarks */
 li[ld-bookmark-item] {
  position: relative;
  [ld-bulk-edit-checkbox].form-checkbox {
    display: none;
  }
  .title a {
    display: inline-block;
    vertical-align: top;
    width: 100%;
    white-space: nowrap;
    overflow: hidden;
    text-overflow: ellipsis;
  }
  .title img {
    width: 16px;
    height: 16px;
    vertical-align: text-top;
  }
  .url-display {
    color: $secondary-link-color;
  }
  .description {
    color: $gray-color-dark;
@@ -50,27 +80,41 @@ ul.bookmark-list {
    }
  }
-  .actions > *:not(:last-child) {
+  .actions {
-    margin-right: 0.1rem;
+    display: flex;
    align-items: baseline;
    flex-wrap: wrap;
    gap: 0.4rem;
  }
-  .actions .btn-link {
+  .actions {
-    color: $gray-color;
+    a, button.btn-link {
-    padding: 0;
+      color: $gray-color;
-    height: auto;
+      padding: 0;
-    vertical-align: unset;
+      height: auto;
-    border: none;
+      vertical-align: unset;
      border: none;
      transition: none;
      text-decoration: none;
-    &:focus,
+      &:focus,
-    &:hover,
+      &:hover,
-    &:active,
+      &:active,
-    &.active {
+      &.active {
-      color: $gray-color-dark;
+        color: $gray-color-dark;
      }
    }
  }
-  .bulk-edit-toggle {
+    .separator {
-    display: none;
+      align-self: flex-start;
    }
    .toggle-notes {
      align-self: center;
      display: flex;
      align-items: center;
      gap: 0.1rem;
    }
  }
 }
@@ -80,8 +124,18 @@ ul.bookmark-list {
 .tag-cloud {
-  a, a:visited:hover {
+  .selected-tags {
-    color: $alternative-color;
+    margin-bottom: 0.8rem;
    a, a:visited:hover {
      color: $error-color;
    }
  }
  .unselected-tags {
    a, a:visited:hover {
      color: $alternative-color;
    }
  }
  .group {
@@ -140,16 +194,79 @@ ul.bookmark-list {
      font-weight: bold;
    }
  }
  details.notes textarea {
    box-sizing: border-box;
  }
 }
-/* Bulk edit */
+/* Bookmark notes */
 ul.bookmark-list {
  .notes {
    display: none;
    max-height: 300px;
    margin: 4px 0;
    overflow: auto;
  }
  &.show-notes .notes,
  li.show-notes .notes {
    display: block;
  }
 }
 /* Bookmark notes markdown styles */
 ul.bookmark-list .notes-content {
  & {
    padding: 0.4rem 0.6rem;
  }
  p, ul, ol, pre, blockquote {
    margin: 0 0 0.4rem 0;
  }
  > *:first-child {
    margin-top: 0;
  }
  > *:last-child {
    margin-bottom: 0;
  }
  ul, ol {
    margin-left: 0.8rem;
  }
  ul li, ol li {
    margin-top: 0.2rem;
  }
  pre {
    padding: 0.2rem 0.4rem;
    background-color: $code-bg-color;
    border-radius: 0.2rem;
  }
  pre code {
    background: none;
    box-shadow: none;
    padding: 0;
  }
  > pre:first-child:last-child {
    padding: 0;
    background: none;
    border-radius: 0;
  }
 }
 /* Bookmark bulk edit */
 $bulk-edit-toggle-width: 16px;
 $bulk-edit-toggle-offset: 8px;
 $bulk-edit-bar-offset: $bulk-edit-toggle-width + (2 * $bulk-edit-toggle-offset);
 $bulk-edit-transition-duration: 400ms;
-.bulk-edit-form {
+[ld-bulk-edit] {
  .bulk-edit-bar {
    margin-top: -17px;
    margin-bottom: 16px;
@@ -159,56 +276,27 @@ $bulk-edit-transition-duration: 400ms;
    transition: max-height $bulk-edit-transition-duration;
  }
-  .bulk-edit-actions {
+  &.active .bulk-edit-bar {
-    display: flex;
+    max-height: 37px;
-    align-items: baseline;
+    border-bottom: solid 1px $border-color;
    padding: 4px 0;
    border-top: solid 1px $border-color;
    button:hover {
      text-decoration: underline;
    }
    > label.form-checkbox {
      min-height: 1rem;
    }
    > button {
      padding: 0;
      margin-left: 8px;
    }
    > span {
      margin-left: 8px;
    }
    > input, .form-autocomplete {
      width: auto;
      margin-left: 4px;
      max-width: 200px;
      -webkit-appearance: none;
    }
    span.confirmation {
      display: flex;
    }
    span.confirmation button {
      padding: 0;
    }
  }
-  .bulk-edit-all-toggle {
+  /* remove overflow after opening animation, otherwise tag autocomplete overlay gets cut off */
  &.active:not(.activating) .bulk-edit-bar {
    overflow: visible;
  }
  /* All checkbox */
  [ld-bulk-edit-checkbox][all].form-checkbox {
    display: block;
    width: $bulk-edit-toggle-width;
    margin: 0 0 0 $bulk-edit-toggle-offset;
    padding: 0;
    min-height: 1rem;
  }
-  ul.bookmark-list li {
+  /* Bookmark checkboxes */
-    position: relative;
+  li[ld-bookmark-item] [ld-bulk-edit-checkbox].form-checkbox {
  }
  ul.bookmark-list li .bulk-edit-toggle {
    display: block;
    position: absolute;
    width: $bulk-edit-toggle-width;
@@ -220,22 +308,36 @@ $bulk-edit-transition-duration: 400ms;
    opacity: 0;
    transition: all $bulk-edit-transition-duration;
-    i {
+    .form-icon {
      top: 0.2rem;
    }
  }
 }
-#bulk-edit-mode {
+  &.active li[ld-bookmark-item] [ld-bulk-edit-checkbox].form-checkbox {
-  display: none;
+    visibility: visible;
-}
+    opacity: 1;
  }
-#bulk-edit-mode:checked ~ .bookmarks-page .bulk-edit-toggle {
+  /* Actions */
-  visibility: visible;
+  .bulk-edit-actions {
-  opacity: 1;
+    display: flex;
-}
+    align-items: baseline;
    padding: 4px 0;
    border-top: solid 1px $border-color;
    gap: 8px;
-#bulk-edit-mode:checked ~ .bookmarks-page .bulk-edit-bar {
+    button {
-  max-height: 37px;
+      padding: 0 !important;
-  border-bottom: solid 1px $border-color;
+    }
    button:hover {
      text-decoration: underline;
    }
    > input, .form-autocomplete {
      width: auto;
      max-width: 200px;
      -webkit-appearance: none;
    }
  }
 }
--- a/bookmarks/styles/settings.scss
+++ b/bookmarks/styles/settings.scss
@@ -11,4 +11,8 @@
  .input-group > input[type=submit] {
    height: auto;
  }
  section.about table {
    max-width: 500px;
  }
 }
--- a/bookmarks/styles/shared.scss
+++ b/bookmarks/styles/shared.scss
@@ -14,9 +14,15 @@ section.content-area {
 }
 // Confirm button component
-.btn-confirmation-action {
+span.confirmation {
  display: flex;
  align-items: baseline;
 }
 span.confirmation .btn.btn-link {
  color: $error-color !important;
  &:hover {
    text-decoration: underline;
  }
-}
+}
--- a/bookmarks/styles/util.scss
+++ b/bookmarks/styles/util.scss
@@ -15,3 +15,7 @@
 .text-gray-dark {
  color: $gray-color-dark;
 }
 .align-baseline {
  align-items: baseline;
 }
--- a/bookmarks/styles/variables-dark.scss
+++ b/bookmarks/styles/variables-dark.scss
@@ -21,8 +21,13 @@ $link-color: $primary-color !default;
 $link-color-dark: darken($link-color, 5%) !default;
 $link-color-light: $link-color !default;
 $secondary-link-color: rgba(168, 177, 255, 0.73);
 $alternative-color: #59bdb9;
 $alternative-color-dark: #73f1eb;
 $code-bg-color: rgba(255, 255, 255, 0.1);
 $code-shadow-color: rgba(255, 255, 255, 0.2);
 /* Dark theme specific */
 $dt-primary-button-color: #5761cb !default;
--- a/bookmarks/styles/variables-light.scss
+++ b/bookmarks/styles/variables-light.scss
@@ -2,3 +2,8 @@ $html-font-size: 18px !default;
 $alternative-color: #05a6a3;
 $alternative-color-dark: darken($alternative-color, 5%);
 $secondary-link-color: rgba(87, 85, 217, 0.64);
 $code-bg-color: rgba(0, 0, 0, 0.05);
 $code-shadow-color: rgba(0, 0, 0, 0.15);
--- a/bookmarks/templates/bookmarks/archive.html
+++ b/bookmarks/templates/bookmarks/archive.html
@@ -4,43 +4,42 @@
 {% load bookmarks %}
 {% block content %}
  <div class="bookmarks-page columns"
       ld-bulk-edit
       ld-bookmark-page
       bookmarks-url="{% url 'bookmarks:partials.bookmark_list.archived' %}"
       tags-url="{% url 'bookmarks:partials.tag_cloud.archived' %}">
-    {% include 'bookmarks/bulk_edit/state.html' %}
+    {# Bookmark list #}
    <section class="content-area column col-8 col-md-12">
      <div class="content-area-header">
        <h2>Archived bookmarks</h2>
        <div class="spacer"></div>
        {% bookmark_search bookmark_list.filters tag_cloud.tags mode='archived' %}
        {% include 'bookmarks/bulk_edit/toggle.html' %}
      </div>
-    <div class="bookmarks-page columns">
+      <form class="bookmark-actions" action="{% url 'bookmarks:action' %}?return_url={{ bookmark_list.return_url }}"
            method="post">
        {% csrf_token %}
        {% include 'bookmarks/bulk_edit/bar.html' with mode='archive' %}
-        {# Bookmark list #}
+        <div class="bookmark-list-container">
-        <section class="content-area column col-8 col-md-12">
+          {% include 'bookmarks/bookmark_list.html' %}
-            <div class="content-area-header">
+        </div>
-                <h2>Archived bookmarks</h2>
+      </form>
-                <div class="spacer"></div>
+    </section>
                {% bookmark_search query tags mode='archive' %}
                {% include 'bookmarks/bulk_edit/toggle.html' %}
            </div>
-            <form class="bulk-edit-form" action="{% url 'bookmarks:bulk_edit' %}?return_url={{ return_url }}"
+    {# Tag cloud #}
-                  method="post">
+    <section class="content-area column col-4 hide-md">
-                {% csrf_token %}
+      <div class="content-area-header">
-                {% include 'bookmarks/bulk_edit/bar.html' with mode='archive' %}
+        <h2>Tags</h2>
      </div>
      <div class="tag-cloud-container">
        {% include 'bookmarks/tag_cloud.html' %}
      </div>
    </section>
  </div>
-                {% if empty %}
+  <script src="{% static "bundle.js" %}"></script>
                    {% include 'bookmarks/empty_bookmarks.html' %}
                {% else %}
                    {% bookmark_list bookmarks return_url %}
                {% endif %}
            </form>
        </section>
        {# Tag list #}
        <section class="content-area column col-4 hide-md">
            <div class="content-area-header">
                <h2>Tags</h2>
            </div>
            {% tag_cloud tags %}
        </section>
    </div>
    <script src="{% static "bundle.js" %}"></script>
    <script src="{% static "shared.js" %}"></script>
    <script src="{% static "bulk_edit.js" %}"></script>
 {% endblock %}
--- a/bookmarks/templates/bookmarks/bookmark_list.html
+++ b/bookmarks/templates/bookmarks/bookmark_list.html
@@ -1,55 +1,136 @@
 {% load static %}
 {% load shared %}
 {% load pagination %}
-<ul class="bookmark-list">
+{% if bookmark_list.is_empty %}
-    {% for bookmark in bookmarks %}
+  {% include 'bookmarks/empty_bookmarks.html' %}
-        <li data-is-bookmark-item>
+{% else %}
-            <label class="form-checkbox bulk-edit-toggle">
+  <ul class="bookmark-list{% if bookmark_list.show_notes %} show-notes{% endif %}">
-                <input type="checkbox" name="bookmark_id" value="{{ bookmark.id }}">
+    {% for bookmark in bookmark_list.bookmarks_page %}
-                <i class="form-icon"></i>
+      <li ld-bookmark-item>
-            </label>
+        <label ld-bulk-edit-checkbox class="form-checkbox">
-            <div class="title truncate">
+          <input type="checkbox" name="bookmark_id" value="{{ bookmark.id }}">
-                <a href="{{ bookmark.url }}" target="_blank" rel="noopener">{{ bookmark.resolved_title }}</a>
+          <i class="form-icon"></i>
        </label>
        <div class="title">
          <a href="{{ bookmark.url }}" target="{{ bookmark_list.link_target }}" rel="noopener"
             class="{% if bookmark.unread %}text-italic{% endif %}">
            {% if bookmark.favicon_file and bookmark_list.show_favicons %}
              <img src="{% static bookmark.favicon_file %}" alt="">
            {% endif %}
            {{ bookmark.resolved_title }}
          </a>
        </div>
        {% if bookmark_list.show_url %}
          <div class="url-path truncate">
            <a href="{{ bookmark.url }}" target="{{ bookmark_list.link_target }}" rel="noopener"
               class="url-display text-sm">
              {{ bookmark.url }}
            </a>
          </div>
        {% endif %}
        <div class="description truncate">
          {% if bookmark.tag_names %}
            <span>
              {% for tag_name in bookmark.tag_names %}
                <a href="?{% add_tag_to_query tag_name %}">{{ tag_name|hash_tag }}</a>
              {% endfor %}
            </span>
          {% endif %}
          {% if bookmark.tag_names and bookmark.resolved_description %} | {% endif %}
          {% if bookmark.resolved_description %}
            <span>{{ bookmark.resolved_description }}</span>
          {% endif %}
        </div>
        {% if bookmark.notes %}
          <div class="notes bg-gray text-gray-dark">
            <div class="notes-content">
              {% markdown bookmark.notes %}
            </div>
-            <div class="description truncate">
+          </div>
-                {% if bookmark.tag_names %}
+        {% endif %}
-                    <span>
+        <div class="actions text-gray text-sm">
-                            {% for tag_name in bookmark.tag_names %}
+          {% if bookmark_list.date_display == 'relative' %}
-                                <a href="?{% append_query_param q=tag_name|hash_tag %}">{{ tag_name|hash_tag }}</a>
+            <span>
-                            {% endfor %}
+              {% if bookmark.web_archive_snapshot_url %}
-                        </span>
+                <a href="{{ bookmark.web_archive_snapshot_url }}"
-                {% endif %}
+                   title="Show snapshot on the Internet Archive Wayback Machine"
-                {% if bookmark.tag_names and bookmark.resolved_description %} | {% endif %}
+                   target="{{ bookmark_list.link_target }}"
-
+                   rel="noopener">
-                {% if bookmark.resolved_description %}
+              {% endif %}
-                    <span>{{ bookmark.resolved_description }}</span>
+              <span>{{ bookmark.date_added|humanize_relative_date }}</span>
-                {% endif %}
+              {% if bookmark.web_archive_snapshot_url %}
-            </div>
+                ∞
-            <div class="actions">
+                </a>
-                {% if request.user.profile.bookmark_date_display == 'relative' %}
+              {% endif %}
-                    <span class="text-gray text-sm">{{ bookmark.date_added|humanize_relative_date }}</span>
+            </span>
-                    <span class="text-gray text-sm">|</span>
+            <span class="separator">|</span>
-                {% endif %}
+          {% endif %}
-                {% if request.user.profile.bookmark_date_display == 'absolute' %}
+          {% if bookmark_list.date_display == 'absolute' %}
-                    <span class="text-gray text-sm">{{ bookmark.date_added|humanize_absolute_date }}</span>
+            <span>
-                    <span class="text-gray text-sm">|</span>
+              {% if bookmark.web_archive_snapshot_url %}
-                {% endif %}
+                <a href="{{ bookmark.web_archive_snapshot_url }}"
-                <a href="{% url 'bookmarks:edit' bookmark.id %}?return_url={{ return_url }}"
+                   title="Show snapshot on the Internet Archive Wayback Machine"
-                   class="btn btn-link btn-sm">Edit</a>
+                   target="{{ bookmark_list.link_target }}"
-                {% if bookmark.is_archived %}
+                   rel="noopener">
-                    <a href="{% url 'bookmarks:unarchive' bookmark.id %}?return_url={{ return_url }}"
+              {% endif %}
-                       class="btn btn-link btn-sm">Unarchive</a>
+              <span>{{ bookmark.date_added|humanize_absolute_date }}</span>
-                {% else %}
+              {% if bookmark.web_archive_snapshot_url %}
-                    <a href="{% url 'bookmarks:archive' bookmark.id %}?return_url={{ return_url }}"
+                ∞
-                       class="btn btn-link btn-sm">Archive</a>
+                </a>
-                {% endif %}
+              {% endif %}
-                <a href="{% url 'bookmarks:remove' bookmark.id %}?return_url={{ return_url }}"
+            </span>
-                   class="btn btn-link btn-sm btn-confirmation">Remove</a>
+            <span class="separator">|</span>
-            </div>
+          {% endif %}
-        </li>
+          {% if bookmark.owner == request.user %}
            {# Bookmark owner actions #}
            <a href="{% url 'bookmarks:edit' bookmark.id %}?return_url={{ bookmark_list.return_url }}">Edit</a>
            {% if bookmark.is_archived %}
              <button type="submit" name="unarchive" value="{{ bookmark.id }}"
                      class="btn btn-link btn-sm">Unarchive
              </button>
            {% else %}
              <button type="submit" name="archive" value="{{ bookmark.id }}"
                      class="btn btn-link btn-sm">Archive
              </button>
            {% endif %}
            <button ld-confirm-button type="submit" name="remove" value="{{ bookmark.id }}"
                    class="btn btn-link btn-sm">Remove
            </button>
            {% if bookmark.unread %}
              <span class="separator">|</span>
              <button type="submit" name="mark_as_read" value="{{ bookmark.id }}"
                      class="btn btn-link btn-sm">Mark as read
              </button>
            {% endif %}
          {% else %}
            {# Shared bookmark actions #}
            <span>Shared by
              <a href="?{% replace_query_param user=bookmark.owner.username %}">{{ bookmark.owner.username }}</a>
            </span>
          {% endif %}
          {% if bookmark.notes and not bookmark_list.show_notes %}
            <span class="separator">|</span>
            <button class="btn btn-link btn-sm toggle-notes" title="Toggle notes">
              <svg xmlns="http://www.w3.org/2000/svg" class="icon icon-tabler icon-tabler-notes" width="16"
                   height="16"
                   viewBox="0 0 24 24" stroke-width="2" stroke="currentColor" fill="none" stroke-linecap="round"
                   stroke-linejoin="round">
                <path stroke="none" d="M0 0h24v24H0z" fill="none"></path>
                <path d="M5 3m0 2a2 2 0 0 1 2 -2h10a2 2 0 0 1 2 2v14a2 2 0 0 1 -2 2h-10a2 2 0 0 1 -2 -2z"></path>
                <path d="M9 7l6 0"></path>
                <path d="M9 11l6 0"></path>
                <path d="M9 15l4 0"></path>
              </svg>
              <span>Notes</span>
            </button>
          {% endif %}
        </div>
      </li>
    {% endfor %}
-</ul>
+  </ul>
-<div class="bookmark-pagination">
+  <div class="bookmark-pagination">
-    {% pagination bookmarks %}
+    {% pagination bookmark_list.bookmarks_page %}
-</div>
+  </div>
 {% endif %}
--- a/bookmarks/templates/bookmarks/bookmarklet.js
+++ b/bookmarks/templates/bookmarks/bookmarklet.js
@@ -1,9 +1,9 @@
-(function() {
+(function () {
-    var bookmarkUrl = window.location;
+  var bookmarkUrl = window.location;
-    var applicationUrl = '{{ application_url }}';
+  var applicationUrl = '{{ application_url }}';
-    applicationUrl += '?url=' + encodeURIComponent(bookmarkUrl);
+  applicationUrl += '?url=' + encodeURIComponent(bookmarkUrl);
-    applicationUrl += '&auto_close';
+  applicationUrl += '&auto_close';
-    window.open(applicationUrl);
+  window.open(applicationUrl);
 })();
--- a/bookmarks/templates/bookmarks/bulk_edit/bar.html
+++ b/bookmarks/templates/bookmarks/bulk_edit/bar.html
@@ -1,31 +1,34 @@
-<div class="bulk-edit-bar">
+{% load shared %}
 {% htmlmin %}
  <div class="bulk-edit-bar">
    <div class="bulk-edit-actions bg-gray">
-        <label class="form-checkbox bulk-edit-all-toggle">
+      <label ld-bulk-edit-checkbox all class="form-checkbox">
-            <input type="checkbox" style="display: none">
+        <input type="checkbox" style="display: none">
-            <i class="form-icon"></i>
+        <i class="form-icon"></i>
-        </label>
+      </label>
-        {% if mode == 'archive' %}
+      {% if mode == 'archive' %}
-            <button type="submit" name="bulk_unarchive" class="btn btn-link btn-sm btn-confirmation"
+        <button ld-confirm-button type="submit" name="bulk_unarchive" class="btn btn-link btn-sm"
-                    title="Unarchive selected bookmarks">Unarchive
+                title="Unarchive selected bookmarks">Unarchive
            </button>
        {% else %}
            <button type="submit" name="bulk_archive" class="btn btn-link btn-sm btn-confirmation"
                    title="Archive selected bookmarks">Archive
            </button>
        {% endif %}
        <span class="text-sm text-gray-dark">•</span>
        <button type="submit" name="bulk_delete" class="btn btn-link btn-sm btn-confirmation"
                title="Delete selected bookmarks">Delete
        </button>
-        <span class="text-sm text-gray-dark">•</span>
+      {% else %}
-        <span class="text-sm text-gray-dark"><label for="bulk-edit-tags-input">Tags:</label></span>
+        <button ld-confirm-button type="submit" name="bulk_archive" class="btn btn-link btn-sm"
-        <input id="bulk-edit-tags-input" name="bulk_tag_string" class="form-input input-sm"
+                title="Archive selected bookmarks">Archive
               placeholder="&nbsp;">
        <button type="submit" name="bulk_tag" class="btn btn-link btn-sm"
                title="Add tags to selected bookmarks">Add
        </button>
        <button type="submit" name="bulk_untag" class="btn btn-link btn-sm"
                title="Remove tags from selected bookmarks">Remove
        </button>
      {% endif %}
      <span class="text-sm text-gray-dark">•</span>
      <button ld-confirm-button type="submit" name="bulk_delete" class="btn btn-link btn-sm"
              title="Delete selected bookmarks">Delete
      </button>
      <span class="text-sm text-gray-dark">•</span>
      <span class="text-sm text-gray-dark"><label for="bulk-edit-tags-input">Tags:</label></span>
      <input ld-tag-autocomplete variant="small"
             name="bulk_tag_string" class="form-input input-sm" placeholder="&nbsp;">
      <button type="submit" name="bulk_tag" class="btn btn-link btn-sm"
              title="Add tags to selected bookmarks">Add
      </button>
      <button type="submit" name="bulk_untag" class="btn btn-link btn-sm"
              title="Remove tags from selected bookmarks">Remove
      </button>
    </div>
-</div>
+  </div>
 {% endhtmlmin %}
--- a/bookmarks/templates/bookmarks/bulk_edit/state.html
+++ b/bookmarks/templates/bookmarks/bulk_edit/state.html
@@ -1 +0,0 @@
 <input id="bulk-edit-mode" type="checkbox">
--- a/bookmarks/templates/bookmarks/bulk_edit/toggle.html
+++ b/bookmarks/templates/bookmarks/bulk_edit/toggle.html
@@ -1,8 +1,7 @@
-<label for="bulk-edit-mode" class="hide-sm">
+<button ld-bulk-edit-active-toggle class="btn hide-sm ml-2" title="Bulk edit">
-    <span class="btn" title="Bulk edit">
+  <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" width="20px"
-        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" width="20px"
+       height="20px">
-             height="20px">
+    <path
-            <path d="M7 3a1 1 0 000 2h6a1 1 0 100-2H7zM4 7a1 1 0 011-1h10a1 1 0 110 2H5a1 1 0 01-1-1zM2 11a2 2 0 012-2h12a2 2 0 012 2v4a2 2 0 01-2 2H4a2 2 0 01-2-2v-4z"/>
+        d="M7 3a1 1 0 000 2h6a1 1 0 100-2H7zM4 7a1 1 0 011-1h10a1 1 0 110 2H5a1 1 0 01-1-1zM2 11a2 2 0 012-2h12a2 2 0 012 2v4a2 2 0 01-2 2H4a2 2 0 01-2-2v-4z"/>
-        </svg>
+  </svg>
-    </span>
+</button>
 </label>
--- a/Show More
+++ b/Show More
		`@@ -1 +0,0 @@`
			`<input id="bulk-edit-mode" type="checkbox">`