Merge pull request #4756 from Tyriar/tyriar/5_3__2

Disable image addon publishing

.devcontainer/Dockerfile

@@ -1,23 +0,0 @@
-FROM node:14-buster
-
-# Configure apt
-ENV DEBIAN_FRONTEND=noninteractive
-RUN apt-get update \
-    && apt-get -y install --no-install-recommends apt-utils 2>&1
-
-# Verify git and process tools are installed
-RUN apt-get install -y git procps
-
-# Install yarn
-RUN apt-get install -y curl apt-transport-https lsb-release \
-    && curl -sS https://dl.yarnpkg.com/$(lsb_release -is | tr '[:upper:]' '[:lower:]')/pubkey.gpg | apt-key add - 2>/dev/null \
-    && echo "deb https://dl.yarnpkg.com/$(lsb_release -is | tr '[:upper:]' '[:lower:]')/ stable main" | tee /etc/apt/sources.list.d/yarn.list \
-    && apt-get update \
-    && apt-get -y install --no-install-recommends \
-       yarn
-
-# Clean up
-RUN apt-get autoremove -y \
-    && apt-get clean -y \
-    && rm -rf /var/lib/apt/lists/*
-ENV DEBIAN_FRONTEND=dialog

.devcontainer/devcontainer.json

@@ -1,10 +1,20 @@
 {
   "name": "xterm.js",
-  "dockerFile": "Dockerfile",
-  "appPort": 3000,
-  "extensions": [
-    "dbaeumer.vscode-eslint",
-    "editorconfig.editorconfig",
-    "hbenl.vscode-mocha-test-adapter"
-  ]
+  "image": "mcr.microsoft.com/devcontainers/typescript-node:0-18-buster",
+  "features": {
+    "ghcr.io/devcontainers/features/node:1": {} // yarn
+  },
+  "forwardPorts": [
+    3000
+  ],
+  "postCreateCommand": "yarn install",
+  "customizations": {
+    "vscode": {
+      "extensions": [
+        "dbaeumer.vscode-eslint",
+        "editorconfig.editorconfig",
+        "hbenl.vscode-mocha-test-adapter"
+      ]
+    }
+  }
 }

.eslintrc.json

@@ -7,16 +7,20 @@
   "parser": "@typescript-eslint/parser",
   "parserOptions": {
     "project": [
+      "demo/tsconfig.json",
       "src/browser/tsconfig.json",
       "src/common/tsconfig.json",
       "src/headless/tsconfig.json",
       "test/api/tsconfig.json",
       "test/benchmark/tsconfig.json",
+      "test/playwright/tsconfig.json",
       "addons/xterm-addon-attach/src/tsconfig.json",
       "addons/xterm-addon-attach/test/tsconfig.json",
       "addons/xterm-addon-canvas/src/tsconfig.json",
       "addons/xterm-addon-fit/src/tsconfig.json",
       "addons/xterm-addon-fit/test/tsconfig.json",
+      "addons/xterm-addon-image/src/tsconfig.json",
+      "addons/xterm-addon-image/test/tsconfig.json",
       "addons/xterm-addon-ligatures/src/tsconfig.json",
       "addons/xterm-addon-search/src/tsconfig.json",
       "addons/xterm-addon-search/test/tsconfig.json",
@@ -33,12 +37,14 @@
     "sourceType": "module"
   },
   "ignorePatterns": [
+    "**/inwasm-sdks/*",
     "**/typings/*.d.ts",
     "**/node_modules",
     "**/*.js"
   ],
   "plugins": [
-    "@typescript-eslint"
+    "@typescript-eslint",
+    "jsdoc"
   ],
   "rules": {
     "no-extra-semi": "error",
@@ -85,7 +91,12 @@
     ],
     "@typescript-eslint/naming-convention": [
       "warn",
-      { "selector": "default", "format": ["camelCase"] },
+      { "selector": "default", "format": ["camelCase"],
+        "filter": {
+          "regex": "^[a-z]",
+          "match": true
+        }
+      },
       // variableLike
       { "selector": "variable", "format": ["camelCase", "UPPER_CASE"] },
       { "selector": "variable", "filter": "^I.+Service$", "format": ["PascalCase"], "prefix": ["I"] },
@@ -94,12 +105,34 @@
       { "selector": "memberLike", "modifiers": ["protected"], "format": ["camelCase"], "leadingUnderscore": "require" },
       { "selector": "enumMember", "format": ["UPPER_CASE"] },
       // memberLike - Allow enum-like objects to use UPPER_CASE
-      { "selector": "property", "modifiers": ["public"], "format": ["camelCase", "UPPER_CASE"] },
-      { "selector": "method", "modifiers": ["public"], "format": ["camelCase", "UPPER_CASE"] },
+      { "selector": "property", "modifiers": ["public"], "format": ["camelCase", "UPPER_CASE"],
+        "filter": {
+          "regex": "^[a-z]",
+          "match": true
+        }
+      },
+      // restrict on* naming for events only
+      { "selector": "method", "modifiers": ["public"], "format": ["camelCase", "UPPER_CASE"], "custom": {
+        "regex": "^on[A-Z].+",
+        "match": false
+      } },
+      { "selector": "method", "modifiers": ["private"], "format": ["camelCase"], "leadingUnderscore": "require", "custom": {
+        "regex": "^on[A-Z].+",
+        "match": false
+      } },
+      { "selector": "method", "modifiers": ["protected"], "format": ["camelCase"], "leadingUnderscore": "require", "custom": {
+        "regex": "^on[A-Z].+",
+        "match": false
+      } },
       // typeLike
       { "selector": "typeLike", "format": ["PascalCase"] },
       { "selector": "interface", "format": ["PascalCase"], "prefix": ["I"] }
     ],
+    "@typescript-eslint/no-confusing-void-expression": [
+      "warn",
+      { "ignoreArrowShorthand": true }
+    ],
+    "@typescript-eslint/no-useless-constructor": "warn",
     "@typescript-eslint/prefer-namespace-keyword": "warn",
     "@typescript-eslint/type-annotation-spacing": "warn",
     "@typescript-eslint/quotes": [
@@ -128,7 +161,20 @@
       "warn",
       "always"
     ],
+    "jsdoc/check-alignment": 1,
+    "jsdoc/check-param-names": 1,
+    "jsdoc/no-multi-asterisks": 1,
     "keyword-spacing": "warn",
+    "max-len": [
+      "warn",
+      {
+        "code": 1000, // Don't enforce for code
+        "comments": 100,
+        "ignoreTrailingComments": true,
+        "ignoreUrls": true,
+        "ignorePattern": "^ *((?<vt_comment>(//|\\*) @vt)|(?<table_comment>\\* \\| )|(?<commented_code>//  ))"
+      }
+    ],
     "new-parens": "warn",
     "no-duplicate-imports": "warn",
     "no-else-return": [
@@ -172,6 +218,10 @@
     ],
     "no-trailing-spaces": "warn",
     "no-unsafe-finally": "warn",
+    "no-unused-vars": ["warn", {
+      "vars": "all",
+      "args": "none"
+    }],
     "no-var": "warn",
     "one-var": [
       "warn",
@@ -193,9 +243,14 @@
   },
   "overrides": [
     {
-      "files": ["**/*.test.ts"],
+      "files": [
+        "**/*.api.ts",
+        "**/*.test.ts"
+      ],
       "rules": {
-        "object-curly-spacing": "off"
+        "object-curly-spacing": "off",
+        "max-len": "off",
+        "no-unused-vars": "off"
       }
     }
   ]

.eslintrc.json.typings

@@ -0,0 +1,104 @@
+{
+  "env": {
+    "browser": true,
+    "es6": true,
+    "node": true
+  },
+  "parser": "@typescript-eslint/parser",
+  "plugins": [
+    "@typescript-eslint",
+    "jsdoc"
+  ],
+  "rules": {
+    "no-extra-semi": "error",
+    "@typescript-eslint/array-type": [
+      "warn",
+      {
+        "default": "array",
+        "readonly": "generic"
+      }
+    ],
+    "@typescript-eslint/explicit-function-return-type": [
+      "warn",
+      {
+        "allowExpressions": true
+      }
+    ],
+    "@typescript-eslint/indent": [
+      "warn",
+      2
+    ],
+    "@typescript-eslint/member-delimiter-style": [
+      "warn",
+      {
+        "multiline": {
+          "delimiter": "semi",
+          "requireLast": true
+        },
+        "singleline": {
+          "delimiter": "comma",
+          "requireLast": false
+        }
+      }
+    ],
+    "@typescript-eslint/naming-convention": [
+      "warn",
+      { "selector": "typeLike", "format": ["PascalCase"] },
+      { "selector": "interface", "format": ["PascalCase"], "prefix": ["I"] }
+    ],
+    "@typescript-eslint/prefer-namespace-keyword": "warn",
+    "@typescript-eslint/type-annotation-spacing": "warn",
+    "@typescript-eslint/quotes": [
+      "warn",
+      "single",
+      { "allowTemplateLiterals": true }
+    ],
+    "@typescript-eslint/semi": [
+      "warn",
+      "always"
+    ],
+    "comma-dangle": [
+      "warn",
+      {
+        "objects": "never",
+        "arrays": "never",
+        "functions": "never"
+      }
+    ],
+    "curly": [
+      "warn",
+      "multi-line"
+    ],
+    "eol-last": "warn",
+    "eqeqeq": [
+      "warn",
+      "always"
+    ],
+    "jsdoc/check-alignment": 1,
+    "jsdoc/check-param-names": 1,
+    "keyword-spacing": "warn",
+    "max-len": [
+      "warn",
+      {
+        "code": 1000, // Don't enforce for code
+        "comments": 80,
+        "ignoreUrls": true,
+        "ignorePattern": "^ *(?<ps_description>\\* Ps=)"
+      }
+    ],
+    "no-irregular-whitespace": "warn",
+    "no-trailing-spaces": "warn",
+    "object-curly-spacing": [
+      "warn",
+      "always"
+    ],
+    "spaced-comment": [
+      "warn",
+      "always",
+      {
+        "markers": ["/"],
+        "exceptions": ["-"]
+      }
+    ]
+  }
+}

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +1,8 @@
 blank_issues_enabled: false
 contact_links:
-  - name: Question
-    url:  https://stackoverflow.com/questions/tagged/xtermjs
-    about: Please ask and answer questions here.
+  - name: FAQ
+    url:  https://github.com/xtermjs/xterm.js/wiki/FAQ
+    about: See our frequently asked questions before filing a bug report
+  - name: Support / Q&A
+    url:  https://github.com/xtermjs/xterm.js/discussions/categories/q-a
+    about: Use GitHub Discussions for community support and general Q&A

.github/workflows/ci.yml

@@ -0,0 +1,300 @@
+name: CI
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js 18.x
+      uses: actions/setup-node@v3
+      with:
+        node-version: 18.x
+        cache: 'yarn'
+    - name: Install dependencies
+      run: yarn --frozen-lockfile
+    - name: Build
+      run: yarn setup
+    - name: Zip artifacts
+      run: |
+        zip -r compressed-build \
+          ./out/* \
+          ./out-test/* \
+          ./addons/xterm-addon-attach/out/* \
+          ./addons/xterm-addon-attach/out-test/* \
+          ./addons/xterm-addon-canvas/out/* \
+          ./addons/xterm-addon-canvas/out-test/* \
+          ./addons/xterm-addon-fit/out/* \
+          ./addons/xterm-addon-fit/out-test/* \
+          ./addons/xterm-addon-image/out/* \
+          ./addons/xterm-addon-image/out-test/* \
+          ./addons/xterm-addon-ligatures/out/* \
+          ./addons/xterm-addon-ligatures/out-test/* \
+          ./addons/xterm-addon-search/out/* \
+          ./addons/xterm-addon-search/out-test/* \
+          ./addons/xterm-addon-serialize/out/* \
+          ./addons/xterm-addon-serialize/out-test/* \
+          ./addons/xterm-addon-unicode11/out/* \
+          ./addons/xterm-addon-unicode11/out-test/* \
+          ./addons/xterm-addon-web-links/out/* \
+          ./addons/xterm-addon-web-links/out-test/* \
+          ./addons/xterm-addon-webgl/out/* \
+          ./addons/xterm-addon-webgl/out-test/*
+    - name: Upload artifacts
+      uses: actions/upload-artifact@v3
+      with:
+        name: build-artifacts
+        path: compressed-build.zip
+        if-no-files-found: error
+
+  lint:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js 18.x
+      uses: actions/setup-node@v3
+      with:
+        node-version: 18.x
+        cache: 'yarn'
+    - name: Install dependencies
+      run: |
+        yarn --frozen-lockfile
+        yarn install-addons
+    - name: Lint code
+      run: yarn lint
+    - name: Lint API
+      run: yarn lint-api
+
+  test-unit-coverage:
+    needs: build
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js 18.x
+      uses: actions/setup-node@v3
+      with:
+        node-version: 18.x
+        cache: 'yarn'
+    - name: Install dependencies
+      run: |
+        yarn --frozen-lockfile
+        yarn install-addons
+    - uses: actions/download-artifact@v3
+      with:
+        name: build-artifacts
+    - name: Unzip artifacts
+      shell: bash
+      run: |
+        if [ "$RUNNER_OS" == "Windows" ]; then
+          pwsh -Command "7z x compressed-build.zip -aoa -o${{ github.workspace }}"
+        else
+          unzip -o compressed-build.zip
+        fi
+        ls -R
+    - name: Unit test coverage
+      run: |
+        yarn test-unit-coverage --forbid-only
+        EXIT_CODE=$?
+        ./node_modules/.bin/nyc report --reporter=cobertura
+        exit $EXIT_CODE
+
+  test-unit-parallel:
+    timeout-minutes: 20
+    strategy:
+      matrix:
+        node-version: [18]
+        runs-on: [ubuntu, macos, windows]
+    runs-on: ${{ matrix.runs-on }}-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js ${{ matrix.node-version }}.x
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node-version }}.x
+        cache: 'yarn'
+    - name: Install dependencies
+      run: |
+        yarn --frozen-lockfile
+        yarn install-addons
+    - name: Wait for build job
+      uses: NathanFirmo/wait-for-other-job@v1.1.1
+      with:
+        token: ${{ secrets.GITHUB_TOKEN }}
+        job: build
+    - uses: actions/download-artifact@v3
+      with:
+        name: build-artifacts
+    - name: Unzip artifacts
+      shell: bash
+      run: |
+        if [ "$RUNNER_OS" == "Windows" ]; then
+          pwsh -Command "7z x compressed-build.zip -aoa -o${{ github.workspace }}"
+        else
+          unzip -o compressed-build.zip
+        fi
+        ls -R
+    - name: Unit tests
+      run: yarn test-unit --forbid-only
+
+  test-unit:
+    needs: build
+    timeout-minutes: 20
+    strategy:
+      matrix:
+        node-version: [16]
+        runs-on: [ubuntu, macos, windows]
+    runs-on: ${{ matrix.runs-on }}-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js ${{ matrix.node-version }}.x
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node-version }}.x
+        cache: 'yarn'
+    - name: Install dependencies
+      run: |
+        yarn --frozen-lockfile
+        yarn install-addons
+    - uses: actions/download-artifact@v3
+      with:
+        name: build-artifacts
+    - name: Unzip artifacts
+      shell: bash
+      run: |
+        if [ "$RUNNER_OS" == "Windows" ]; then
+          pwsh -Command "7z x compressed-build.zip -aoa -o${{ github.workspace }}"
+        else
+          unzip -o compressed-build.zip
+        fi
+        ls -R
+    - name: Unit tests
+      run: yarn test-unit --forbid-only
+
+  test-api-parallel:
+    timeout-minutes: 20
+    strategy:
+      matrix:
+        node-version: [18] # just one as integration tests are about testing in browser
+        runs-on: [ubuntu] # macos is flaky
+        browser: [chromium, firefox]
+    runs-on: ${{ matrix.runs-on }}-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js ${{ matrix.node-version }}.x
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node-version }}.x
+        cache: 'yarn'
+    - name: Install dependencies
+      run: |
+        yarn --frozen-lockfile
+        yarn install-addons
+    - name: Install playwright
+      run: npx playwright install
+    - name: Wait for build job
+      uses: NathanFirmo/wait-for-other-job@v1.1.1
+      with:
+        token: ${{ secrets.GITHUB_TOKEN }}
+        job: build
+    - uses: actions/download-artifact@v3
+      with:
+        name: build-artifacts
+    - name: Unzip artifacts
+      shell: bash
+      run: |
+        if [ "$RUNNER_OS" == "Windows" ]; then
+          pwsh -Command "7z x compressed-build.zip -aoa -o${{ github.workspace }}"
+        else
+          unzip -o compressed-build.zip
+        fi
+        ls -R
+    - name: Integration tests (${{ matrix.browser }})
+      run: yarn test-api-${{ matrix.browser }} --headless --forbid-only
+
+  test-playwright-parallel:
+    timeout-minutes: 20
+    strategy:
+      matrix:
+        node-version: [18] # just one as integration tests are about testing in browser
+        runs-on: [ubuntu] # macos is flaky
+        browser: [chromium, firefox, webkit]
+    runs-on: ${{ matrix.runs-on }}-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js ${{ matrix.node-version }}.x
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node-version }}.x
+        cache: 'yarn'
+    - name: Install dependencies
+      run: |
+        yarn --frozen-lockfile
+        yarn install-addons
+    - name: Install playwright
+      run: npx playwright install --with-deps ${{ matrix.browser }}
+    - name: Wait for build job
+      uses: NathanFirmo/wait-for-other-job@v1.1.1
+      with:
+        token: ${{ secrets.GITHUB_TOKEN }}
+        job: build
+    - uses: actions/download-artifact@v3
+      with:
+        name: build-artifacts
+    - name: Unzip artifacts
+      shell: bash
+      run: |
+        if [ "$RUNNER_OS" == "Windows" ]; then
+          pwsh -Command "7z x compressed-build.zip -aoa -o${{ github.workspace }}"
+        else
+          unzip -o compressed-build.zip
+        fi
+        ls -R
+    - name: Build demo
+      run: yarn build-demo
+    - name: Integration tests
+      run: yarn test-playwright-${{ matrix.browser }} --forbid-only
+
+  test-api:
+    needs: build
+    timeout-minutes: 20
+    strategy:
+      matrix:
+        node-version: [18] # just one as integration tests are about testing in browser
+        runs-on: [windows] # macos is flaky
+        browser: [chromium, firefox]
+    runs-on: ${{ matrix.runs-on }}-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js ${{ matrix.node-version }}.x
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node-version }}.x
+        cache: 'yarn'
+    - name: Install dependencies
+      run: |
+        yarn --frozen-lockfile
+        yarn install-addons
+    - name: Install playwright
+      run: npx playwright install
+    - uses: actions/download-artifact@v3
+      with:
+        name: build-artifacts
+    - name: Unzip artifacts
+      shell: bash
+      run: |
+        if [ "$RUNNER_OS" == "Windows" ]; then
+          pwsh -Command "7z x compressed-build.zip -aoa -o${{ github.workspace }}"
+        else
+          unzip -o compressed-build.zip
+        fi
+        ls -R
+    - name: Integration tests (${{ matrix.browser }})
+      run: yarn test-api-${{ matrix.browser }} --headless --forbid-only

.github/workflows/codeql-analysis.yml

@@ -1,21 +1,9 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-#
-# ******** NOTE ********
-# We have attempted to detect the languages in your repository. Please check
-# the `language` matrix defined below to confirm you have the correct set of
-# supported CodeQL languages.
-#
 name: "CodeQL"
 
 on:
   push:
     branches: [ "master" ]
   pull_request:
-    # The branches below must be a subset of the branches above
     branches: [ "master" ]
   schedule:
     - cron: '41 17 * * 0'
@@ -33,40 +21,15 @@ jobs:
       fail-fast: false
       matrix:
         language: [ 'javascript' ]
-        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
-        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
 
     steps:
     - name: Checkout repository
       uses: actions/checkout@v3
-
-    # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
       uses: github/codeql-action/init@v2
       with:
         languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-
-        # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
-        # queries: security-extended,security-and-quality
-
-
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
-    # If this step fails, then you should remove it and run the build manually (see below)
     - name: Autobuild
       uses: github/codeql-action/autobuild@v2
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
-
-    #   If the Autobuild fails above, remove it and uncomment the following three lines.
-    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
-
-    # - run: |
-    #   echo "Run, Build Application using script"
-    #   ./location_of_script_within_repo/buildscript.sh
-
     - name: Perform CodeQL Analysis
       uses: github/codeql-action/analyze@v2

.github/workflows/release.yml

@@ -0,0 +1,30 @@
+name: Release
+
+on:
+  push:
+    # If a commit reaches master, assume it has passed CI via PR and publish
+    # without running tests to save time to publish
+    branches: [ "master" ]
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js 18.x
+      uses: actions/setup-node@v3
+      with:
+        node-version: 18.x
+        cache: 'yarn'
+    - name: Install dependencies
+      run: yarn --frozen-lockfile
+    - name: Build
+      run: yarn setup
+    - name: Package headless
+      run: |
+        yarn package-headless
+        node ./bin/package_headless.js
+    - name: Publish to npm
+      env:
+        NPM_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      run: node ./bin/publish.js

.nvmrc

@@ -0,0 +1 @@
+16

.vscode/settings.json

@@ -1,4 +1,7 @@
 {
+  "files.associations": {
+    ".eslintrc.json.typings": "jsonc"
+  },
   "typescript.preferences.importModuleSpecifier": "non-relative",
   "typescript.preferences.quoteStyle": "single",
   "mochaExplorer.envPath": ".mocha.env",

CONTRIBUTING.md

@@ -28,6 +28,10 @@ opening an issue, read these pointers.
 - Be polite. Issues with an indignant or belligerent tone tend to be moved to the
   bottom of the pile.
 
+## Answering discussion questions
+
+Issues are only meant to track (likely) feature requests and bugs. We use [GitHub Discussions](https://github.com/xtermjs/xterm.js/discussions) for general Q&A as well as discussing possible features. If you want to help out, many questions get asked over at the [discussions page](https://github.com/xtermjs/xterm.js/discussions) which could use an expert as the core team is often stretched thin.
+
 ## Contributing code
 
 You can find issues to work on by looking at the [help wanted](https://github.com/xtermjs/xterm.js/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22) or [good first issue](https://github.com/xtermjs/xterm.js/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22) issues. It's a good idea to comment on the issue saying that you're taking it, just in case someone else comes along and you duplicate work. Once you have your issue, here are the steps to contribute:

README.md

@@ -1,7 +1,5 @@
 # [![xterm.js logo](logo-full.png)](https://xtermjs.org)
 
-[![Build Status](https://dev.azure.com/xtermjs/xterm.js/_apis/build/status/xtermjs.xterm.js)](https://dev.azure.com/xtermjs/xterm.js/_build/latest?definitionId=3)
-
 Xterm.js is a front-end component written in TypeScript that lets applications bring fully-featured terminals to their users in the browser. It's used by popular projects such as VS Code, Hyper and Theia.
 
 ## Features
@@ -99,6 +97,26 @@ The full API for xterm.js is contained within the [TypeScript declaration file](
 
 Note that some APIs are marked *experimental*, these are added to enable experimentation with new ideas without committing to support it like a normal [semver](https://semver.org/) API. Note that these APIs can change radically between versions, so be sure to read release notes if you plan on using experimental APIs.
 
+## Releases
+
+Xterm.js follows a monthly release cycle roughly.
+
+All current and past releases are available on this repo's [Releases page](https://github.com/sourcelair/xterm.js/releases), you can view the [high-level roadmap on the wiki](https://github.com/xtermjs/xterm.js/wiki/Roadmap) and see what we're working on now by looking through [Milestones](https://github.com/sourcelair/xterm.js/milestones).
+
+### Beta builds
+
+Our CI releases beta builds to npm for every change that goes into master. Install the latest beta build with:
+
+```bash
+npm install -S xterm@beta
+```
+
+These should generally be stable, but some bugs may slip in. We recommend using the beta build primarily to test out new features and to verify bug fixes.
+
+## Contributing
+
+You can read the [guide on the wiki](https://github.com/xtermjs/xterm.js/wiki/Contributing) to learn how to contribute and set up xterm.js for development.
+
 ## Real-world uses
 Xterm.js is used in several world-class applications to provide great terminal experiences.
 
@@ -166,7 +184,7 @@ Xterm.js is used in several world-class applications to provide great terminal e
 - [**DockerStacks**](https://docker-stacks.com/): Local LAMP/LEMP development studio
 - [**Codecademy**](https://codecademy.com/): Uses xterm.js in its courses on Bash.
 - [**Laravel Ssh Web Client**](https://github.com/roke22/Laravel-ssh-client): Laravel server inventory with ssh web client to connect at server using xterm.js
-- [**Repl.it**](https://repl.it): Collaborative browser based IDE with support for 50+ different languages.
+- [**Replit**](https://replit.com): Collaborative browser based IDE with support for 50+ different languages.
 - [**TeleType**](https://github.com/akshaykmr/TeleType): cli tool that allows you to share your terminal online conveniently. Show off mad cli-fu, help a colleague, teach, or troubleshoot.
 - [**Intervue**](https://www.intervue.io): Pair programming for interviews. Multiple programming languages are supported, with results displayed by xterm.js.
 - [**TRASA**](https://trasa.io): Zero trust access to Web, SSH, RDP, and Database services.
@@ -193,34 +211,20 @@ Xterm.js is used in several world-class applications to provide great terminal e
 - [**Go SSH Web Client**](https://github.com/wuchihsu/go-ssh-web-client): A simple SSH web client using Go, WebSocket and Xterm.js.
 - [**web3os**](https://web3os.sh): A decentralized operating system for the next web
 - [**Cratecode**](https://cratecode.com): Learn to program for free through interactive online lessons. Cratecode uses xterm.js to give users access to their own Linux environment.
+- [**Super Terminal**](https://github.com/bugwheels94/super-terminal): It is a http based terminal for developers who dont like repetition and save time.
+- [**graSSHopper**](https://grasshopper.coding.kiwi): A simple SSH client with file explorer, history and many more features.
+- [**DomTerm**](https://domterm.org/xtermjs.html): Tiles and tabs. Detachable sessions (like tmux). [Remote connections](https://domterm.org/Remoting-over-ssh.html) using a nice ssh wrapper with predictive echo. Qt, Electron, Tauri/Wry, or desktop browser front-ends. Choose between xterm.js engine (faster) or native DomTerm (more functionality and graphics) - or both.
+- [**Cloudtutor.io**](https://cloudtutor.io): innovative online learning platform that offers users access to an interactive lab.
+- [**Helix Editor Playground**](https://github.com/tomgroenwoldt/helix-editor-playground): Online playground for the terminal based helix editor.
+- [**Coder**](https://github.com/coder/coder): Self-Hosted Remote Development Environments
 - [And much more...](https://github.com/xtermjs/xterm.js/network/dependents?package_id=UGFja2FnZS0xNjYzMjc4OQ%3D%3D)
 
 Do you use xterm.js in your application as well? Please [open a Pull Request](https://github.com/sourcelair/xterm.js/pulls) to include it here. We would love to have it on our list. Note: Please add any new contributions to the end of the list only.
 
-## Releases
-
-Xterm.js follows a monthly release cycle roughly.
-
-All current and past releases are available on this repo's [Releases page](https://github.com/sourcelair/xterm.js/releases), you can view the [high-level roadmap on the wiki](https://github.com/xtermjs/xterm.js/wiki/Roadmap) and see what we're working on now by looking through [Milestones](https://github.com/sourcelair/xterm.js/milestones).
-
-### Beta builds
-
-Our CI releases beta builds to npm for every change that goes into master. Install the latest beta build with:
-
-```bash
-npm install -S xterm@beta
-```
-
-These should generally be stable, but some bugs may slip in. We recommend using the beta build primarily to test out new features and to verify bug fixes.
-
-## Contributing
-
-You can read the [guide on the wiki](https://github.com/xtermjs/xterm.js/wiki/Contributing) to learn how to contribute and set up xterm.js for development.
-
 ## License Agreement
 
 If you contribute code to this project, you implicitly allow your code to be distributed under the MIT license. You are also implicitly verifying that all code is your original work.
 
-Copyright (c) 2017-2019, [The xterm.js authors](https://github.com/xtermjs/xterm.js/graphs/contributors) (MIT License)<br>
+Copyright (c) 2017-2022, [The xterm.js authors](https://github.com/xtermjs/xterm.js/graphs/contributors) (MIT License)<br>
 Copyright (c) 2014-2017, SourceLair, Private Company ([www.sourcelair.com](https://www.sourcelair.com/home)) (MIT License)<br>
 Copyright (c) 2012-2013, Christopher Jeffrey (MIT License)

addons/xterm-addon-attach/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xterm-addon-attach",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "author": {
     "name": "The xterm.js authors",
     "url": "https://xtermjs.org/"

addons/xterm-addon-attach/src/AttachAddon.ts

@@ -47,16 +47,14 @@ export class AttachAddon implements ITerminalAddon {
   }
 
   private _sendData(data: string): void {
-    // TODO: do something better than just swallowing
-    // the data if the socket is not in a working condition
-    if (this._socket.readyState !== 1) {
+    if (!this._checkOpenSocket()) {
       return;
     }
     this._socket.send(data);
   }
 
   private _sendBinary(data: string): void {
-    if (this._socket.readyState !== 1) {
+    if (!this._checkOpenSocket()) {
       return;
     }
     const buffer = new Uint8Array(data.length);
@@ -65,6 +63,22 @@ export class AttachAddon implements ITerminalAddon {
     }
     this._socket.send(buffer);
   }
+
+  private _checkOpenSocket(): boolean {
+    switch (this._socket.readyState) {
+      case WebSocket.OPEN:
+        return true;
+      case WebSocket.CONNECTING:
+        throw new Error('Attach addon was loaded before socket was open');
+      case WebSocket.CLOSING:
+        console.warn('Attach addon socket is closing');
+        return false;
+      case WebSocket.CLOSED:
+        throw new Error('Attach addon socket is closed');
+      default:
+        throw new Error('Unexpected socket state');
+    }
+  }
 }
 
 function addSocketListener<K extends keyof WebSocketEventMap>(socket: WebSocket, type: K, handler: (this: WebSocket, ev: WebSocketEventMap[K]) => any): IDisposable {

addons/xterm-addon-attach/test/AttachAddon.api.ts

@@ -5,7 +5,7 @@
 
 import WebSocket = require('ws');
 import { openTerminal, pollFor, launchBrowser } from '../../../out-test/api/TestUtils';
-import { Browser, Page } from 'playwright';
+import { Browser, Page } from '@playwright/test';
 
 const APP = 'http://127.0.0.1:3001/test';
 

addons/xterm-addon-canvas/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xterm-addon-canvas",
-  "version": "0.2.0",
+  "version": "0.5.0",
   "author": {
     "name": "The xterm.js authors",
     "url": "https://xtermjs.org/"

addons/xterm-addon-canvas/src/BaseRenderLayer.ts

@@ -3,77 +3,78 @@
  * @license MIT
  */
 
-import { IRenderDimensions } from 'browser/renderer/Types';
-import { IRenderLayer } from './Types';
-import { ICellData, IColor } from 'common/Types';
-import { DEFAULT_COLOR, WHITESPACE_CELL_CHAR, WHITESPACE_CELL_CODE, Attributes } from 'common/buffer/Constants';
-import { IGlyphIdentifier } from './atlas/Types';
-import { DIM_OPACITY, INVERTED_DEFAULT_COLOR, TEXT_BASELINE } from 'browser/renderer/Constants';
-import { BaseCharAtlas } from './atlas/BaseCharAtlas';
-import { acquireCharAtlas } from './atlas/CharAtlasCache';
-import { AttributeData } from 'common/buffer/AttributeData';
-import { IColorSet } from 'browser/Types';
+import { ReadonlyColorSet } from 'browser/Types';
+import { CellColorResolver } from 'browser/renderer/shared/CellColorResolver';
+import { acquireTextureAtlas } from 'browser/renderer/shared/CharAtlasCache';
+import { TEXT_BASELINE } from 'browser/renderer/shared/Constants';
+import { tryDrawCustomChar } from 'browser/renderer/shared/CustomGlyphs';
+import { throwIfFalsy } from 'browser/renderer/shared/RendererUtils';
+import { createSelectionRenderModel } from 'browser/renderer/shared/SelectionRenderModel';
+import { IRasterizedGlyph, IRenderDimensions, ISelectionRenderModel, ITextureAtlas } from 'browser/renderer/shared/Types';
+import { ICoreBrowserService, IThemeService } from 'browser/services/Services';
+import { EventEmitter, forwardEvent } from 'common/EventEmitter';
+import { Disposable, MutableDisposable, toDisposable } from 'common/Lifecycle';
+import { isSafari } from 'common/Platform';
+import { ICellData } from 'common/Types';
 import { CellData } from 'common/buffer/CellData';
+import { WHITESPACE_CELL_CODE } from 'common/buffer/Constants';
 import { IBufferService, IDecorationService, IOptionsService } from 'common/services/Services';
-import { ICoreBrowserService } from 'browser/services/Services';
-import { excludeFromContrastRatioDemands, throwIfFalsy } from 'browser/renderer/RendererUtils';
-import { channels, color, rgba } from 'common/Color';
-import { removeElementFromParent } from 'browser/Dom';
-import { tryDrawCustomChar } from 'browser/renderer/CustomGlyphs';
+import { Terminal } from 'xterm';
+import { IRenderLayer } from './Types';
 
-export abstract class BaseRenderLayer implements IRenderLayer {
+export abstract class BaseRenderLayer extends Disposable implements IRenderLayer {
   private _canvas: HTMLCanvasElement;
   protected _ctx!: CanvasRenderingContext2D;
-  private _scaledCharWidth: number = 0;
-  private _scaledCharHeight: number = 0;
-  private _scaledCellWidth: number = 0;
-  private _scaledCellHeight: number = 0;
-  private _scaledCharLeft: number = 0;
-  private _scaledCharTop: number = 0;
+  private _deviceCharWidth: number = 0;
+  private _deviceCharHeight: number = 0;
+  private _deviceCellWidth: number = 0;
+  private _deviceCellHeight: number = 0;
+  private _deviceCharLeft: number = 0;
+  private _deviceCharTop: number = 0;
 
-  protected _selectionStart: [number, number] | undefined;
-  protected _selectionEnd: [number, number] | undefined;
-  protected _columnSelectMode: boolean = false;
+  protected _selectionModel: ISelectionRenderModel = createSelectionRenderModel();
+  private _cellColorResolver: CellColorResolver;
+  private _bitmapGenerator: (BitmapGenerator | undefined)[] = [];
 
-  protected _charAtlas: BaseCharAtlas | undefined;
-
-  /**
-   * An object that's reused when drawing glyphs in order to reduce GC.
-   */
-  private _currentGlyphIdentifier: IGlyphIdentifier = {
-    chars: '',
-    code: 0,
-    bg: 0,
-    fg: 0,
-    bold: false,
-    dim: false,
-    italic: false
-  };
+  protected _charAtlas!: ITextureAtlas;
+  protected _charAtlasDisposable = this.register(new MutableDisposable());
 
   public get canvas(): HTMLCanvasElement { return this._canvas; }
+  public get cacheCanvas(): HTMLCanvasElement { return this._charAtlas?.pages[0].canvas!; }
+
+  private readonly _onAddTextureAtlasCanvas = this.register(new EventEmitter<HTMLCanvasElement>());
+  public readonly onAddTextureAtlasCanvas = this._onAddTextureAtlasCanvas.event;
 
   constructor(
+    private readonly _terminal: Terminal,
     private _container: HTMLElement,
     id: string,
     zIndex: number,
     private _alpha: boolean,
-    protected _colors: IColorSet,
-    private _rendererId: number,
+    protected readonly _themeService: IThemeService,
     protected readonly _bufferService: IBufferService,
     protected readonly _optionsService: IOptionsService,
     protected readonly _decorationService: IDecorationService,
     protected readonly _coreBrowserService: ICoreBrowserService
   ) {
+    super();
+    this._cellColorResolver = new CellColorResolver(this._terminal, this._selectionModel, this._decorationService, this._coreBrowserService, this._themeService);
     this._canvas = document.createElement('canvas');
     this._canvas.classList.add(`xterm-${id}-layer`);
     this._canvas.style.zIndex = zIndex.toString();
     this._initCanvas();
     this._container.appendChild(this._canvas);
-  }
+    this._refreshCharAtlas(this._themeService.colors);
+    this.register(this._themeService.onChangeColors(e => {
+      this._refreshCharAtlas(e);
+      this.reset();
+      // Trigger selection changed as it's handled separately to regular rendering
+      this.handleSelectionChanged(this._selectionModel.selectionStart, this._selectionModel.selectionEnd, this._selectionModel.columnSelectMode);
+    }));
 
-  public dispose(): void {
-    removeElementFromParent(this._canvas);
-    this._charAtlas?.dispose();
+    this.register(toDisposable(() => {
+      this._canvas.remove();
+    }));
   }
 
   private _initCanvas(): void {
@@ -84,20 +85,13 @@ export abstract class BaseRenderLayer implements IRenderLayer {
     }
   }
 
-  public onOptionsChanged(): void {}
-  public onBlur(): void {}
-  public onFocus(): void {}
-  public onCursorMove(): void {}
-  public onGridChanged(startRow: number, endRow: number): void {}
+  public handleBlur(): void {}
+  public handleFocus(): void {}
+  public handleCursorMove(): void {}
+  public handleGridChanged(startRow: number, endRow: number): void {}
 
-  public onSelectionChanged(start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean = false): void {
-    this._selectionStart = start;
-    this._selectionEnd = end;
-    this._columnSelectMode = columnSelectMode;
-  }
-
-  public setColors(colorSet: IColorSet): void {
-    this._refreshCharAtlas(colorSet);
+  public handleSelectionChanged(start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean = false): void {
+    this._selectionModel.update(this._terminal, start, end, columnSelectMode);
   }
 
   protected _setTransparency(alpha: boolean): void {
@@ -115,46 +109,50 @@ export abstract class BaseRenderLayer implements IRenderLayer {
     this._container.replaceChild(this._canvas, oldCanvas);
 
     // Regenerate char atlas and force a full redraw
-    this._refreshCharAtlas(this._colors);
-    this.onGridChanged(0, this._bufferService.rows - 1);
+    this._refreshCharAtlas(this._themeService.colors);
+    this.handleGridChanged(0, this._bufferService.rows - 1);
   }
 
   /**
    * Refreshes the char atlas, aquiring a new one if necessary.
    * @param colorSet The color set to use for the char atlas.
    */
-  private _refreshCharAtlas(colorSet: IColorSet): void {
-    if (this._scaledCharWidth <= 0 && this._scaledCharHeight <= 0) {
+  private _refreshCharAtlas(colorSet: ReadonlyColorSet): void {
+    if (this._deviceCharWidth <= 0 && this._deviceCharHeight <= 0) {
       return;
     }
-    this._charAtlas = acquireCharAtlas(this._optionsService.rawOptions, this._rendererId, colorSet, this._scaledCharWidth, this._scaledCharHeight, this._coreBrowserService.dpr);
+    this._charAtlas = acquireTextureAtlas(this._terminal, this._optionsService.rawOptions, colorSet, this._deviceCellWidth, this._deviceCellHeight, this._deviceCharWidth, this._deviceCharHeight, this._coreBrowserService.dpr);
+    this._charAtlasDisposable.value = forwardEvent(this._charAtlas.onAddTextureAtlasCanvas, this._onAddTextureAtlasCanvas);
     this._charAtlas.warmUp();
+    for (let i = 0; i < this._charAtlas.pages.length; i++) {
+      this._bitmapGenerator[i] = new BitmapGenerator(this._charAtlas.pages[i].canvas);
+    }
   }
 
   public resize(dim: IRenderDimensions): void {
-    this._scaledCellWidth = dim.scaledCellWidth;
-    this._scaledCellHeight = dim.scaledCellHeight;
-    this._scaledCharWidth = dim.scaledCharWidth;
-    this._scaledCharHeight = dim.scaledCharHeight;
-    this._scaledCharLeft = dim.scaledCharLeft;
-    this._scaledCharTop = dim.scaledCharTop;
-    this._canvas.width = dim.scaledCanvasWidth;
-    this._canvas.height = dim.scaledCanvasHeight;
-    this._canvas.style.width = `${dim.canvasWidth}px`;
-    this._canvas.style.height = `${dim.canvasHeight}px`;
+    this._deviceCellWidth = dim.device.cell.width;
+    this._deviceCellHeight = dim.device.cell.height;
+    this._deviceCharWidth = dim.device.char.width;
+    this._deviceCharHeight = dim.device.char.height;
+    this._deviceCharLeft = dim.device.char.left;
+    this._deviceCharTop = dim.device.char.top;
+    this._canvas.width = dim.device.canvas.width;
+    this._canvas.height = dim.device.canvas.height;
+    this._canvas.style.width = `${dim.css.canvas.width}px`;
+    this._canvas.style.height = `${dim.css.canvas.height}px`;
 
     // Draw the background if this is an opaque layer
     if (!this._alpha) {
       this._clearAll();
     }
 
-    this._refreshCharAtlas(this._colors);
+    this._refreshCharAtlas(this._themeService.colors);
   }
 
   public abstract reset(): void;
 
   public clearTextureAtlas(): void {
-    this._charAtlas?.clear();
+    this._charAtlas?.clearTexture();
   }
 
   /**
@@ -166,24 +164,24 @@ export abstract class BaseRenderLayer implements IRenderLayer {
    */
   protected _fillCells(x: number, y: number, width: number, height: number): void {
     this._ctx.fillRect(
-      x * this._scaledCellWidth,
-      y * this._scaledCellHeight,
-      width * this._scaledCellWidth,
-      height * this._scaledCellHeight);
+      x * this._deviceCellWidth,
+      y * this._deviceCellHeight,
+      width * this._deviceCellWidth,
+      height * this._deviceCellHeight);
   }
 
   /**
-     * Fills a 1px line (2px on HDPI) at the middle of the cell. This uses the
-     * existing fillStyle on the context.
-     * @param x The column to fill.
-     * @param y The row to fill.
-     */
+   * Fills a 1px line (2px on HDPI) at the middle of the cell. This uses the
+   * existing fillStyle on the context.
+   * @param x The column to fill.
+   * @param y The row to fill.
+   */
   protected _fillMiddleLineAtCells(x: number, y: number, width: number = 1): void {
-    const cellOffset = Math.ceil(this._scaledCellHeight * 0.5);
+    const cellOffset = Math.ceil(this._deviceCellHeight * 0.5);
     this._ctx.fillRect(
-      x * this._scaledCellWidth,
-      (y + 1) * this._scaledCellHeight - cellOffset - this._coreBrowserService.dpr,
-      width * this._scaledCellWidth,
+      x * this._deviceCellWidth,
+      (y + 1) * this._deviceCellHeight - cellOffset - this._coreBrowserService.dpr,
+      width * this._deviceCellWidth,
       this._coreBrowserService.dpr);
   }
 
@@ -195,9 +193,9 @@ export abstract class BaseRenderLayer implements IRenderLayer {
    */
   protected _fillBottomLineAtCells(x: number, y: number, width: number = 1, pixelOffset: number = 0): void {
     this._ctx.fillRect(
-      x * this._scaledCellWidth,
-      (y + 1) * this._scaledCellHeight + pixelOffset - this._coreBrowserService.dpr - 1 /* Ensure it's drawn within the cell */,
-      width * this._scaledCellWidth,
+      x * this._deviceCellWidth,
+      (y + 1) * this._deviceCellHeight + pixelOffset - this._coreBrowserService.dpr - 1 /* Ensure it's drawn within the cell */,
+      width * this._deviceCellWidth,
       this._coreBrowserService.dpr);
   }
 
@@ -208,10 +206,10 @@ export abstract class BaseRenderLayer implements IRenderLayer {
     const lineWidth = this._coreBrowserService.dpr;
     this._ctx.lineWidth = lineWidth;
     for (let xOffset = 0; xOffset < width; xOffset++) {
-      const xLeft = (x + xOffset) * this._scaledCellWidth;
-      const xMid = (x + xOffset + 0.5) * this._scaledCellWidth;
-      const xRight = (x + xOffset + 1) * this._scaledCellWidth;
-      const yMid = (y + 1) * this._scaledCellHeight - lineWidth - 1;
+      const xLeft = (x + xOffset) * this._deviceCellWidth;
+      const xMid = (x + xOffset + 0.5) * this._deviceCellWidth;
+      const xRight = (x + xOffset + 1) * this._deviceCellWidth;
+      const yMid = (y + 1) * this._deviceCellHeight - lineWidth - 1;
       const yMidBot = yMid - lineWidth;
       const yMidTop = yMid + lineWidth;
       this._ctx.moveTo(xLeft, yMid);
@@ -237,12 +235,12 @@ export abstract class BaseRenderLayer implements IRenderLayer {
     const lineWidth = this._coreBrowserService.dpr;
     this._ctx.lineWidth = lineWidth;
     this._ctx.setLineDash([lineWidth * 2, lineWidth]);
-    const xLeft = x * this._scaledCellWidth;
-    const yMid = (y + 1) * this._scaledCellHeight - lineWidth - 1;
+    const xLeft = x * this._deviceCellWidth;
+    const yMid = (y + 1) * this._deviceCellHeight - lineWidth - 1;
     this._ctx.moveTo(xLeft, yMid);
     for (let xOffset = 0; xOffset < width; xOffset++) {
-      // const xLeft = x * this._scaledCellWidth;
-      const xRight = (x + width + xOffset) * this._scaledCellWidth;
+      // const xLeft = x * this._deviceCellWidth;
+      const xRight = (x + width + xOffset) * this._deviceCellWidth;
       this._ctx.lineTo(xRight, yMid);
     }
     this._ctx.stroke();
@@ -257,9 +255,9 @@ export abstract class BaseRenderLayer implements IRenderLayer {
     const lineWidth = this._coreBrowserService.dpr;
     this._ctx.lineWidth = lineWidth;
     this._ctx.setLineDash([lineWidth * 4, lineWidth * 3]);
-    const xLeft = x * this._scaledCellWidth;
-    const xRight = (x + width) * this._scaledCellWidth;
-    const yMid = (y + 1) * this._scaledCellHeight - lineWidth - 1;
+    const xLeft = x * this._deviceCellWidth;
+    const xRight = (x + width) * this._deviceCellWidth;
+    const yMid = (y + 1) * this._deviceCellHeight - lineWidth - 1;
     this._ctx.moveTo(xLeft, yMid);
     this._ctx.lineTo(xRight, yMid);
     this._ctx.stroke();
@@ -275,10 +273,10 @@ export abstract class BaseRenderLayer implements IRenderLayer {
    */
   protected _fillLeftLineAtCell(x: number, y: number, width: number): void {
     this._ctx.fillRect(
-      x * this._scaledCellWidth,
-      y * this._scaledCellHeight,
+      x * this._deviceCellWidth,
+      y * this._deviceCellHeight,
       this._coreBrowserService.dpr * width,
-      this._scaledCellHeight);
+      this._deviceCellHeight);
   }
 
   /**
@@ -291,10 +289,10 @@ export abstract class BaseRenderLayer implements IRenderLayer {
     const lineWidth = this._coreBrowserService.dpr;
     this._ctx.lineWidth = lineWidth;
     this._ctx.strokeRect(
-      x * this._scaledCellWidth + lineWidth / 2,
-      y * this._scaledCellHeight + (lineWidth / 2),
-      width * this._scaledCellWidth - lineWidth,
-      (height * this._scaledCellHeight) - lineWidth);
+      x * this._deviceCellWidth + lineWidth / 2,
+      y * this._deviceCellHeight + (lineWidth / 2),
+      width * this._deviceCellWidth - lineWidth,
+      (height * this._deviceCellHeight) - lineWidth);
   }
 
   /**
@@ -304,7 +302,7 @@ export abstract class BaseRenderLayer implements IRenderLayer {
     if (this._alpha) {
       this._ctx.clearRect(0, 0, this._canvas.width, this._canvas.height);
     } else {
-      this._ctx.fillStyle = this._colors.background.css;
+      this._ctx.fillStyle = this._themeService.colors.background.css;
       this._ctx.fillRect(0, 0, this._canvas.width, this._canvas.height);
     }
   }
@@ -319,17 +317,17 @@ export abstract class BaseRenderLayer implements IRenderLayer {
   protected _clearCells(x: number, y: number, width: number, height: number): void {
     if (this._alpha) {
       this._ctx.clearRect(
-        x * this._scaledCellWidth,
-        y * this._scaledCellHeight,
-        width * this._scaledCellWidth,
-        height * this._scaledCellHeight);
+        x * this._deviceCellWidth,
+        y * this._deviceCellHeight,
+        width * this._deviceCellWidth,
+        height * this._deviceCellHeight);
     } else {
-      this._ctx.fillStyle = this._colors.background.css;
+      this._ctx.fillStyle = this._themeService.colors.background.css;
       this._ctx.fillRect(
-        x * this._scaledCellWidth,
-        y * this._scaledCellHeight,
-        width * this._scaledCellWidth,
-        height * this._scaledCellHeight);
+        x * this._deviceCellWidth,
+        y * this._deviceCellHeight,
+        width * this._deviceCellWidth,
+        height * this._deviceCellHeight);
     }
   }
 
@@ -340,7 +338,6 @@ export abstract class BaseRenderLayer implements IRenderLayer {
    * @param cell The cell data for the character to draw.
    * @param x The column to draw at.
    * @param y The row to draw at.
-   * @param color The color of the character.
    */
   protected _fillCharTrueColor(cell: CellData, x: number, y: number): void {
     this._ctx.font = this._getFont(false, false);
@@ -350,149 +347,73 @@ export abstract class BaseRenderLayer implements IRenderLayer {
     // Draw custom characters if applicable
     let drawSuccess = false;
     if (this._optionsService.rawOptions.customGlyphs !== false) {
-      drawSuccess = tryDrawCustomChar(this._ctx, cell.getChars(), x * this._scaledCellWidth, y * this._scaledCellHeight, this._scaledCellWidth, this._scaledCellHeight, this._optionsService.rawOptions.fontSize, this._coreBrowserService.dpr);
+      drawSuccess = tryDrawCustomChar(this._ctx, cell.getChars(), x * this._deviceCellWidth, y * this._deviceCellHeight, this._deviceCellWidth, this._deviceCellHeight, this._optionsService.rawOptions.fontSize, this._coreBrowserService.dpr);
     }
 
     // Draw the character
     if (!drawSuccess) {
       this._ctx.fillText(
         cell.getChars(),
-        x * this._scaledCellWidth + this._scaledCharLeft,
-        y * this._scaledCellHeight + this._scaledCharTop + this._scaledCharHeight);
+        x * this._deviceCellWidth + this._deviceCharLeft,
+        y * this._deviceCellHeight + this._deviceCharTop + this._deviceCharHeight);
     }
   }
 
   /**
    * Draws one or more characters at a cell. If possible this will draw using
    * the character atlas to reduce draw time.
-   * @param chars The character or characters.
-   * @param code The character code.
-   * @param width The width of the characters.
-   * @param x The column to draw at.
-   * @param y The row to draw at.
-   * @param fg The foreground color, in the format stored within the attributes.
-   * @param bg The background color, in the format stored within the attributes.
-   * This is used to validate whether a cached image can be used.
-   * @param bold Whether the text is bold.
    */
   protected _drawChars(cell: ICellData, x: number, y: number): void {
-    const contrastColor = this._getContrastColor(cell, x, y);
+    const chars = cell.getChars();
+    this._cellColorResolver.resolve(cell, x, this._bufferService.buffer.ydisp + y);
 
-    // skip cache right away if we draw in RGB
-    // Note: to avoid bad runtime JoinedCellData will be skipped
-    //       in the cache handler itself (atlasDidDraw == false) and
-    //       fall through to uncached later down below
-    if (contrastColor || cell.isFgRGB() || cell.isBgRGB()) {
-      this._drawUncachedChars(cell, x, y, contrastColor);
+    if (!this._charAtlas) {
       return;
     }
 
-    let fg;
-    let bg;
-    if (cell.isInverse()) {
-      fg = (cell.isBgDefault()) ? INVERTED_DEFAULT_COLOR : cell.getBgColor();
-      bg = (cell.isFgDefault()) ? INVERTED_DEFAULT_COLOR : cell.getFgColor();
+    let glyph: IRasterizedGlyph;
+    if (chars && chars.length > 1) {
+      glyph = this._charAtlas.getRasterizedGlyphCombinedChar(chars, this._cellColorResolver.result.bg, this._cellColorResolver.result.fg, this._cellColorResolver.result.ext, true);
     } else {
-      bg = (cell.isBgDefault()) ? DEFAULT_COLOR : cell.getBgColor();
-      fg = (cell.isFgDefault()) ? DEFAULT_COLOR : cell.getFgColor();
+      glyph = this._charAtlas.getRasterizedGlyph(cell.getCode() || WHITESPACE_CELL_CODE, this._cellColorResolver.result.bg, this._cellColorResolver.result.fg, this._cellColorResolver.result.ext, true);
     }
-
-    const drawInBrightColor = this._optionsService.rawOptions.drawBoldTextInBrightColors && cell.isBold() && fg < 8;
-
-    fg += drawInBrightColor ? 8 : 0;
-    this._currentGlyphIdentifier.chars = cell.getChars() || WHITESPACE_CELL_CHAR;
-    this._currentGlyphIdentifier.code = cell.getCode() || WHITESPACE_CELL_CODE;
-    this._currentGlyphIdentifier.bg = bg;
-    this._currentGlyphIdentifier.fg = fg;
-    this._currentGlyphIdentifier.bold = !!cell.isBold();
-    this._currentGlyphIdentifier.dim = !!cell.isDim();
-    this._currentGlyphIdentifier.italic = !!cell.isItalic();
-
-    // Don't try cache the glyph if it uses any decoration foreground/background override.
-    let hasOverrides = false;
-    this._decorationService.forEachDecorationAtCell(x, y, undefined, d => {
-      if (d.backgroundColorRGB || d.foregroundColorRGB) {
-        hasOverrides = true;
-      }
-    });
-
-    const atlasDidDraw = hasOverrides ? false : this._charAtlas?.draw(this._ctx, this._currentGlyphIdentifier, x * this._scaledCellWidth + this._scaledCharLeft, y * this._scaledCellHeight + this._scaledCharTop);
-
-    if (!atlasDidDraw) {
-      this._drawUncachedChars(cell, x, y);
+    if (!glyph.size.x || !glyph.size.y) {
+      return;
     }
-  }
-
-  /**
-   * Draws one or more characters at one or more cells. The character(s) will be
-   * clipped to ensure that they fit with the cell(s), including the cell to the
-   * right if the last character is a wide character.
-   * @param chars The character.
-   * @param width The width of the character.
-   * @param fg The foreground color, in the format stored within the attributes.
-   * @param x The column to draw at.
-   * @param y The row to draw at.
-   */
-  private _drawUncachedChars(cell: ICellData, x: number, y: number, fgOverride?: IColor): void {
     this._ctx.save();
-    this._ctx.font = this._getFont(!!cell.isBold(), !!cell.isItalic());
-    this._ctx.textBaseline = TEXT_BASELINE;
-
-    if (cell.isInverse()) {
-      if (fgOverride) {
-        this._ctx.fillStyle = fgOverride.css;
-      } else if (cell.isBgDefault()) {
-        this._ctx.fillStyle = color.opaque(this._colors.background).css;
-      } else if (cell.isBgRGB()) {
-        this._ctx.fillStyle = `rgb(${AttributeData.toColorRGB(cell.getBgColor()).join(',')})`;
-      } else {
-        let bg = cell.getBgColor();
-        if (this._optionsService.rawOptions.drawBoldTextInBrightColors && cell.isBold() && bg < 8) {
-          bg += 8;
-        }
-        this._ctx.fillStyle = this._colors.ansi[bg].css;
-      }
-    } else {
-      if (fgOverride) {
-        this._ctx.fillStyle = fgOverride.css;
-      } else if (cell.isFgDefault()) {
-        this._ctx.fillStyle = this._colors.foreground.css;
-      } else if (cell.isFgRGB()) {
-        this._ctx.fillStyle = `rgb(${AttributeData.toColorRGB(cell.getFgColor()).join(',')})`;
-      } else {
-        let fg = cell.getFgColor();
-        if (this._optionsService.rawOptions.drawBoldTextInBrightColors && cell.isBold() && fg < 8) {
-          fg += 8;
-        }
-        this._ctx.fillStyle = this._colors.ansi[fg].css;
-      }
-    }
-
     this._clipRow(y);
 
-    // Apply alpha to dim the character
-    if (cell.isDim()) {
-      this._ctx.globalAlpha = DIM_OPACITY;
+    // Draw the image, use the bitmap if it's available
+
+    // HACK: If the canvas doesn't match, delete the generator. It's not clear how this happens but
+    // something is wrong with either the lifecycle of _bitmapGenerator or the page canvases are
+    // swapped out unexpectedly
+    if (this._bitmapGenerator[glyph.texturePage] && this._charAtlas.pages[glyph.texturePage].canvas !== this._bitmapGenerator[glyph.texturePage]!.canvas) {
+      this._bitmapGenerator[glyph.texturePage]?.bitmap?.close();
+      delete this._bitmapGenerator[glyph.texturePage];
     }
 
-    // Draw custom characters if applicable
-    let drawSuccess = false;
-    if (this._optionsService.rawOptions.customGlyphs !== false) {
-      drawSuccess = tryDrawCustomChar(this._ctx, cell.getChars(), x * this._scaledCellWidth, y * this._scaledCellHeight, this._scaledCellWidth, this._scaledCellHeight, this._optionsService.rawOptions.fontSize, this._coreBrowserService.dpr);
+    if (this._charAtlas.pages[glyph.texturePage].version !== this._bitmapGenerator[glyph.texturePage]?.version) {
+      if (!this._bitmapGenerator[glyph.texturePage]) {
+        this._bitmapGenerator[glyph.texturePage] = new BitmapGenerator(this._charAtlas.pages[glyph.texturePage].canvas);
+      }
+      this._bitmapGenerator[glyph.texturePage]!.refresh();
+      this._bitmapGenerator[glyph.texturePage]!.version = this._charAtlas.pages[glyph.texturePage].version;
     }
-
-    // Draw the character
-    if (!drawSuccess) {
-      this._ctx.fillText(
-        cell.getChars(),
-        x * this._scaledCellWidth + this._scaledCharLeft,
-        y * this._scaledCellHeight + this._scaledCharTop + this._scaledCharHeight);
-    }
-
+    this._ctx.drawImage(
+      this._bitmapGenerator[glyph.texturePage]?.bitmap || this._charAtlas!.pages[glyph.texturePage].canvas,
+      glyph.texturePosition.x,
+      glyph.texturePosition.y,
+      glyph.size.x,
+      glyph.size.y,
+      x * this._deviceCellWidth + this._deviceCharLeft - glyph.offset.x,
+      y * this._deviceCellHeight + this._deviceCharTop - glyph.offset.y,
+      glyph.size.x,
+      glyph.size.y
+    );
     this._ctx.restore();
   }
 
-
   /**
    * Clips a row to ensure no pixels will be drawn outside the cells in the row.
    * @param y The row to clip.
@@ -501,9 +422,9 @@ export abstract class BaseRenderLayer implements IRenderLayer {
     this._ctx.beginPath();
     this._ctx.rect(
       0,
-      y * this._scaledCellHeight,
-      this._bufferService.cols * this._scaledCellWidth,
-      this._scaledCellHeight);
+      y * this._deviceCellHeight,
+      this._bufferService.cols * this._deviceCellWidth,
+      this._deviceCellHeight);
     this._ctx.clip();
   }
 
@@ -517,137 +438,62 @@ export abstract class BaseRenderLayer implements IRenderLayer {
 
     return `${fontStyle} ${fontWeight} ${this._optionsService.rawOptions.fontSize * this._coreBrowserService.dpr}px ${this._optionsService.rawOptions.fontFamily}`;
   }
-
-  private _getContrastColor(cell: CellData, x: number, y: number): IColor | undefined {
-    // Get any decoration foreground/background overrides, this must be fetched before the early
-    // exist but applied after inverse
-    let bgOverride: number | undefined;
-    let fgOverride: number | undefined;
-    let isTop = false;
-    this._decorationService.forEachDecorationAtCell(x, y, undefined, d => {
-      if (d.options.layer !== 'top' && isTop) {
-        return;
-      }
-      if (d.backgroundColorRGB) {
-        bgOverride = d.backgroundColorRGB.rgba;
-      }
-      if (d.foregroundColorRGB) {
-        fgOverride = d.foregroundColorRGB.rgba;
-      }
-      isTop = d.options.layer === 'top';
-    });
-
-    // Apply selection foreground if applicable
-    if (!isTop) {
-      if (this._colors.selectionForeground && this._isCellInSelection(x, y)) {
-        fgOverride = this._colors.selectionForeground.rgba;
-      }
-    }
-
-    if (!bgOverride && !fgOverride && (this._optionsService.rawOptions.minimumContrastRatio === 1 || excludeFromContrastRatioDemands(cell.getCode()))) {
-      return undefined;
-    }
-
-    if (!bgOverride && !fgOverride) {
-      // Try get from cache
-      const adjustedColor = this._colors.contrastCache.getColor(cell.bg, cell.fg);
-      if (adjustedColor !== undefined) {
-        return adjustedColor || undefined;
-      }
-    }
-
-    let fgColor = cell.getFgColor();
-    let fgColorMode = cell.getFgColorMode();
-    let bgColor = cell.getBgColor();
-    let bgColorMode = cell.getBgColorMode();
-    const isInverse = !!cell.isInverse();
-    const isBold = !!cell.isInverse();
-    if (isInverse) {
-      const temp = fgColor;
-      fgColor = bgColor;
-      bgColor = temp;
-      const temp2 = fgColorMode;
-      fgColorMode = bgColorMode;
-      bgColorMode = temp2;
-    }
-
-    const bgRgba = this._resolveBackgroundRgba(bgOverride !== undefined ? Attributes.CM_RGB : bgColorMode, bgOverride ?? bgColor, isInverse);
-    const fgRgba = this._resolveForegroundRgba(fgColorMode, fgColor, isInverse, isBold);
-    let result = rgba.ensureContrastRatio(bgOverride ?? bgRgba, fgOverride ?? fgRgba, this._optionsService.rawOptions.minimumContrastRatio);
-
-    if (!result) {
-      if (!fgOverride) {
-        this._colors.contrastCache.setColor(cell.bg, cell.fg, null);
-        return undefined;
-      }
-      // If it was an override and there was no contrast change, set as the result
-      result = fgOverride;
-    }
-
-    const color: IColor = {
-      css: channels.toCss(
-        (result >> 24) & 0xFF,
-        (result >> 16) & 0xFF,
-        (result >> 8) & 0xFF
-      ),
-      rgba: result
-    };
-    if (!bgOverride && !fgOverride) {
-      this._colors.contrastCache.setColor(cell.bg, cell.fg, color);
-    }
-
-    return color;
-  }
-
-  private _resolveBackgroundRgba(bgColorMode: number, bgColor: number, inverse: boolean): number {
-    switch (bgColorMode) {
-      case Attributes.CM_P16:
-      case Attributes.CM_P256:
-        return this._colors.ansi[bgColor].rgba;
-      case Attributes.CM_RGB:
-        return bgColor << 8;
-      case Attributes.CM_DEFAULT:
-      default:
-        if (inverse) {
-          return this._colors.foreground.rgba;
-        }
-        return this._colors.background.rgba;
-    }
-  }
-
-  private _resolveForegroundRgba(fgColorMode: number, fgColor: number, inverse: boolean, bold: boolean): number {
-    switch (fgColorMode) {
-      case Attributes.CM_P16:
-      case Attributes.CM_P256:
-        if (this._optionsService.rawOptions.drawBoldTextInBrightColors && bold && fgColor < 8) {
-          fgColor += 8;
-        }
-        return this._colors.ansi[fgColor].rgba;
-      case Attributes.CM_RGB:
-        return fgColor << 8;
-      case Attributes.CM_DEFAULT:
-      default:
-        if (inverse) {
-          return this._colors.background.rgba;
-        }
-        return this._colors.foreground.rgba;
-    }
-  }
-
-  private _isCellInSelection(x: number, y: number): boolean {
-    const start = this._selectionStart;
-    const end = this._selectionEnd;
-    if (!start || !end) {
-      return false;
-    }
-    if (this._columnSelectMode) {
-      return x >= start[0] && y >= start[1] &&
-        x < end[0] && y < end[1];
-    }
-    return (y > start[1] && y < end[1]) ||
-        (start[1] === end[1] && y === start[1] && x >= start[0] && x < end[0]) ||
-        (start[1] < end[1] && y === end[1] && x < end[0]) ||
-        (start[1] < end[1] && y === start[1] && x >= start[0]);
-  }
 }
 
+/**
+ * The number of milliseconds to wait before generating the ImageBitmap, this is to debounce/batch
+ * the operation as window.createImageBitmap is asynchronous.
+ */
+const GLYPH_BITMAP_COMMIT_DELAY = 100;
+
+const enum BitmapGeneratorState {
+  IDLE = 0,
+  GENERATING = 1,
+  GENERATING_INVALID = 2
+}
+
+class BitmapGenerator {
+  private _state: BitmapGeneratorState = BitmapGeneratorState.IDLE;
+  private _commitTimeout: number | undefined = undefined;
+  private _bitmap: ImageBitmap | undefined = undefined;
+  public get bitmap(): ImageBitmap | undefined { return this._bitmap; }
+  public version: number = -1;
+
+  constructor(public readonly canvas: HTMLCanvasElement) {
+  }
+
+  public refresh(): void {
+    // Clear the bitmap immediately as it's stale
+    this._bitmap?.close();
+    this._bitmap = undefined;
+    // Disable ImageBitmaps on Safari because of https://bugs.webkit.org/show_bug.cgi?id=149990
+    if (isSafari) {
+      return;
+    }
+    if (this._commitTimeout === undefined) {
+      this._commitTimeout = window.setTimeout(() => this._generate(), GLYPH_BITMAP_COMMIT_DELAY);
+    }
+    if (this._state === BitmapGeneratorState.GENERATING) {
+      this._state = BitmapGeneratorState.GENERATING_INVALID;
+    }
+  }
+
+  private _generate(): void {
+    if (this._state === BitmapGeneratorState.IDLE) {
+      this._bitmap?.close();
+      this._bitmap = undefined;
+      this._state = BitmapGeneratorState.GENERATING;
+      window.createImageBitmap(this.canvas).then(bitmap => {
+        if (this._state === BitmapGeneratorState.GENERATING_INVALID) {
+          this.refresh();
+        } else {
+          this._bitmap = bitmap;
+        }
+        this._state = BitmapGeneratorState.IDLE;
+      });
+      if (this._commitTimeout) {
+        this._commitTimeout = undefined;
+      }
+    }
+  }
+}

addons/xterm-addon-canvas/src/CanvasAddon.ts

@@ -3,45 +3,66 @@
  * @license MIT
  */
 
-import { ICharacterJoinerService, ICharSizeService, ICoreBrowserService, IRenderService } from 'browser/services/Services';
-import { IColorSet } from 'browser/Types';
-import { CanvasRenderer } from './CanvasRenderer';
-import { IBufferService, ICoreService, IDecorationService, IOptionsService } from 'common/services/Services';
+import { ICharacterJoinerService, ICharSizeService, ICoreBrowserService, IRenderService, IThemeService } from 'browser/services/Services';
+import { ITerminal } from 'browser/Types';
+import { EventEmitter, forwardEvent } from 'common/EventEmitter';
+import { Disposable, toDisposable } from 'common/Lifecycle';
+import { setTraceLogger } from 'common/services/LogService';
+import { IBufferService, IDecorationService, ILogService } from 'common/services/Services';
 import { ITerminalAddon, Terminal } from 'xterm';
+import { CanvasRenderer } from './CanvasRenderer';
 
-export class CanvasAddon implements ITerminalAddon {
+export class CanvasAddon extends Disposable implements ITerminalAddon {
   private _terminal?: Terminal;
   private _renderer?: CanvasRenderer;
 
-  public activate(terminal: Terminal): void {
-    if (!terminal.element) {
-      throw new Error('Cannot activate CanvasAddon before Terminal.open');
-    }
-    this._terminal = terminal;
-    const bufferService: IBufferService = (terminal as any)._core._bufferService;
-    const renderService: IRenderService = (terminal as any)._core._renderService;
-    const characterJoinerService: ICharacterJoinerService = (terminal as any)._core._characterJoinerService;
-    const charSizeService: ICharSizeService = (terminal as any)._core._charSizeService;
-    const coreService: ICoreService = (terminal as any)._core.coreService;
-    const coreBrowserService: ICoreBrowserService = (terminal as any)._core._coreBrowserService;
-    const decorationService: IDecorationService = (terminal as any)._core._decorationService;
-    const optionsService: IOptionsService = (terminal as any)._core.optionsService;
-    const colors: IColorSet = (terminal as any)._core._colorManager.colors;
-    const screenElement: HTMLElement = (terminal as any)._core.screenElement;
-    const linkifier = (terminal as any)._core.linkifier2;
-    this._renderer = new CanvasRenderer(colors, screenElement, linkifier, bufferService, charSizeService, optionsService, characterJoinerService, coreService, coreBrowserService, decorationService);
-    renderService.setRenderer(this._renderer);
-    renderService.onResize(bufferService.cols, bufferService.rows);
+  private readonly _onChangeTextureAtlas = this.register(new EventEmitter<HTMLCanvasElement>());
+  public readonly onChangeTextureAtlas = this._onChangeTextureAtlas.event;
+  private readonly _onAddTextureAtlasCanvas = this.register(new EventEmitter<HTMLCanvasElement>());
+  public readonly onAddTextureAtlasCanvas = this._onAddTextureAtlasCanvas.event;
+
+  public get textureAtlas(): HTMLCanvasElement | undefined {
+    return this._renderer?.textureAtlas;
   }
 
-  public dispose(): void {
-    if (!this._terminal) {
-      throw new Error('Cannot dispose CanvasAddon because it is activated');
+  public activate(terminal: Terminal): void {
+    const core = (terminal as any)._core as ITerminal;
+    if (!terminal.element) {
+      this.register(core.onWillOpen(() => this.activate(terminal)));
+      return;
     }
-    const renderService: IRenderService = (this._terminal as any)._core._renderService;
-    renderService.setRenderer((this._terminal as any)._core._createRenderer());
-    renderService.onResize(this._terminal.cols, this._terminal.rows);
-    this._renderer?.dispose();
-    this._renderer = undefined;
+
+    this._terminal = terminal;
+    const coreService = core.coreService;
+    const optionsService = core.optionsService;
+    const screenElement = core.screenElement!;
+    const linkifier = core.linkifier2;
+
+    const unsafeCore = core as any;
+    const bufferService: IBufferService = unsafeCore._bufferService;
+    const renderService: IRenderService = unsafeCore._renderService;
+    const characterJoinerService: ICharacterJoinerService = unsafeCore._characterJoinerService;
+    const charSizeService: ICharSizeService = unsafeCore._charSizeService;
+    const coreBrowserService: ICoreBrowserService = unsafeCore._coreBrowserService;
+    const decorationService: IDecorationService = unsafeCore._decorationService;
+    const logService: ILogService = unsafeCore._logService;
+    const themeService: IThemeService = unsafeCore._themeService;
+
+    // Set trace logger just in case it hasn't been yet which could happen when the addon is
+    // bundled separately to the core module
+    setTraceLogger(logService);
+
+    this._renderer = new CanvasRenderer(terminal, screenElement, linkifier, bufferService, charSizeService, optionsService, characterJoinerService, coreService, coreBrowserService, decorationService, themeService);
+    this.register(forwardEvent(this._renderer.onChangeTextureAtlas, this._onChangeTextureAtlas));
+    this.register(forwardEvent(this._renderer.onAddTextureAtlasCanvas, this._onAddTextureAtlasCanvas));
+    renderService.setRenderer(this._renderer);
+    renderService.handleResize(bufferService.cols, bufferService.rows);
+
+    this.register(toDisposable(() => {
+      renderService.setRenderer((this._terminal as any)._core._createRenderer());
+      renderService.handleResize(terminal.cols, terminal.rows);
+      this._renderer?.dispose();
+      this._renderer = undefined;
+    }));
   }
 }

addons/xterm-addon-canvas/src/CanvasRenderer.ts

@@ -3,35 +3,37 @@
  * @license MIT
  */
 
-import { TextRenderLayer } from './TextRenderLayer';
-import { SelectionRenderLayer } from './SelectionRenderLayer';
+import { ILinkifier2 } from 'browser/Types';
+import { removeTerminalFromCache } from 'browser/renderer/shared/CharAtlasCache';
+import { observeDevicePixelDimensions } from 'browser/renderer/shared/DevicePixelObserver';
+import { createRenderDimensions } from 'browser/renderer/shared/RendererUtils';
+import { IRenderDimensions, IRenderer, IRequestRedrawEvent } from 'browser/renderer/shared/Types';
+import { ICharSizeService, ICharacterJoinerService, ICoreBrowserService, IThemeService } from 'browser/services/Services';
+import { EventEmitter, forwardEvent } from 'common/EventEmitter';
+import { Disposable, toDisposable } from 'common/Lifecycle';
+import { IBufferService, ICoreService, IDecorationService, IOptionsService } from 'common/services/Services';
+import { Terminal } from 'xterm';
 import { CursorRenderLayer } from './CursorRenderLayer';
-import { IRenderer, IRenderDimensions, IRequestRedrawEvent } from 'browser/renderer/Types';
-import { IRenderLayer } from './Types';
 import { LinkRenderLayer } from './LinkRenderLayer';
-import { Disposable } from 'common/Lifecycle';
-import { IColorSet, ILinkifier2 } from 'browser/Types';
-import { ICharacterJoinerService, ICharSizeService, ICoreBrowserService } from 'browser/services/Services';
-import { IBufferService, IOptionsService, IDecorationService, ICoreService } from 'common/services/Services';
-import { removeTerminalFromCache } from './atlas/CharAtlasCache';
-import { EventEmitter, IEvent } from 'common/EventEmitter';
-import { observeDevicePixelDimensions } from 'browser/renderer/DevicePixelObserver';
-
-let nextRendererId = 1;
+import { SelectionRenderLayer } from './SelectionRenderLayer';
+import { TextRenderLayer } from './TextRenderLayer';
+import { IRenderLayer } from './Types';
 
 export class CanvasRenderer extends Disposable implements IRenderer {
-  private _id = nextRendererId++;
-
   private _renderLayers: IRenderLayer[];
   private _devicePixelRatio: number;
 
   public dimensions: IRenderDimensions;
 
-  private _onRequestRedraw = new EventEmitter<IRequestRedrawEvent>();
-  public get onRequestRedraw(): IEvent<IRequestRedrawEvent> { return this._onRequestRedraw.event; }
+  private readonly _onRequestRedraw = this.register(new EventEmitter<IRequestRedrawEvent>());
+  public readonly onRequestRedraw = this._onRequestRedraw.event;
+  private readonly _onChangeTextureAtlas = this.register(new EventEmitter<HTMLCanvasElement>());
+  public readonly onChangeTextureAtlas = this._onChangeTextureAtlas.event;
+  private readonly _onAddTextureAtlasCanvas = this.register(new EventEmitter<HTMLCanvasElement>());
+  public readonly onAddTextureAtlasCanvas = this._onAddTextureAtlasCanvas.event;
 
   constructor(
-    private _colors: IColorSet,
+    private readonly _terminal: Terminal,
     private readonly _screenElement: HTMLElement,
     linkifier2: ILinkifier2,
     private readonly _bufferService: IBufferService,
@@ -40,65 +42,47 @@ export class CanvasRenderer extends Disposable implements IRenderer {
     characterJoinerService: ICharacterJoinerService,
     coreService: ICoreService,
     private readonly _coreBrowserService: ICoreBrowserService,
-    decorationService: IDecorationService
+    decorationService: IDecorationService,
+    private readonly _themeService: IThemeService
   ) {
     super();
     const allowTransparency = this._optionsService.rawOptions.allowTransparency;
     this._renderLayers = [
-      new TextRenderLayer(this._screenElement, 0, this._colors, allowTransparency, this._id, this._bufferService, this._optionsService, characterJoinerService, decorationService, this._coreBrowserService),
-      new SelectionRenderLayer(this._screenElement, 1, this._colors, this._id, this._bufferService, this._coreBrowserService, decorationService, this._optionsService),
-      new LinkRenderLayer(this._screenElement, 2, this._colors, this._id, linkifier2, this._bufferService, this._optionsService, decorationService, this._coreBrowserService),
-      new CursorRenderLayer(this._screenElement, 3, this._colors, this._id, this._onRequestRedraw, this._bufferService, this._optionsService, coreService, this._coreBrowserService, decorationService)
+      new TextRenderLayer(this._terminal, this._screenElement, 0, allowTransparency, this._bufferService, this._optionsService, characterJoinerService, decorationService, this._coreBrowserService, _themeService),
+      new SelectionRenderLayer(this._terminal, this._screenElement, 1, this._bufferService, this._coreBrowserService, decorationService, this._optionsService, _themeService),
+      new LinkRenderLayer(this._terminal, this._screenElement, 2, linkifier2, this._bufferService, this._optionsService, decorationService, this._coreBrowserService, _themeService),
+      new CursorRenderLayer(this._terminal, this._screenElement, 3, this._onRequestRedraw, this._bufferService, this._optionsService, coreService, this._coreBrowserService, decorationService, _themeService)
     ];
-    this.dimensions = {
-      scaledCharWidth: 0,
-      scaledCharHeight: 0,
-      scaledCellWidth: 0,
-      scaledCellHeight: 0,
-      scaledCharLeft: 0,
-      scaledCharTop: 0,
-      scaledCanvasWidth: 0,
-      scaledCanvasHeight: 0,
-      canvasWidth: 0,
-      canvasHeight: 0,
-      actualCellWidth: 0,
-      actualCellHeight: 0
-    };
+    for (const layer of this._renderLayers) {
+      forwardEvent(layer.onAddTextureAtlasCanvas, this._onAddTextureAtlasCanvas);
+    }
+    this.dimensions = createRenderDimensions();
     this._devicePixelRatio = this._coreBrowserService.dpr;
     this._updateDimensions();
 
     this.register(observeDevicePixelDimensions(this._renderLayers[0].canvas, this._coreBrowserService.window, (w, h) => this._setCanvasDevicePixelDimensions(w, h)));
-
-    this.onOptionsChanged();
+    this.register(toDisposable(() => {
+      for (const l of this._renderLayers) {
+        l.dispose();
+      }
+      removeTerminalFromCache(this._terminal);
+    }));
   }
 
-  public dispose(): void {
-    for (const l of this._renderLayers) {
-      l.dispose();
-    }
-    super.dispose();
-    removeTerminalFromCache(this._id);
+  public get textureAtlas(): HTMLCanvasElement | undefined {
+    return this._renderLayers[0].cacheCanvas;
   }
 
-  public onDevicePixelRatioChange(): void {
+  public handleDevicePixelRatioChange(): void {
     // If the device pixel ratio changed, the char atlas needs to be regenerated
     // and the terminal needs to refreshed
     if (this._devicePixelRatio !== this._coreBrowserService.dpr) {
       this._devicePixelRatio = this._coreBrowserService.dpr;
-      this.onResize(this._bufferService.cols, this._bufferService.rows);
+      this.handleResize(this._bufferService.cols, this._bufferService.rows);
     }
   }
 
-  public setColors(colors: IColorSet): void {
-    this._colors = colors;
-    // Clear layers and force a full render
-    for (const l of this._renderLayers) {
-      l.setColors(this._colors);
-      l.reset();
-    }
-  }
-
-  public onResize(cols: number, rows: number): void {
+  public handleResize(cols: number, rows: number): void {
     // Update character and canvas dimensions
     this._updateDimensions();
 
@@ -108,36 +92,32 @@ export class CanvasRenderer extends Disposable implements IRenderer {
     }
 
     // Resize the screen
-    this._screenElement.style.width = `${this.dimensions.canvasWidth}px`;
-    this._screenElement.style.height = `${this.dimensions.canvasHeight}px`;
+    this._screenElement.style.width = `${this.dimensions.css.canvas.width}px`;
+    this._screenElement.style.height = `${this.dimensions.css.canvas.height}px`;
   }
 
-  public onCharSizeChanged(): void {
-    this.onResize(this._bufferService.cols, this._bufferService.rows);
+  public handleCharSizeChanged(): void {
+    this.handleResize(this._bufferService.cols, this._bufferService.rows);
   }
 
-  public onBlur(): void {
-    this._runOperation(l => l.onBlur());
+  public handleBlur(): void {
+    this._runOperation(l => l.handleBlur());
   }
 
-  public onFocus(): void {
-    this._runOperation(l => l.onFocus());
+  public handleFocus(): void {
+    this._runOperation(l => l.handleFocus());
   }
 
-  public onSelectionChanged(start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean = false): void {
-    this._runOperation(l => l.onSelectionChanged(start, end, columnSelectMode));
+  public handleSelectionChanged(start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean = false): void {
+    this._runOperation(l => l.handleSelectionChanged(start, end, columnSelectMode));
     // Selection foreground requires a full re-render
-    if (this._colors.selectionForeground) {
+    if (this._themeService.colors.selectionForeground) {
       this._onRequestRedraw.fire({ start: 0, end: this._bufferService.rows - 1 });
     }
   }
 
-  public onCursorMove(): void {
-    this._runOperation(l => l.onCursorMove());
-  }
-
-  public onOptionsChanged(): void {
-    this._runOperation(l => l.onOptionsChanged());
+  public handleCursorMove(): void {
+    this._runOperation(l => l.handleCursorMove());
   }
 
   public clear(): void {
@@ -156,7 +136,7 @@ export class CanvasRenderer extends Disposable implements IRenderer {
    */
   public renderRows(start: number, end: number): void {
     for (const l of this._renderLayers) {
-      l.onGridChanged(start, end);
+      l.handleGridChanged(start, end);
     }
   }
 
@@ -176,23 +156,23 @@ export class CanvasRenderer extends Disposable implements IRenderer {
 
     // See the WebGL renderer for an explanation of this section.
     const dpr = this._coreBrowserService.dpr;
-    this.dimensions.scaledCharWidth = Math.floor(this._charSizeService.width * dpr);
-    this.dimensions.scaledCharHeight = Math.ceil(this._charSizeService.height * dpr);
-    this.dimensions.scaledCellHeight = Math.floor(this.dimensions.scaledCharHeight * this._optionsService.rawOptions.lineHeight);
-    this.dimensions.scaledCharTop = this._optionsService.rawOptions.lineHeight === 1 ? 0 : Math.round((this.dimensions.scaledCellHeight - this.dimensions.scaledCharHeight) / 2);
-    this.dimensions.scaledCellWidth = this.dimensions.scaledCharWidth + Math.round(this._optionsService.rawOptions.letterSpacing);
-    this.dimensions.scaledCharLeft = Math.floor(this._optionsService.rawOptions.letterSpacing / 2);
-    this.dimensions.scaledCanvasHeight = this._bufferService.rows * this.dimensions.scaledCellHeight;
-    this.dimensions.scaledCanvasWidth = this._bufferService.cols * this.dimensions.scaledCellWidth;
-    this.dimensions.canvasHeight = Math.round(this.dimensions.scaledCanvasHeight / dpr);
-    this.dimensions.canvasWidth = Math.round(this.dimensions.scaledCanvasWidth / dpr);
-    this.dimensions.actualCellHeight = this.dimensions.canvasHeight / this._bufferService.rows;
-    this.dimensions.actualCellWidth = this.dimensions.canvasWidth / this._bufferService.cols;
+    this.dimensions.device.char.width = Math.floor(this._charSizeService.width * dpr);
+    this.dimensions.device.char.height = Math.ceil(this._charSizeService.height * dpr);
+    this.dimensions.device.cell.height = Math.floor(this.dimensions.device.char.height * this._optionsService.rawOptions.lineHeight);
+    this.dimensions.device.char.top = this._optionsService.rawOptions.lineHeight === 1 ? 0 : Math.round((this.dimensions.device.cell.height - this.dimensions.device.char.height) / 2);
+    this.dimensions.device.cell.width = this.dimensions.device.char.width + Math.round(this._optionsService.rawOptions.letterSpacing);
+    this.dimensions.device.char.left = Math.floor(this._optionsService.rawOptions.letterSpacing / 2);
+    this.dimensions.device.canvas.height = this._bufferService.rows * this.dimensions.device.cell.height;
+    this.dimensions.device.canvas.width = this._bufferService.cols * this.dimensions.device.cell.width;
+    this.dimensions.css.canvas.height = Math.round(this.dimensions.device.canvas.height / dpr);
+    this.dimensions.css.canvas.width = Math.round(this.dimensions.device.canvas.width / dpr);
+    this.dimensions.css.cell.height = this.dimensions.css.canvas.height / this._bufferService.rows;
+    this.dimensions.css.cell.width = this.dimensions.css.canvas.width / this._bufferService.cols;
   }
 
   private _setCanvasDevicePixelDimensions(width: number, height: number): void {
-    this.dimensions.scaledCanvasHeight = height;
-    this.dimensions.scaledCanvasWidth = width;
+    this.dimensions.device.canvas.height = height;
+    this.dimensions.device.canvas.width = width;
     // Resize all render layers
     for (const l of this._renderLayers) {
       l.resize(this.dimensions);

addons/xterm-addon-canvas/src/CursorRenderLayer.ts

@@ -3,14 +3,17 @@
  * @license MIT
  */
 
-import { IRenderDimensions, IRequestRedrawEvent } from 'browser/renderer/Types';
-import { BaseRenderLayer } from './BaseRenderLayer';
+import { CursorBlinkStateManager } from 'browser/renderer/shared/CursorBlinkStateManager';
+import { IRenderDimensions, IRequestRedrawEvent } from 'browser/renderer/shared/Types';
+import { ICoreBrowserService, IThemeService } from 'browser/services/Services';
+import { IEventEmitter } from 'common/EventEmitter';
+import { MutableDisposable } from 'common/Lifecycle';
+import { isFirefox } from 'common/Platform';
 import { ICellData } from 'common/Types';
 import { CellData } from 'common/buffer/CellData';
-import { IColorSet } from 'browser/Types';
-import { IBufferService, IOptionsService, ICoreService, IDecorationService } from 'common/services/Services';
-import { IEventEmitter } from 'common/EventEmitter';
-import { ICoreBrowserService } from 'browser/services/Services';
+import { IBufferService, ICoreService, IDecorationService, IOptionsService } from 'common/services/Services';
+import { Terminal } from 'xterm';
+import { BaseRenderLayer } from './BaseRenderLayer';
 
 interface ICursorState {
   x: number;
@@ -20,30 +23,25 @@ interface ICursorState {
   width: number;
 }
 
-/**
- * The time between cursor blinks.
- */
-const BLINK_INTERVAL = 600;
-
 export class CursorRenderLayer extends BaseRenderLayer {
   private _state: ICursorState;
   private _cursorRenderers: {[key: string]: (x: number, y: number, cell: ICellData) => void};
-  private _cursorBlinkStateManager: CursorBlinkStateManager | undefined;
+  private _cursorBlinkStateManager: MutableDisposable<CursorBlinkStateManager> = this.register(new MutableDisposable());
   private _cell: ICellData = new CellData();
 
   constructor(
+    terminal: Terminal,
     container: HTMLElement,
     zIndex: number,
-    colors: IColorSet,
-    rendererId: number,
     private readonly _onRequestRedraw: IEventEmitter<IRequestRedrawEvent>,
     bufferService: IBufferService,
     optionsService: IOptionsService,
     private readonly _coreService: ICoreService,
     coreBrowserService: ICoreBrowserService,
-    decorationService: IDecorationService
+    decorationService: IDecorationService,
+    themeService: IThemeService
   ) {
-    super(container, 'cursor', zIndex, true, colors, rendererId, bufferService, optionsService, decorationService, coreBrowserService);
+    super(terminal, container, 'cursor', zIndex, true, themeService, bufferService, optionsService, decorationService, coreBrowserService);
     this._state = {
       x: 0,
       y: 0,
@@ -54,16 +52,11 @@ export class CursorRenderLayer extends BaseRenderLayer {
     this._cursorRenderers = {
       'bar': this._renderBarCursor.bind(this),
       'block': this._renderBlockCursor.bind(this),
-      'underline': this._renderUnderlineCursor.bind(this)
+      'underline': this._renderUnderlineCursor.bind(this),
+      'outline': this._renderOutlineCursor.bind(this)
     };
-  }
-
-  public dispose(): void {
-    if (this._cursorBlinkStateManager) {
-      this._cursorBlinkStateManager.dispose();
-      this._cursorBlinkStateManager = undefined;
-    }
-    super.dispose();
+    this.register(optionsService.onOptionChange(() => this._handleOptionsChanged()));
+    this._handleOptionsChanged();
   }
 
   public resize(dim: IRenderDimensions): void {
@@ -80,45 +73,42 @@ export class CursorRenderLayer extends BaseRenderLayer {
 
   public reset(): void {
     this._clearCursor();
-    this._cursorBlinkStateManager?.restartBlinkAnimation();
-    this.onOptionsChanged();
+    this._cursorBlinkStateManager.value?.restartBlinkAnimation();
+    this._handleOptionsChanged();
   }
 
-  public onBlur(): void {
-    this._cursorBlinkStateManager?.pause();
+  public handleBlur(): void {
+    this._cursorBlinkStateManager.value?.pause();
     this._onRequestRedraw.fire({ start: this._bufferService.buffer.y, end: this._bufferService.buffer.y });
   }
 
-  public onFocus(): void {
-    this._cursorBlinkStateManager?.resume();
+  public handleFocus(): void {
+    this._cursorBlinkStateManager.value?.resume();
     this._onRequestRedraw.fire({ start: this._bufferService.buffer.y, end: this._bufferService.buffer.y });
   }
 
-  public onOptionsChanged(): void {
+  private _handleOptionsChanged(): void {
     if (this._optionsService.rawOptions.cursorBlink) {
-      if (!this._cursorBlinkStateManager) {
-        this._cursorBlinkStateManager = new CursorBlinkStateManager(this._coreBrowserService.isFocused, () => {
-          this._render(true);
-        }, this._coreBrowserService);
+      if (!this._cursorBlinkStateManager.value) {
+        this._cursorBlinkStateManager.value = new CursorBlinkStateManager(() => this._render(true), this._coreBrowserService);
       }
     } else {
-      this._cursorBlinkStateManager?.dispose();
-      this._cursorBlinkStateManager = undefined;
+      this._cursorBlinkStateManager.clear();
     }
     // Request a refresh from the terminal as management of rendering is being
     // moved back to the terminal
     this._onRequestRedraw.fire({ start: this._bufferService.buffer.y, end: this._bufferService.buffer.y });
   }
 
-  public onCursorMove(): void {
-    this._cursorBlinkStateManager?.restartBlinkAnimation();
+  public handleCursorMove(): void {
+    this._cursorBlinkStateManager.value?.restartBlinkAnimation();
   }
 
-  public onGridChanged(startRow: number, endRow: number): void {
-    if (!this._cursorBlinkStateManager || this._cursorBlinkStateManager.isPaused) {
+  public handleGridChanged(startRow: number, endRow: number): void {
+    if (!this._cursorBlinkStateManager.value || this._cursorBlinkStateManager.value.isPaused) {
       this._render(false);
     } else {
-      this._cursorBlinkStateManager.restartBlinkAnimation();
+      this._cursorBlinkStateManager.value.restartBlinkAnimation();
     }
   }
 
@@ -148,12 +138,11 @@ export class CursorRenderLayer extends BaseRenderLayer {
     if (!this._coreBrowserService.isFocused) {
       this._clearCursor();
       this._ctx.save();
-      this._ctx.fillStyle = this._colors.cursor.css;
+      this._ctx.fillStyle = this._themeService.colors.cursor.css;
       const cursorStyle = this._optionsService.rawOptions.cursorStyle;
-      if (cursorStyle && cursorStyle !== 'block') {
-        this._cursorRenderers[cursorStyle](cursorX, viewportRelativeCursorY, this._cell);
-      } else {
-        this._renderBlurCursor(cursorX, viewportRelativeCursorY, this._cell);
+      const cursorInactiveStyle = this._optionsService.rawOptions.cursorInactiveStyle;
+      if (cursorInactiveStyle && cursorInactiveStyle !== 'none') {
+        this._cursorRenderers[cursorInactiveStyle](cursorX, viewportRelativeCursorY, this._cell);
       }
       this._ctx.restore();
       this._state.x = cursorX;
@@ -165,7 +154,7 @@ export class CursorRenderLayer extends BaseRenderLayer {
     }
 
     // Don't draw the cursor if it's blinking
-    if (this._cursorBlinkStateManager && !this._cursorBlinkStateManager.isCursorVisible) {
+    if (this._cursorBlinkStateManager.value && !this._cursorBlinkStateManager.value.isCursorVisible) {
       this._clearCursor();
       return;
     }
@@ -195,8 +184,9 @@ export class CursorRenderLayer extends BaseRenderLayer {
 
   private _clearCursor(): void {
     if (this._state) {
-      // Avoid potential rounding errors when device pixel ratio is less than 1
-      if (this._coreBrowserService.dpr < 1) {
+      // Avoid potential rounding errors when browser is Firefox (#4487) or device pixel ratio is
+      // less than 1
+      if (isFirefox || this._coreBrowserService.dpr < 1) {
         this._clearAll();
       } else {
         this._clearCells(this._state.x, this._state.y, this._state.width, 1);
@@ -213,167 +203,31 @@ export class CursorRenderLayer extends BaseRenderLayer {
 
   private _renderBarCursor(x: number, y: number, cell: ICellData): void {
     this._ctx.save();
-    this._ctx.fillStyle = this._colors.cursor.css;
+    this._ctx.fillStyle = this._themeService.colors.cursor.css;
     this._fillLeftLineAtCell(x, y, this._optionsService.rawOptions.cursorWidth);
     this._ctx.restore();
   }
 
   private _renderBlockCursor(x: number, y: number, cell: ICellData): void {
     this._ctx.save();
-    this._ctx.fillStyle = this._colors.cursor.css;
+    this._ctx.fillStyle = this._themeService.colors.cursor.css;
     this._fillCells(x, y, cell.getWidth(), 1);
-    this._ctx.fillStyle = this._colors.cursorAccent.css;
+    this._ctx.fillStyle = this._themeService.colors.cursorAccent.css;
     this._fillCharTrueColor(cell, x, y);
     this._ctx.restore();
   }
 
   private _renderUnderlineCursor(x: number, y: number, cell: ICellData): void {
     this._ctx.save();
-    this._ctx.fillStyle = this._colors.cursor.css;
+    this._ctx.fillStyle = this._themeService.colors.cursor.css;
     this._fillBottomLineAtCells(x, y);
     this._ctx.restore();
   }
 
-  private _renderBlurCursor(x: number, y: number, cell: ICellData): void {
+  private _renderOutlineCursor(x: number, y: number, cell: ICellData): void {
     this._ctx.save();
-    this._ctx.strokeStyle = this._colors.cursor.css;
+    this._ctx.strokeStyle = this._themeService.colors.cursor.css;
     this._strokeRectAtCell(x, y, cell.getWidth(), 1);
     this._ctx.restore();
   }
 }
-
-class CursorBlinkStateManager {
-  public isCursorVisible: boolean;
-
-  private _animationFrame: number | undefined;
-  private _blinkStartTimeout: number | undefined;
-  private _blinkInterval: number | undefined;
-
-  /**
-   * The time at which the animation frame was restarted, this is used on the
-   * next render to restart the timers so they don't need to restart the timers
-   * multiple times over a short period.
-   */
-  private _animationTimeRestarted: number | undefined;
-
-  constructor(
-    isFocused: boolean,
-    private _renderCallback: () => void,
-    private _coreBrowserService: ICoreBrowserService
-  ) {
-    this.isCursorVisible = true;
-    if (isFocused) {
-      this._restartInterval();
-    }
-  }
-
-  public get isPaused(): boolean { return !(this._blinkStartTimeout || this._blinkInterval); }
-
-  public dispose(): void {
-    if (this._blinkInterval) {
-      this._coreBrowserService.window.clearInterval(this._blinkInterval);
-      this._blinkInterval = undefined;
-    }
-    if (this._blinkStartTimeout) {
-      this._coreBrowserService.window.clearTimeout(this._blinkStartTimeout);
-      this._blinkStartTimeout = undefined;
-    }
-    if (this._animationFrame) {
-      this._coreBrowserService.window.cancelAnimationFrame(this._animationFrame);
-      this._animationFrame = undefined;
-    }
-  }
-
-  public restartBlinkAnimation(): void {
-    if (this.isPaused) {
-      return;
-    }
-    // Save a timestamp so that the restart can be done on the next interval
-    this._animationTimeRestarted = Date.now();
-    // Force a cursor render to ensure it's visible and in the correct position
-    this.isCursorVisible = true;
-    if (!this._animationFrame) {
-      this._animationFrame = this._coreBrowserService.window.requestAnimationFrame(() => {
-        this._renderCallback();
-        this._animationFrame = undefined;
-      });
-    }
-  }
-
-  private _restartInterval(timeToStart: number = BLINK_INTERVAL): void {
-    // Clear any existing interval
-    if (this._blinkInterval) {
-      this._coreBrowserService.window.clearInterval(this._blinkInterval);
-      this._blinkInterval = undefined;
-    }
-
-    // Setup the initial timeout which will hide the cursor, this is done before
-    // the regular interval is setup in order to support restarting the blink
-    // animation in a lightweight way (without thrashing clearInterval and
-    // setInterval).
-    this._blinkStartTimeout = this._coreBrowserService.window.setTimeout(() => {
-      // Check if another animation restart was requested while this was being
-      // started
-      if (this._animationTimeRestarted) {
-        const time = BLINK_INTERVAL - (Date.now() - this._animationTimeRestarted);
-        this._animationTimeRestarted = undefined;
-        if (time > 0) {
-          this._restartInterval(time);
-          return;
-        }
-      }
-
-      // Hide the cursor
-      this.isCursorVisible = false;
-      this._animationFrame = this._coreBrowserService.window.requestAnimationFrame(() => {
-        this._renderCallback();
-        this._animationFrame = undefined;
-      });
-
-      // Setup the blink interval
-      this._blinkInterval = this._coreBrowserService.window.setInterval(() => {
-        // Adjust the animation time if it was restarted
-        if (this._animationTimeRestarted) {
-          // calc time diff
-          // Make restart interval do a setTimeout initially?
-          const time = BLINK_INTERVAL - (Date.now() - this._animationTimeRestarted);
-          this._animationTimeRestarted = undefined;
-          this._restartInterval(time);
-          return;
-        }
-
-        // Invert visibility and render
-        this.isCursorVisible = !this.isCursorVisible;
-        this._animationFrame = this._coreBrowserService.window.requestAnimationFrame(() => {
-          this._renderCallback();
-          this._animationFrame = undefined;
-        });
-      }, BLINK_INTERVAL);
-    }, timeToStart);
-  }
-
-  public pause(): void {
-    this.isCursorVisible = true;
-    if (this._blinkInterval) {
-      this._coreBrowserService.window.clearInterval(this._blinkInterval);
-      this._blinkInterval = undefined;
-    }
-    if (this._blinkStartTimeout) {
-      this._coreBrowserService.window.clearTimeout(this._blinkStartTimeout);
-      this._blinkStartTimeout = undefined;
-    }
-    if (this._animationFrame) {
-      this._coreBrowserService.window.cancelAnimationFrame(this._animationFrame);
-      this._animationFrame = undefined;
-    }
-  }
-
-  public resume(): void {
-    // Clear out any existing timers just in case
-    this.pause();
-
-    this._animationTimeRestarted = undefined;
-    this._restartInterval();
-    this.restartBlinkAnimation();
-  }
-}

addons/xterm-addon-canvas/src/LinkRenderLayer.ts

@@ -3,32 +3,33 @@
  * @license MIT
  */
 
-import { IRenderDimensions } from 'browser/renderer/Types';
-import { BaseRenderLayer } from './BaseRenderLayer';
-import { INVERTED_DEFAULT_COLOR } from 'browser/renderer/Constants';
-import { ICoreBrowserService } from 'browser/services/Services';
-import { is256Color } from './atlas/CharAtlasUtils';
-import { IColorSet, ILinkifierEvent, ILinkifier2 } from 'browser/Types';
+import { ILinkifier2, ILinkifierEvent } from 'browser/Types';
+import { is256Color } from 'browser/renderer/shared/CharAtlasUtils';
+import { INVERTED_DEFAULT_COLOR } from 'browser/renderer/shared/Constants';
+import { IRenderDimensions } from 'browser/renderer/shared/Types';
+import { ICoreBrowserService, IThemeService } from 'browser/services/Services';
 import { IBufferService, IDecorationService, IOptionsService } from 'common/services/Services';
+import { Terminal } from 'xterm';
+import { BaseRenderLayer } from './BaseRenderLayer';
 
 export class LinkRenderLayer extends BaseRenderLayer {
   private _state: ILinkifierEvent | undefined;
 
   constructor(
+    terminal: Terminal,
     container: HTMLElement,
     zIndex: number,
-    colors: IColorSet,
-    rendererId: number,
     linkifier2: ILinkifier2,
     bufferService: IBufferService,
     optionsService: IOptionsService,
     decorationService: IDecorationService,
-    coreBrowserService: ICoreBrowserService
+    coreBrowserService: ICoreBrowserService,
+    themeService: IThemeService
   ) {
-    super(container, 'link', zIndex, true, colors, rendererId, bufferService, optionsService, decorationService, coreBrowserService);
+    super(terminal, container, 'link', zIndex, true, themeService, bufferService, optionsService, decorationService, coreBrowserService);
 
-    linkifier2.onShowLinkUnderline(e => this._onShowLinkUnderline(e));
-    linkifier2.onHideLinkUnderline(e => this._onHideLinkUnderline(e));
+    this.register(linkifier2.onShowLinkUnderline(e => this._handleShowLinkUnderline(e)));
+    this.register(linkifier2.onHideLinkUnderline(e => this._handleHideLinkUnderline(e)));
   }
 
   public resize(dim: IRenderDimensions): void {
@@ -53,14 +54,14 @@ export class LinkRenderLayer extends BaseRenderLayer {
     }
   }
 
-  private _onShowLinkUnderline(e: ILinkifierEvent): void {
+  private _handleShowLinkUnderline(e: ILinkifierEvent): void {
     if (e.fg === INVERTED_DEFAULT_COLOR) {
-      this._ctx.fillStyle = this._colors.background.css;
+      this._ctx.fillStyle = this._themeService.colors.background.css;
     } else if (e.fg && is256Color(e.fg)) {
       // 256 color support
-      this._ctx.fillStyle = this._colors.ansi[e.fg].css;
+      this._ctx.fillStyle = this._themeService.colors.ansi[e.fg].css;
     } else {
-      this._ctx.fillStyle = this._colors.foreground.css;
+      this._ctx.fillStyle = this._themeService.colors.foreground.css;
     }
 
     if (e.y1 === e.y2) {
@@ -77,7 +78,7 @@ export class LinkRenderLayer extends BaseRenderLayer {
     this._state = e;
   }
 
-  private _onHideLinkUnderline(e: ILinkifierEvent): void {
+  private _handleHideLinkUnderline(e: ILinkifierEvent): void {
     this._clearCurrentLink();
   }
 }

addons/xterm-addon-canvas/src/SelectionRenderLayer.ts

@@ -3,11 +3,11 @@
  * @license MIT
  */
 
-import { IRenderDimensions } from 'browser/renderer/Types';
+import { IRenderDimensions } from 'browser/renderer/shared/Types';
 import { BaseRenderLayer } from './BaseRenderLayer';
-import { IColorSet } from 'browser/Types';
 import { IBufferService, IDecorationService, IOptionsService } from 'common/services/Services';
-import { ICoreBrowserService } from 'browser/services/Services';
+import { ICoreBrowserService, IThemeService } from 'browser/services/Services';
+import { Terminal } from 'xterm';
 
 interface ISelectionState {
   start?: [number, number];
@@ -20,16 +20,16 @@ export class SelectionRenderLayer extends BaseRenderLayer {
   private _state!: ISelectionState;
 
   constructor(
+    terminal: Terminal,
     container: HTMLElement,
     zIndex: number,
-    colors: IColorSet,
-    rendererId: number,
     bufferService: IBufferService,
     coreBrowserService: ICoreBrowserService,
     decorationService: IDecorationService,
-    optionsService: IOptionsService
+    optionsService: IOptionsService,
+    themeService: IThemeService
   ) {
-    super(container, 'selection', zIndex, true, colors, rendererId, bufferService, optionsService, decorationService, coreBrowserService);
+    super(terminal, container, 'selection', zIndex, true, themeService, bufferService, optionsService, decorationService, coreBrowserService);
     this._clearState();
   }
 
@@ -46,8 +46,9 @@ export class SelectionRenderLayer extends BaseRenderLayer {
     super.resize(dim);
     // On resize use the base render layer's cached selection values since resize clears _state
     // inside reset.
-    if (this._selectionStart && this._selectionEnd) {
-      this._redrawSelection(this._selectionStart, this._selectionEnd, this._columnSelectMode);
+    if (this._selectionModel.selectionStart && this._selectionModel.selectionEnd) {
+      this._clearState();
+      this._redrawSelection(this._selectionModel.selectionStart, this._selectionModel.selectionEnd, this._selectionModel.columnSelectMode);
     }
   }
 
@@ -58,18 +59,18 @@ export class SelectionRenderLayer extends BaseRenderLayer {
     }
   }
 
-  public onBlur(): void {
+  public handleBlur(): void {
     this.reset();
-    this._redrawSelection(this._selectionStart, this._selectionEnd, this._columnSelectMode);
+    this._redrawSelection(this._selectionModel.selectionStart, this._selectionModel.selectionEnd, this._selectionModel.columnSelectMode);
   }
 
-  public onFocus(): void {
+  public handleFocus(): void {
     this.reset();
-    this._redrawSelection(this._selectionStart, this._selectionEnd, this._columnSelectMode);
+    this._redrawSelection(this._selectionModel.selectionStart, this._selectionModel.selectionEnd, this._selectionModel.columnSelectMode);
   }
 
-  public onSelectionChanged(start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean): void {
-    super.onSelectionChanged(start, end, columnSelectMode);
+  public handleSelectionChanged(start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean): void {
+    super.handleSelectionChanged(start, end, columnSelectMode);
     this._redrawSelection(start, end, columnSelectMode);
   }
 
@@ -101,8 +102,8 @@ export class SelectionRenderLayer extends BaseRenderLayer {
     }
 
     this._ctx.fillStyle = (this._coreBrowserService.isFocused
-      ? this._colors.selectionBackgroundTransparent
-      : this._colors.selectionInactiveBackgroundTransparent).css;
+      ? this._themeService.colors.selectionBackgroundTransparent
+      : this._themeService.colors.selectionInactiveBackgroundTransparent).css;
 
     if (columnSelectMode) {
       const startCol = start[0];

addons/xterm-addon-canvas/src/TextRenderLayer.ts

@@ -3,18 +3,17 @@
  * @license MIT
  */
 
-import { IRenderDimensions } from 'browser/renderer/Types';
-import { CharData, ICellData } from 'common/Types';
-import { GridCache } from './GridCache';
-import { BaseRenderLayer } from './BaseRenderLayer';
-import { AttributeData } from 'common/buffer/AttributeData';
-import { NULL_CELL_CODE, Content, UnderlineStyle } from 'common/buffer/Constants';
-import { IColorSet } from 'browser/Types';
-import { CellData } from 'common/buffer/CellData';
-import { IOptionsService, IBufferService, IDecorationService } from 'common/services/Services';
-import { ICharacterJoinerService, ICoreBrowserService } from 'browser/services/Services';
+import { IRenderDimensions } from 'browser/renderer/shared/Types';
 import { JoinedCellData } from 'browser/services/CharacterJoinerService';
-import { color, css } from 'common/Color';
+import { ICharacterJoinerService, ICoreBrowserService, IThemeService } from 'browser/services/Services';
+import { CharData, ICellData } from 'common/Types';
+import { AttributeData } from 'common/buffer/AttributeData';
+import { CellData } from 'common/buffer/CellData';
+import { Content, NULL_CELL_CODE } from 'common/buffer/Constants';
+import { IBufferService, IDecorationService, IOptionsService } from 'common/services/Services';
+import { Terminal } from 'xterm';
+import { BaseRenderLayer } from './BaseRenderLayer';
+import { GridCache } from './GridCache';
 
 /**
  * This CharData looks like a null character, which will forc a clear and render
@@ -31,19 +30,20 @@ export class TextRenderLayer extends BaseRenderLayer {
   private _workCell = new CellData();
 
   constructor(
+    terminal: Terminal,
     container: HTMLElement,
     zIndex: number,
-    colors: IColorSet,
     alpha: boolean,
-    rendererId: number,
     bufferService: IBufferService,
     optionsService: IOptionsService,
     private readonly _characterJoinerService: ICharacterJoinerService,
     decorationService: IDecorationService,
-    coreBrowserService: ICoreBrowserService
+    coreBrowserService: ICoreBrowserService,
+    themeService: IThemeService
   ) {
-    super(container, 'text', zIndex, alpha, colors, rendererId, bufferService, optionsService, decorationService, coreBrowserService);
+    super(terminal, container, 'text', zIndex, alpha, themeService, bufferService, optionsService, decorationService, coreBrowserService);
     this._state = new GridCache<CharData>();
+    this.register(optionsService.onSpecificOptionChange('allowTransparency', value => this._setTransparency(value)));
   }
 
   public resize(dim: IRenderDimensions): void {
@@ -51,8 +51,8 @@ export class TextRenderLayer extends BaseRenderLayer {
 
     // Clear the character width cache if the font or width has changed
     const terminalFont = this._getFont(false, false);
-    if (this._characterWidth !== dim.scaledCharWidth || this._characterFont !== terminalFont) {
-      this._characterWidth = dim.scaledCharWidth;
+    if (this._characterWidth !== dim.device.char.width || this._characterFont !== terminalFont) {
+      this._characterWidth = dim.device.char.width;
       this._characterFont = terminalFont;
       this._characterOverlapCache = {};
     }
@@ -93,6 +93,13 @@ export class TextRenderLayer extends BaseRenderLayer {
           continue;
         }
 
+        // exit early for NULL and SP
+        // NOTE: commented out due to #4120 (needs a more clever patch to keep things performant)
+        // const code = cell.getCode();
+        // if (code === 0 || code === 32) {
+        //  continue;
+        // }
+
         // Process any joined character ranges as needed. Because of how the
         // ranges are produced, we know that they are valid for the characters
         // and attributes of our input.
@@ -167,22 +174,16 @@ export class TextRenderLayer extends BaseRenderLayer {
 
       if (cell.isInverse()) {
         if (cell.isFgDefault()) {
-          nextFillStyle = this._colors.foreground.css;
+          nextFillStyle = this._themeService.colors.foreground.css;
         } else if (cell.isFgRGB()) {
           nextFillStyle = `rgb(${AttributeData.toColorRGB(cell.getFgColor()).join(',')})`;
         } else {
-          nextFillStyle = this._colors.ansi[cell.getFgColor()].css;
+          nextFillStyle = this._themeService.colors.ansi[cell.getFgColor()].css;
         }
       } else if (cell.isBgRGB()) {
         nextFillStyle = `rgb(${AttributeData.toColorRGB(cell.getBgColor()).join(',')})`;
       } else if (cell.isBgPalette()) {
-        nextFillStyle = this._colors.ansi[cell.getBgColor()].css;
-      }
-
-      // Apply dim to the background, this is relatively slow as the CSS is re-parsed but dim is
-      // rarely used
-      if (nextFillStyle && cell.isDim()) {
-        nextFillStyle = color.multiplyOpacity(css.toColor(nextFillStyle), 0.5).css;
+        nextFillStyle = this._themeService.colors.ansi[cell.getBgColor()].css;
       }
 
       // Get any decoration foreground/background overrides, this must be fetched before the early
@@ -232,81 +233,10 @@ export class TextRenderLayer extends BaseRenderLayer {
   }
 
   private _drawForeground(firstRow: number, lastRow: number): void {
-    this._forEachCell(firstRow, lastRow, (cell, x, y) => {
-      if (cell.isInvisible()) {
-        return;
-      }
-      this._drawChars(cell, x, y);
-      if (cell.isUnderline() || cell.isStrikethrough()) {
-        this._ctx.save();
-
-        if (cell.isInverse()) {
-          if (cell.isBgDefault()) {
-            this._ctx.fillStyle = this._colors.background.css;
-          } else if (cell.isBgRGB()) {
-            this._ctx.fillStyle = `rgb(${AttributeData.toColorRGB(cell.getBgColor()).join(',')})`;
-          } else {
-            let bg = cell.getBgColor();
-            if (this._optionsService.rawOptions.drawBoldTextInBrightColors && cell.isBold() && bg < 8) {
-              bg += 8;
-            }
-            this._ctx.fillStyle = this._colors.ansi[bg].css;
-          }
-        } else {
-          if (cell.isFgDefault()) {
-            this._ctx.fillStyle = this._colors.foreground.css;
-          } else if (cell.isFgRGB()) {
-            this._ctx.fillStyle = `rgb(${AttributeData.toColorRGB(cell.getFgColor()).join(',')})`;
-          } else {
-            let fg = cell.getFgColor();
-            if (this._optionsService.rawOptions.drawBoldTextInBrightColors && cell.isBold() && fg < 8) {
-              fg += 8;
-            }
-            this._ctx.fillStyle = this._colors.ansi[fg].css;
-          }
-        }
-
-        if (cell.isStrikethrough()) {
-          this._fillMiddleLineAtCells(x, y, cell.getWidth());
-        }
-        if (cell.isUnderline()) {
-          if (!cell.isUnderlineColorDefault()) {
-            if (cell.isUnderlineColorRGB()) {
-              this._ctx.fillStyle = `rgb(${AttributeData.toColorRGB(cell.getUnderlineColor()).join(',')})`;
-            } else {
-              let fg = cell.getUnderlineColor();
-              if (this._optionsService.rawOptions.drawBoldTextInBrightColors && cell.isBold() && fg < 8) {
-                fg += 8;
-              }
-              this._ctx.fillStyle = this._colors.ansi[fg].css;
-            }
-          }
-          switch (cell.extended.underlineStyle) {
-            case UnderlineStyle.DOUBLE:
-              this._fillBottomLineAtCells(x, y, cell.getWidth(), -this._coreBrowserService.dpr);
-              this._fillBottomLineAtCells(x, y, cell.getWidth(), this._coreBrowserService.dpr);
-              break;
-            case UnderlineStyle.CURLY:
-              this._curlyUnderlineAtCell(x, y, cell.getWidth());
-              break;
-            case UnderlineStyle.DOTTED:
-              this._dottedUnderlineAtCell(x, y, cell.getWidth());
-              break;
-            case UnderlineStyle.DASHED:
-              this._dashedUnderlineAtCell(x, y, cell.getWidth());
-              break;
-            case UnderlineStyle.SINGLE:
-            default:
-              this._fillBottomLineAtCells(x, y, cell.getWidth());
-              break;
-          }
-        }
-        this._ctx.restore();
-      }
-    });
+    this._forEachCell(firstRow, lastRow, (cell, x, y) => this._drawChars(cell, x, y));
   }
 
-  public onGridChanged(firstRow: number, lastRow: number): void {
+  public handleGridChanged(firstRow: number, lastRow: number): void {
     // Resize has not been called yet
     if (this._state.cache.length === 0) {
       return;
@@ -321,10 +251,6 @@ export class TextRenderLayer extends BaseRenderLayer {
     this._drawForeground(firstRow, lastRow);
   }
 
-  public onOptionsChanged(): void {
-    this._setTransparency(this._optionsService.rawOptions.allowTransparency);
-  }
-
   /**
    * Whether a character is overlapping to the next cell.
    */
@@ -363,19 +289,4 @@ export class TextRenderLayer extends BaseRenderLayer {
     this._characterOverlapCache[chars] = overlaps;
     return overlaps;
   }
-
-  /**
-   * Clear the charcater at the cell specified.
-   * @param x The column of the char.
-   * @param y The row of the char.
-   */
-  // private _clearChar(x: number, y: number): void {
-  //   let colsToClear = 1;
-  //   // Clear the adjacent character if it was wide
-  //   const state = this._state.cache[x][y];
-  //   if (state && state[CHAR_DATA_WIDTH_INDEX] === 2) {
-  //     colsToClear = 2;
-  //   }
-  //   this.clearCells(x, y, colsToClear, 1);
-  // }
 }

addons/xterm-addon-canvas/src/Types.d.ts

@@ -4,24 +4,8 @@
  */
 
 import { IDisposable } from 'common/Types';
-import { IColorSet } from 'browser/Types';
 import { IEvent } from 'common/EventEmitter';
-
-// TODO: Use core interfaces
-export interface IRenderDimensions {
-  scaledCharWidth: number;
-  scaledCharHeight: number;
-  scaledCellWidth: number;
-  scaledCellHeight: number;
-  scaledCharLeft: number;
-  scaledCharTop: number;
-  scaledCanvasWidth: number;
-  scaledCanvasHeight: number;
-  canvasWidth: number;
-  canvasHeight: number;
-  actualCellWidth: number;
-  actualCellHeight: number;
-}
+import { IRenderDimensions } from 'browser/renderer/shared/Types';
 
 export interface IRequestRedrawEvent {
   start: number;
@@ -41,16 +25,14 @@ export interface IRenderer extends IDisposable {
    */
   readonly onRequestRedraw: IEvent<IRequestRedrawEvent>;
 
-  dispose(): void;
-  setColors(colors: IColorSet): void;
-  onDevicePixelRatioChange(): void;
-  onResize(cols: number, rows: number): void;
-  onCharSizeChanged(): void;
-  onBlur(): void;
-  onFocus(): void;
-  onSelectionChanged(start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean): void;
-  onCursorMove(): void;
-  onOptionsChanged(): void;
+  handleDevicePixelRatioChange(): void;
+  handleResize(cols: number, rows: number): void;
+  handleCharSizeChanged(): void;
+  handleBlur(): void;
+  handleFocus(): void;
+  handleSelectionChanged(start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean): void;
+  handleCursorMove(): void;
+  handleOptionsChanged(): void;
   clear(): void;
   renderRows(start: number, end: number): void;
   clearTextureAtlas?(): void;
@@ -58,42 +40,34 @@ export interface IRenderer extends IDisposable {
 
 export interface IRenderLayer extends IDisposable {
   readonly canvas: HTMLCanvasElement;
+  readonly cacheCanvas: HTMLCanvasElement;
 
+  readonly onAddTextureAtlasCanvas: IEvent<HTMLCanvasElement>;
   /**
    * Called when the terminal loses focus.
    */
-  onBlur(): void;
+  handleBlur(): void;
 
   /**
-   * * Called when the terminal gets focus.
+   * Called when the terminal gets focus.
    */
-  onFocus(): void;
+  handleFocus(): void;
 
   /**
    * Called when the cursor is moved.
    */
-  onCursorMove(): void;
-
-  /**
-   * Called when options change.
-   */
-  onOptionsChanged(): void;
-
-  /**
-   * Called when the theme changes.
-   */
-  setColors(colorSet: IColorSet): void;
+  handleCursorMove(): void;
 
   /**
    * Called when the data in the grid has changed (or needs to be rendered
    * again).
    */
-  onGridChanged(startRow: number, endRow: number): void;
+  handleGridChanged(startRow: number, endRow: number): void;
 
   /**
    * Calls when the selection changes.
    */
-  onSelectionChanged(start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean): void;
+  handleSelectionChanged(start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean): void;
 
   /**
    * Resize the render layer.

addons/xterm-addon-canvas/src/atlas/BaseCharAtlas.ts

@@ -1,58 +0,0 @@
-/**
- * Copyright (c) 2017 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { IGlyphIdentifier } from './Types';
-import { IDisposable } from 'common/Types';
-
-export abstract class BaseCharAtlas implements IDisposable {
-  private _didWarmUp: boolean = false;
-
-  public dispose(): void { }
-
-  /**
-   * Perform any work needed to warm the cache before it can be used. May be called multiple times.
-   * Implement _doWarmUp instead if you only want to get called once.
-   */
-  public warmUp(): void {
-    if (!this._didWarmUp) {
-      this._doWarmUp();
-      this._didWarmUp = true;
-    }
-  }
-
-  /**
-   * Perform any work needed to warm the cache before it can be used. Used by the default
-   * implementation of warmUp(), and will only be called once.
-   */
-  private _doWarmUp(): void { }
-
-  public clear(): void { }
-
-  /**
-   * Called when we start drawing a new frame.
-   *
-   * TODO: We rely on this getting called by TextRenderLayer. This should really be called by
-   * Renderer instead, but we need to make Renderer the source-of-truth for the char atlas, instead
-   * of BaseRenderLayer.
-   */
-  public beginFrame(): void { }
-
-  /**
-   * May be called before warmUp finishes, however it is okay for the implementation to
-   * do nothing and return false in that case.
-   *
-   * @param ctx Where to draw the character onto.
-   * @param glyph Information about what to draw
-   * @param x The position on the context to start drawing at
-   * @param y The position on the context to start drawing at
-   * @returns The success state. True if we drew the character.
-   */
-  public abstract draw(
-    ctx: CanvasRenderingContext2D,
-    glyph: IGlyphIdentifier,
-    x: number,
-    y: number
-  ): boolean;
-}

addons/xterm-addon-canvas/src/atlas/CharAtlasCache.ts

@@ -1,96 +0,0 @@
-/**
- * Copyright (c) 2017 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { generateConfig, configEquals } from './CharAtlasUtils';
-import { BaseCharAtlas } from './BaseCharAtlas';
-import { DynamicCharAtlas } from './DynamicCharAtlas';
-import { ICharAtlasConfig } from './Types';
-import { IColorSet } from 'browser/Types';
-import { ITerminalOptions } from 'xterm';
-
-interface ICharAtlasCacheEntry {
-  atlas: BaseCharAtlas;
-  config: ICharAtlasConfig;
-  // N.B. This implementation potentially holds onto copies of the terminal forever, so
-  // this may cause memory leaks.
-  ownedBy: number[];
-}
-
-const charAtlasCache: ICharAtlasCacheEntry[] = [];
-
-/**
- * Acquires a char atlas, either generating a new one or returning an existing
- * one that is in use by another terminal.
- */
-export function acquireCharAtlas(
-  options: Required<ITerminalOptions>,
-  rendererId: number,
-  colors: IColorSet,
-  scaledCharWidth: number,
-  scaledCharHeight: number,
-  devicePixelRatio: number
-): BaseCharAtlas {
-  const newConfig = generateConfig(scaledCharWidth, scaledCharHeight, options, colors, devicePixelRatio);
-
-  // Check to see if the renderer already owns this config
-  for (let i = 0; i < charAtlasCache.length; i++) {
-    const entry = charAtlasCache[i];
-    const ownedByIndex = entry.ownedBy.indexOf(rendererId);
-    if (ownedByIndex >= 0) {
-      if (configEquals(entry.config, newConfig)) {
-        return entry.atlas;
-      }
-      // The configs differ, release the renderer from the entry
-      if (entry.ownedBy.length === 1) {
-        entry.atlas.dispose();
-        charAtlasCache.splice(i, 1);
-      } else {
-        entry.ownedBy.splice(ownedByIndex, 1);
-      }
-      break;
-    }
-  }
-
-  // Try match a char atlas from the cache
-  for (let i = 0; i < charAtlasCache.length; i++) {
-    const entry = charAtlasCache[i];
-    if (configEquals(entry.config, newConfig)) {
-      // Add the renderer to the cache entry and return
-      entry.ownedBy.push(rendererId);
-      return entry.atlas;
-    }
-  }
-
-  const newEntry: ICharAtlasCacheEntry = {
-    atlas: new DynamicCharAtlas(
-      document,
-      newConfig
-    ),
-    config: newConfig,
-    ownedBy: [rendererId]
-  };
-  charAtlasCache.push(newEntry);
-  return newEntry.atlas;
-}
-
-/**
- * Removes a terminal reference from the cache, allowing its memory to be freed.
- */
-export function removeTerminalFromCache(rendererId: number): void {
-  for (let i = 0; i < charAtlasCache.length; i++) {
-    const index = charAtlasCache[i].ownedBy.indexOf(rendererId);
-    if (index !== -1) {
-      if (charAtlasCache[i].ownedBy.length === 1) {
-        // Remove the cache entry if it's the only renderer
-        charAtlasCache[i].atlas.dispose();
-        charAtlasCache.splice(i, 1);
-      } else {
-        // Remove the reference from the cache entry
-        charAtlasCache[i].ownedBy.splice(index, 1);
-      }
-      break;
-    }
-  }
-}

addons/xterm-addon-canvas/src/atlas/CharAtlasUtils.ts

@@ -1,54 +0,0 @@
-/**
- * Copyright (c) 2017 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { ICharAtlasConfig } from './Types';
-import { DEFAULT_COLOR } from 'common/buffer/Constants';
-import { IColorSet, IPartialColorSet } from 'browser/Types';
-import { ITerminalOptions } from 'xterm';
-
-export function generateConfig(scaledCharWidth: number, scaledCharHeight: number, options: Required<ITerminalOptions>, colors: IColorSet, devicePixelRatio: number): ICharAtlasConfig {
-  // null out some fields that don't matter
-  const clonedColors: IPartialColorSet = {
-    foreground: colors.foreground,
-    background: colors.background,
-    cursor: undefined,
-    cursorAccent: undefined,
-    selectionBackground: undefined,
-    ansi: colors.ansi.slice()
-  };
-  return {
-    devicePixelRatio,
-    scaledCharWidth,
-    scaledCharHeight,
-    fontFamily: options.fontFamily,
-    fontSize: options.fontSize,
-    fontWeight: options.fontWeight,
-    fontWeightBold: options.fontWeightBold,
-    allowTransparency: options.allowTransparency,
-    colors: clonedColors
-  };
-}
-
-export function configEquals(a: ICharAtlasConfig, b: ICharAtlasConfig): boolean {
-  for (let i = 0; i < a.colors.ansi.length; i++) {
-    if (a.colors.ansi[i].rgba !== b.colors.ansi[i].rgba) {
-      return false;
-    }
-  }
-  return a.devicePixelRatio === b.devicePixelRatio &&
-      a.fontFamily === b.fontFamily &&
-      a.fontSize === b.fontSize &&
-      a.fontWeight === b.fontWeight &&
-      a.fontWeightBold === b.fontWeightBold &&
-      a.allowTransparency === b.allowTransparency &&
-      a.scaledCharWidth === b.scaledCharWidth &&
-      a.scaledCharHeight === b.scaledCharHeight &&
-      a.colors.foreground === b.colors.foreground &&
-      a.colors.background === b.colors.background;
-}
-
-export function is256Color(colorCode: number): boolean {
-  return colorCode < DEFAULT_COLOR;
-}

addons/xterm-addon-canvas/src/atlas/DynamicCharAtlas.ts

@@ -1,411 +0,0 @@
-/**
- * Copyright (c) 2017 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { DIM_OPACITY, INVERTED_DEFAULT_COLOR, TEXT_BASELINE } from 'browser/renderer/Constants';
-import { IGlyphIdentifier, ICharAtlasConfig } from './Types';
-import { BaseCharAtlas } from './BaseCharAtlas';
-import { DEFAULT_ANSI_COLORS } from 'browser/ColorManager';
-import { LRUMap } from './LRUMap';
-import { isFirefox, isSafari } from 'common/Platform';
-import { IColor } from 'common/Types';
-import { throwIfFalsy } from 'browser/renderer/RendererUtils';
-import { color } from 'common/Color';
-
-// In practice we're probably never going to exhaust a texture this large. For debugging purposes,
-// however, it can be useful to set this to a really tiny value, to verify that LRU eviction works.
-const TEXTURE_WIDTH = 1024;
-const TEXTURE_HEIGHT = 1024;
-
-const TRANSPARENT_COLOR = {
-  css: 'rgba(0, 0, 0, 0)',
-  rgba: 0
-};
-
-// Drawing to the cache is expensive: If we have to draw more than this number of glyphs to the
-// cache in a single frame, give up on trying to cache anything else, and try to finish the current
-// frame ASAP.
-//
-// This helps to limit the amount of damage a program can do when it would otherwise thrash the
-// cache.
-const FRAME_CACHE_DRAW_LIMIT = 100;
-
-/**
- * The number of milliseconds to wait before generating the ImageBitmap, this is to debounce/batch
- * the operation as window.createImageBitmap is asynchronous.
- */
-const GLYPH_BITMAP_COMMIT_DELAY = 100;
-
-interface IGlyphCacheValue {
-  index: number;
-  isEmpty: boolean;
-  inBitmap: boolean;
-}
-
-export function getGlyphCacheKey(glyph: IGlyphIdentifier): number {
-  // Note that this only returns a valid key when code < 256
-  // Layout:
-  // 0b00000000000000000000000000000001: italic (1)
-  // 0b00000000000000000000000000000010: dim (1)
-  // 0b00000000000000000000000000000100: bold (1)
-  // 0b00000000000000000000111111111000: fg (9)
-  // 0b00000000000111111111000000000000: bg (9)
-  // 0b00011111111000000000000000000000: code (8)
-  // 0b11100000000000000000000000000000: unused (3)
-  return glyph.code << 21 | glyph.bg << 12 | glyph.fg << 3 | (glyph.bold ? 0 : 4) + (glyph.dim ? 0 : 2) + (glyph.italic ? 0 : 1);
-}
-
-export class DynamicCharAtlas extends BaseCharAtlas {
-  // An ordered map that we're using to keep track of where each glyph is in the atlas texture.
-  // It's ordered so that we can determine when to remove the old entries.
-  private _cacheMap: LRUMap<IGlyphCacheValue>;
-
-  // The texture that the atlas is drawn to
-  private _cacheCanvas: HTMLCanvasElement;
-  private _cacheCtx: CanvasRenderingContext2D;
-
-  // A temporary context that glyphs are drawn to before being transfered to the atlas.
-  private _tmpCtx: CanvasRenderingContext2D;
-
-  // The number of characters stored in the atlas by width/height
-  private _width: number;
-  private _height: number;
-
-  private _drawToCacheCount: number = 0;
-
-  // An array of glyph keys that are waiting on the bitmap to be generated.
-  private _glyphsWaitingOnBitmap: IGlyphCacheValue[] = [];
-
-  // The timeout that is used to batch bitmap generation so it's not requested for every new glyph.
-  private _bitmapCommitTimeout: number | null = null;
-
-  // The bitmap to draw from, this is much faster on other browsers than others.
-  private _bitmap: ImageBitmap | null = null;
-
-  constructor(document: Document, private _config: ICharAtlasConfig) {
-    super();
-    this._cacheCanvas = document.createElement('canvas');
-    this._cacheCanvas.width = TEXTURE_WIDTH;
-    this._cacheCanvas.height = TEXTURE_HEIGHT;
-    // The canvas needs alpha because we use clearColor to convert the background color to alpha.
-    // It might also contain some characters with transparent backgrounds if allowTransparency is
-    // set.
-    this._cacheCtx = throwIfFalsy(this._cacheCanvas.getContext('2d', { alpha: true }));
-
-    const tmpCanvas = document.createElement('canvas');
-    tmpCanvas.width = this._config.scaledCharWidth;
-    tmpCanvas.height = this._config.scaledCharHeight;
-    this._tmpCtx = throwIfFalsy(tmpCanvas.getContext('2d', { alpha: this._config.allowTransparency }));
-
-    this._width = Math.floor(TEXTURE_WIDTH / this._config.scaledCharWidth);
-    this._height = Math.floor(TEXTURE_HEIGHT / this._config.scaledCharHeight);
-    const capacity = this._width * this._height;
-    this._cacheMap = new LRUMap(capacity);
-    this._cacheMap.prealloc(capacity);
-
-    // This is useful for debugging
-    // document.body.appendChild(this._cacheCanvas);
-  }
-
-  public dispose(): void {
-    if (this._bitmapCommitTimeout !== null) {
-      window.clearTimeout(this._bitmapCommitTimeout);
-      this._bitmapCommitTimeout = null;
-    }
-  }
-
-  public beginFrame(): void {
-    this._drawToCacheCount = 0;
-  }
-
-  public clear(): void {
-    if (this._cacheMap.size > 0) {
-      const capacity = this._width * this._height;
-      this._cacheMap = new LRUMap(capacity);
-      this._cacheMap.prealloc(capacity);
-    }
-    this._cacheCtx.clearRect(0, 0, TEXTURE_WIDTH, TEXTURE_HEIGHT);
-    this._tmpCtx.clearRect(0, 0, this._config.scaledCharWidth, this._config.scaledCharHeight);
-  }
-
-  public draw(
-    ctx: CanvasRenderingContext2D,
-    glyph: IGlyphIdentifier,
-    x: number,
-    y: number
-  ): boolean {
-    // Space is always an empty cell, special case this as it's so common
-    if (glyph.code === 32) {
-      return true;
-    }
-
-    // Exit early for uncachable glyphs
-    if (!this._canCache(glyph)) {
-      return false;
-    }
-
-    const glyphKey = getGlyphCacheKey(glyph);
-    const cacheValue = this._cacheMap.get(glyphKey);
-    if (cacheValue !== null && cacheValue !== undefined) {
-      this._drawFromCache(ctx, cacheValue, x, y);
-      return true;
-    }
-    if (this._drawToCacheCount < FRAME_CACHE_DRAW_LIMIT) {
-      let index;
-      if (this._cacheMap.size < this._cacheMap.capacity) {
-        index = this._cacheMap.size;
-      } else {
-        // we're out of space, so our call to set will delete this item
-        index = this._cacheMap.peek()!.index;
-      }
-      const cacheValue = this._drawToCache(glyph, index);
-      this._cacheMap.set(glyphKey, cacheValue);
-      this._drawFromCache(ctx, cacheValue, x, y);
-      return true;
-    }
-    return false;
-  }
-
-  private _canCache(glyph: IGlyphIdentifier): boolean {
-    // Only cache ascii and extended characters for now, to be safe. In the future, we could do
-    // something more complicated to determine the expected width of a character.
-    //
-    // If we switch the renderer over to webgl at some point, we may be able to use blending modes
-    // to draw overlapping glyphs from the atlas:
-    // https://github.com/servo/webrender/issues/464#issuecomment-255632875
-    // https://webglfundamentals.org/webgl/lessons/webgl-text-texture.html
-    return glyph.code < 256;
-  }
-
-  private _toCoordinateX(index: number): number {
-    return (index % this._width) * this._config.scaledCharWidth;
-  }
-
-  private _toCoordinateY(index: number): number {
-    return Math.floor(index / this._width) * this._config.scaledCharHeight;
-  }
-
-  private _drawFromCache(
-    ctx: CanvasRenderingContext2D,
-    cacheValue: IGlyphCacheValue,
-    x: number,
-    y: number
-  ): void {
-    // We don't actually need to do anything if this is whitespace.
-    if (cacheValue.isEmpty) {
-      return;
-    }
-    const cacheX = this._toCoordinateX(cacheValue.index);
-    const cacheY = this._toCoordinateY(cacheValue.index);
-    ctx.drawImage(
-      cacheValue.inBitmap ? this._bitmap! : this._cacheCanvas,
-      cacheX,
-      cacheY,
-      this._config.scaledCharWidth,
-      this._config.scaledCharHeight,
-      x,
-      y,
-      this._config.scaledCharWidth,
-      this._config.scaledCharHeight
-    );
-  }
-
-  private _getColorFromAnsiIndex(idx: number): IColor {
-    if (idx < this._config.colors.ansi.length) {
-      return this._config.colors.ansi[idx];
-    }
-    return DEFAULT_ANSI_COLORS[idx];
-  }
-
-  private _getBackgroundColor(glyph: IGlyphIdentifier): IColor {
-    if (this._config.allowTransparency) {
-      // The background color might have some transparency, so we need to render it as fully
-      // transparent in the atlas. Otherwise we'd end up drawing the transparent background twice
-      // around the anti-aliased edges of the glyph, and it would look too dark.
-      return TRANSPARENT_COLOR;
-    }
-    let result: IColor;
-    if (glyph.bg === INVERTED_DEFAULT_COLOR) {
-      result = this._config.colors.foreground;
-    } else if (glyph.bg < 256) {
-      result = this._getColorFromAnsiIndex(glyph.bg);
-    } else {
-      result = this._config.colors.background;
-    }
-    if (glyph.dim) {
-      result = color.blend(this._config.colors.background, color.multiplyOpacity(result, 0.5));
-    }
-    return result;
-  }
-
-  private _getForegroundColor(glyph: IGlyphIdentifier): IColor {
-    if (glyph.fg === INVERTED_DEFAULT_COLOR) {
-      return color.opaque(this._config.colors.background);
-    }
-    if (glyph.fg < 256) {
-      // 256 color support
-      return this._getColorFromAnsiIndex(glyph.fg);
-    }
-    return this._config.colors.foreground;
-  }
-
-  // TODO: We do this (or something similar) in multiple places. We should split this off
-  // into a shared function.
-  private _drawToCache(glyph: IGlyphIdentifier, index: number): IGlyphCacheValue {
-    this._drawToCacheCount++;
-
-    this._tmpCtx.save();
-
-    // draw the background
-    const backgroundColor = this._getBackgroundColor(glyph);
-    // Use a 'copy' composite operation to clear any existing glyph out of _tmpCtxWithAlpha, regardless of
-    // transparency in backgroundColor
-    this._tmpCtx.globalCompositeOperation = 'copy';
-    this._tmpCtx.fillStyle = backgroundColor.css;
-    this._tmpCtx.fillRect(0, 0, this._config.scaledCharWidth, this._config.scaledCharHeight);
-    this._tmpCtx.globalCompositeOperation = 'source-over';
-
-    // draw the foreground/glyph
-    const fontWeight = glyph.bold ? this._config.fontWeightBold : this._config.fontWeight;
-    const fontStyle = glyph.italic ? 'italic' : '';
-    this._tmpCtx.font =
-      `${fontStyle} ${fontWeight} ${this._config.fontSize * this._config.devicePixelRatio}px ${this._config.fontFamily}`;
-    this._tmpCtx.textBaseline = TEXT_BASELINE;
-
-    this._tmpCtx.fillStyle = this._getForegroundColor(glyph).css;
-
-    // Apply alpha to dim the character
-    if (glyph.dim) {
-      this._tmpCtx.globalAlpha = DIM_OPACITY;
-    }
-
-    // Draw the character
-    this._tmpCtx.fillText(glyph.chars, 0, this._config.scaledCharHeight);
-
-    // clear the background from the character to avoid issues with drawing over the previous
-    // character if it extends past it's bounds
-    let imageData = this._tmpCtx.getImageData(
-      0, 0, this._config.scaledCharWidth, this._config.scaledCharHeight
-    );
-    let isEmpty = false;
-    if (!this._config.allowTransparency) {
-      isEmpty = clearColor(imageData, backgroundColor);
-    }
-
-    // If this charcater is underscore and empty, shift it up until it is visible, try for a maximum
-    // of 5 pixels.
-    if (isEmpty && glyph.chars === '_' && !this._config.allowTransparency) {
-      for (let offset = 1; offset <= 5; offset++) {
-        // Draw the character
-        this._tmpCtx.fillText(glyph.chars, 0, this._config.scaledCharHeight - offset);
-
-        // clear the background from the character to avoid issues with drawing over the previous
-        // character if it extends past it's bounds
-        imageData = this._tmpCtx.getImageData(
-          0, 0, this._config.scaledCharWidth, this._config.scaledCharHeight
-        );
-        isEmpty = clearColor(imageData, backgroundColor);
-        if (!isEmpty) {
-          break;
-        }
-      }
-    }
-
-    this._tmpCtx.restore();
-
-    // copy the data from imageData to _cacheCanvas
-    const x = this._toCoordinateX(index);
-    const y = this._toCoordinateY(index);
-    // putImageData doesn't do any blending, so it will overwrite any existing cache entry for us
-    this._cacheCtx.putImageData(imageData, x, y);
-
-    // Add the glyph and queue it to the bitmap (if the browser supports it)
-    const cacheValue = {
-      index,
-      isEmpty,
-      inBitmap: false
-    };
-    this._addGlyphToBitmap(cacheValue);
-
-    return cacheValue;
-  }
-
-  private _addGlyphToBitmap(cacheValue: IGlyphCacheValue): void {
-    // Support is patchy for createImageBitmap at the moment, pass a canvas back
-    // if support is lacking as drawImage works there too. Firefox is also
-    // included here as ImageBitmap appears both buggy and has horrible
-    // performance (tested on v55).
-    if (!('createImageBitmap' in window) || isFirefox || isSafari) {
-      return;
-    }
-
-    // Add the glyph to the queue
-    this._glyphsWaitingOnBitmap.push(cacheValue);
-
-    // Check if bitmap generation timeout already exists
-    if (this._bitmapCommitTimeout !== null) {
-      return;
-    }
-
-    this._bitmapCommitTimeout = window.setTimeout(() => this._generateBitmap(), GLYPH_BITMAP_COMMIT_DELAY);
-  }
-
-  private _generateBitmap(): void {
-    const glyphsMovingToBitmap = this._glyphsWaitingOnBitmap;
-    this._glyphsWaitingOnBitmap = [];
-    window.createImageBitmap(this._cacheCanvas).then(bitmap => {
-      // Set bitmap
-      this._bitmap = bitmap;
-
-      // Mark all new glyphs as in bitmap, excluding glyphs that came in after
-      // the bitmap was requested
-      for (let i = 0; i < glyphsMovingToBitmap.length; i++) {
-        const value = glyphsMovingToBitmap[i];
-        // It doesn't matter if the value was already evicted, it will be
-        // released from memory after this block if so.
-        value.inBitmap = true;
-      }
-    });
-    this._bitmapCommitTimeout = null;
-  }
-}
-
-// This is used for debugging the renderer, just swap out `new DynamicCharAtlas` with
-// `new NoneCharAtlas`.
-export class NoneCharAtlas extends BaseCharAtlas {
-  constructor(document: Document, config: ICharAtlasConfig) {
-    super();
-  }
-
-  public draw(
-    ctx: CanvasRenderingContext2D,
-    glyph: IGlyphIdentifier,
-    x: number,
-    y: number
-  ): boolean {
-    return false;
-  }
-}
-
-/**
- * Makes a particular rgb color and colors that are nearly the same in an ImageData completely
- * transparent.
- * @returns True if the result is "empty", meaning all pixels are fully transparent.
- */
-function clearColor(imageData: ImageData, color: IColor): boolean {
-  let isEmpty = true;
-  const r = color.rgba >>> 24;
-  const g = color.rgba >>> 16 & 0xFF;
-  const b = color.rgba >>> 8 & 0xFF;
-  for (let offset = 0; offset < imageData.data.length; offset += 4) {
-    if (Math.abs(imageData.data[offset] - r) +
-        Math.abs(imageData.data[offset + 1] - g) +
-        Math.abs(imageData.data[offset + 2] - b) < 35) {
-      imageData.data[offset + 3] = 0;
-    } else {
-      isEmpty = false;
-    }
-  }
-  return isEmpty;
-}

addons/xterm-addon-canvas/src/atlas/LRUMap.test.ts

@@ -1,65 +0,0 @@
-/**
- * Copyright (c) 2017 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { assert } from 'chai';
-import { LRUMap } from './LRUMap';
-
-describe('LRUMap', () => {
-  it('can be used to store and retrieve values', () => {
-    const map = new LRUMap(10);
-    map.set(1, 'valuea');
-    map.set(2, 'valueb');
-    map.set(3, 'valuec');
-    assert.strictEqual(map.get(1), 'valuea');
-    assert.strictEqual(map.get(2), 'valueb');
-    assert.strictEqual(map.get(3), 'valuec');
-  });
-
-  it('maintains a size from insertions', () => {
-    const map = new LRUMap(10);
-    assert.strictEqual(map.size, 0);
-    map.set(1, 'value');
-    assert.strictEqual(map.size, 1);
-    map.set(2, 'value');
-    assert.strictEqual(map.size, 2);
-  });
-
-  it('deletes the oldest entry when the capacity is exceeded', () => {
-    const map = new LRUMap(4);
-    map.set(1, 'value');
-    map.set(2, 'value');
-    map.set(3, 'value');
-    map.set(4, 'value');
-    map.set(5, 'value');
-    assert.isNull(map.get(1));
-    assert.isNotNull(map.get(2));
-    assert.isNotNull(map.get(3));
-    assert.isNotNull(map.get(4));
-    assert.isNotNull(map.get(5));
-    assert.strictEqual(map.size, 4);
-  });
-
-  it('prevents a recently accessed entry from getting deleted', () => {
-    const map = new LRUMap(2);
-    map.set(1, 'value');
-    map.set(2, 'value');
-    map.get(1);
-    // a would normally get deleted here, except that we called get()
-    map.set(3, 'value');
-    assert.isNotNull(map.get(1));
-    // b got deleted instead of a
-    assert.isNull(map.get(2));
-    assert.isNotNull(map.get(3));
-  });
-
-  it('supports mutation', () => {
-    const map = new LRUMap(10);
-    map.set(1, 'oldvalue');
-    map.set(1, 'newvalue');
-    // mutation doesn't change the size
-    assert.strictEqual(map.size, 1);
-    assert.strictEqual(map.get(1), 'newvalue');
-  });
-});

addons/xterm-addon-canvas/src/atlas/LRUMap.ts

@@ -1,136 +0,0 @@
-/**
- * Copyright (c) 2017 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-interface ILinkedListNode<T> {
-  prev: ILinkedListNode<T> | null;
-  next: ILinkedListNode<T> | null;
-  key: number | null;
-  value: T | null;
-}
-
-export class LRUMap<T> {
-  private _map: { [key: number]: ILinkedListNode<T> } = {};
-  private _head: ILinkedListNode<T> | null = null;
-  private _tail: ILinkedListNode<T> | null = null;
-  private _nodePool: ILinkedListNode<T>[] = [];
-  public size: number = 0;
-
-  constructor(public capacity: number) { }
-
-  private _unlinkNode(node: ILinkedListNode<T>): void {
-    const prev = node.prev;
-    const next = node.next;
-    if (node === this._head) {
-      this._head = next;
-    }
-    if (node === this._tail) {
-      this._tail = prev;
-    }
-    if (prev !== null) {
-      prev.next = next;
-    }
-    if (next !== null) {
-      next.prev = prev;
-    }
-  }
-
-  private _appendNode(node: ILinkedListNode<T>): void {
-    const tail = this._tail;
-    if (tail !== null) {
-      tail.next = node;
-    }
-    node.prev = tail;
-    node.next = null;
-    this._tail = node;
-    if (this._head === null) {
-      this._head = node;
-    }
-  }
-
-  /**
-   * Preallocate a bunch of linked-list nodes. Allocating these nodes ahead of time means that
-   * they're more likely to live next to each other in memory, which seems to improve performance.
-   *
-   * Each empty object only consumes about 60 bytes of memory, so this is pretty cheap, even for
-   * large maps.
-   */
-  public prealloc(count: number): void {
-    const nodePool = this._nodePool;
-    for (let i = 0; i < count; i++) {
-      nodePool.push({
-        prev: null,
-        next: null,
-        key: null,
-        value: null
-      });
-    }
-  }
-
-  public get(key: number): T | null {
-    // This is unsafe: We're assuming our keyspace doesn't overlap with Object.prototype. However,
-    // it's faster than calling hasOwnProperty, and in our case, it would never overlap.
-    const node = this._map[key];
-    if (node !== undefined) {
-      this._unlinkNode(node);
-      this._appendNode(node);
-      return node.value;
-    }
-    return null;
-  }
-
-  /**
-   * Gets a value from a key without marking it as the most recently used item.
-   */
-  public peekValue(key: number): T | null {
-    const node = this._map[key];
-    if (node !== undefined) {
-      return node.value;
-    }
-    return null;
-  }
-
-  public peek(): T | null {
-    const head = this._head;
-    return head === null ? null : head.value;
-  }
-
-  public set(key: number, value: T): void {
-    // This is unsafe: See note above.
-    let node = this._map[key];
-    if (node !== undefined) {
-      // already exists, we just need to mutate it and move it to the end of the list
-      node = this._map[key];
-      this._unlinkNode(node);
-      node.value = value;
-    } else if (this.size >= this.capacity) {
-      // we're out of space: recycle the head node, move it to the tail
-      node = this._head!;
-      this._unlinkNode(node);
-      delete this._map[node.key!];
-      node.key = key;
-      node.value = value;
-      this._map[key] = node;
-    } else {
-      // make a new element
-      const nodePool = this._nodePool;
-      if (nodePool.length > 0) {
-        // use a preallocated node if we can
-        node = nodePool.pop()!;
-        node.key = key;
-        node.value = value;
-      } else {
-        node = {
-          prev: null,
-          next: null,
-          key,
-          value
-        };
-      }
-      this._map[key] = node;
-      this.size++;
-    }
-    this._appendNode(node);
-  }
-}

addons/xterm-addon-canvas/src/atlas/Types.d.ts

@@ -1,29 +0,0 @@
-/**
- * Copyright (c) 2017 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { FontWeight } from 'common/services/Services';
-import { IPartialColorSet } from 'browser/Types';
-
-export interface IGlyphIdentifier {
-  chars: string;
-  code: number;
-  bg: number;
-  fg: number;
-  bold: boolean;
-  dim: boolean;
-  italic: boolean;
-}
-
-export interface ICharAtlasConfig {
-  devicePixelRatio: number;
-  fontSize: number;
-  fontFamily: string;
-  fontWeight: FontWeight;
-  fontWeightBold: FontWeight;
-  scaledCharWidth: number;
-  scaledCharHeight: number;
-  allowTransparency: boolean;
-  colors: IPartialColorSet;
-}

addons/xterm-addon-canvas/typings/xterm-addon-canvas.d.ts

@@ -12,6 +12,16 @@ declare module 'xterm-addon-canvas' {
   export class CanvasAddon implements ITerminalAddon {
     public textureAtlas?: HTMLCanvasElement;
 
+    /**
+     * An event that is fired when the texture atlas of the renderer changes.
+     */
+    public readonly onChangeTextureAtlas: IEvent<HTMLCanvasElement>;
+
+    /**
+     * An event that is fired when the a new page is added to the texture atlas.
+     */
+    public readonly onAddTextureAtlasCanvas: IEvent<HTMLCanvasElement>;
+
     constructor();
 
     /**

addons/xterm-addon-fit/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xterm-addon-fit",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "author": {
     "name": "The xterm.js authors",
     "url": "https://xtermjs.org/"

addons/xterm-addon-fit/src/FitAddon.ts

@@ -4,6 +4,7 @@
  */
 
 import { Terminal, ITerminalAddon } from 'xterm';
+import { IRenderDimensions } from 'browser/renderer/shared/Types';
 
 interface ITerminalDimensions {
   /**
@@ -23,8 +24,6 @@ const MINIMUM_ROWS = 1;
 export class FitAddon implements ITerminalAddon {
   private _terminal: Terminal | undefined;
 
-  constructor() {}
-
   public activate(terminal: Terminal): void {
     this._terminal = terminal;
   }
@@ -58,8 +57,9 @@ export class FitAddon implements ITerminalAddon {
 
     // TODO: Remove reliance on private API
     const core = (this._terminal as any)._core;
+    const dims: IRenderDimensions = core._renderService.dimensions;
 
-    if (core._renderService.dimensions.actualCellWidth === 0 || core._renderService.dimensions.actualCellHeight === 0) {
+    if (dims.css.cell.width === 0 || dims.css.cell.height === 0) {
       return undefined;
     }
 
@@ -81,8 +81,8 @@ export class FitAddon implements ITerminalAddon {
     const availableHeight = parentElementHeight - elementPaddingVer;
     const availableWidth = parentElementWidth - elementPaddingHor - scrollbarWidth;
     const geometry = {
-      cols: Math.max(MINIMUM_COLS, Math.floor(availableWidth / core._renderService.dimensions.actualCellWidth)),
-      rows: Math.max(MINIMUM_ROWS, Math.floor(availableHeight / core._renderService.dimensions.actualCellHeight))
+      cols: Math.max(MINIMUM_COLS, Math.floor(availableWidth / dims.css.cell.width)),
+      rows: Math.max(MINIMUM_ROWS, Math.floor(availableHeight / dims.css.cell.height))
     };
     return geometry;
   }

addons/xterm-addon-fit/src/tsconfig.json

@@ -13,10 +13,20 @@
     "strict": true,
     "types": [
       "../../../node_modules/@types/mocha"
-    ]
+    ],
+    "paths": {
+      "browser/*": [
+        "../../../src/browser/*"
+      ]
+    }
   },
   "include": [
     "./**/*",
     "../../../typings/xterm.d.ts"
+  ],
+  "references": [
+    {
+      "path": "../../../src/browser"
+    }
   ]
 }

addons/xterm-addon-fit/test/FitAddon.api.ts

@@ -5,7 +5,7 @@
 
 import { assert } from 'chai';
 import { openTerminal, launchBrowser } from '../../../out-test/api/TestUtils';
-import { Browser, Page } from 'playwright';
+import { Browser, Page } from '@playwright/test';
 
 const APP = 'http://127.0.0.1:3001/test';
 
@@ -41,9 +41,7 @@ describe('FitAddon', () => {
   });
 
   describe('proposeDimensions', () => {
-    afterEach(async () => {
-      return await unloadFit();
-    });
+    afterEach(() => unloadFit());
 
     it('default', async function(): Promise<any> {
       await loadFit();
@@ -82,9 +80,7 @@ describe('FitAddon', () => {
   });
 
   describe('fit', () => {
-    afterEach(async () => {
-      return await unloadFit();
-    });
+    afterEach(() => unloadFit());
 
     it('default', async function(): Promise<any> {
       await loadFit();

addons/xterm-addon-image/.gitignore

@@ -0,0 +1,34 @@
+node_modules/
+*.swp
+.lock-wscript
+lib/
+out/
+out-test/
+out-worker/
+.nyc_output/
+Makefile.gyp
+*.Makefile
+*.target.gyp.mk
+*.node
+example/*.log
+docs/
+npm-debug.log
+/.idea/
+.env
+build/
+.DS_Store
+package-lock.json
+yarn.lock
+
+# Keep bundled code out of Git
+dist/
+demo/dist/
+
+# skip benchmark & inwasm folders, except builds
+.benchmark/
+timeline/
+inwasm-sdks/
+inwasm-builds/
+!inwasm-builds/**/final.wat
+!inwasm-builds/**/final.wasm
+!inwasm-builds/**/definition.json

addons/xterm-addon-image/.npmignore

@@ -0,0 +1,10 @@
+.github
+fixture
+overwrite
+bootstrap.sh
+tsconfig.json
+webpack.config.js
+test
+out-test
+inwasm-sdks
+inwasm-builds

addons/xterm-addon-image/LICENSE

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

addons/xterm-addon-image/README.md

@@ -0,0 +1,231 @@
+## xterm-addon-image
+
+Inline image output in xterm.js. Supports SIXEL and iTerm's inline image protocol (IIP).
+
+
+![](fixture/example.png)
+
+
+### Install from npm
+
+```bash
+npm install --save xterm-addon-image
+```
+
+
+### Usage
+
+```ts
+import { Terminal } from 'xterm';
+import { ImageAddon, IImageAddonOptions } from 'xterm-addon-image';
+
+// customize as needed (showing addon defaults)
+const customSettings: IImageAddonOptions = {
+  enableSizeReports: true,    // whether to enable CSI t reports (see below)
+  pixelLimit: 16777216,       // max. pixel size of a single image
+  sixelSupport: true,         // enable sixel support
+  sixelScrolling: true,       // whether to scroll on image output
+  sixelPaletteLimit: 256,     // initial sixel palette size
+  sixelSizeLimit: 25000000,   // size limit of a single sixel sequence
+  storageLimit: 128,          // FIFO storage limit in MB
+  showPlaceholder: true,      // whether to show a placeholder for evicted images
+  iipSupport: true,           // enable iTerm IIP support
+  iipSizeLimit: 20000000      // size limit of a single IIP sequence
+}
+
+// initialization
+const terminal = new Terminal();
+const imageAddon = new ImageAddon(customSettings);
+terminal.loadAddon(imageAddon);
+```
+
+### General Notes
+
+- *IMPORTANT:* The worker approach as done in previous releases got removed.
+  The addon contructor no longer expects a worker path as first argument.
+
+- By default the addon will activate these `windowOptions` reports on the terminal:
+  - getWinSizePixels (CSI 14 t)
+  - getCellSizePixels (CSI 16 t)
+  - getWinSizeChars (CSI 18 t)
+  
+  to help applications getting useful terminal metrics for their image preparations. Set `enableSizeReports` in the constructor options to `false`, if you dont want the addon to alter these terminal settings. This is especially useful, if you have very strict security needs not allowing any terminal reports, or deal with `windowOptions` by other means.
+
+
+### Operation Modes
+
+- **SIXEL Support**  
+  Set by default, change it with `{sixelSupport: true}`.
+
+- **Scrolling On | Off**  
+  By default scrolling is on, thus an image will advance the cursor at the bottom if needed.
+  (see cursor positioning).
+
+  If scrolling is off, the image gets painted from the top left of the current viewport
+  and might be truncated if the image exceeds the viewport size.
+  The cursor position does not change.
+
+  You can customize this behavior with the constructor option `{sixelScrolling: false}`
+  or with `DECSET 80` (off, binary: `\x1b [ ? 80 h`) and
+  `DECRST 80` (on, binary: `\x1b [ ? 80 l`) during runtime.
+
+- **Cursor Positioning**  
+  If scrolling is set, the cursor will be placed at the first image column of the last image row (VT340 mode).
+  Other cursor positioning modes as used by xterm or mintty are not supported.
+
+- **SIXEL Palette Handling**  
+  By default the addon limits the palette size to 256 registers (as demanded by the DEC specification).
+  The limit can be increased to a maximum of 4096 registers (via `sixelPaletteLimit`).
+
+  The default palette is a mixture of VT340 colors (lower 16 registers), xterm colors (up to 256) and zeros (up to 4096).
+  There is no private/shared palette distinction, palette colors are always carried over from a previous sixel image.
+  Restoring the default palette size and colors is possible with `XTSMGRAPHICS 1 ; 2` (binary: `\x1b[?1;2S`).
+  It gets also restored automatically on RIS and DECSTR.
+
+  Other than on older terminals, the underlying SIXEL library applies colors immediately to individual pixels
+  (*printer mode*), thus it is technically possible to use more colors in one image than the palette has color slots.
+  This feature is called *high-color* in libsixel.
+
+  A terminal wide shared palette mode with late indexed coloring of the output is not supported,
+  therefore palette animations cannot be used.
+
+- **SIXEL Raster Attributes Handling**  
+  If raster attributes were found in the SIXEL data (level 2), the image will always be truncated to the given height/width extend. We deviate here from the specification on purpose, as it allows several processing optimizations. For level 1 SIXEL data without any raster attributes the image can freely grow in width and height up to the last data byte, which has a much higher processing penalty. In general encoding libraries should not create level 1 data anymore and should not produce pixel information beyond the announced height/width extend. Both is discouraged by the >30 years old specification.
+
+  Currently the SIXEL implementation of the addon does not take custom pixel sizes into account, a SIXEL pixel will map 1:1 to a screen pixel.
+
+- **IIP Support (iTerm's Inline Image Protocol)**  
+  Set by default, change it with `{iipSupport: true}`.
+
+  The IIP implementation has the following features / restrictions (sequence will silently fail for unmet conditions):
+  - Supported formats: PNG, JPEG and GIF
+  - No animation support.
+  - Image type hinting is not supported (always deducted from data header).
+  - File download is not supported.
+  - Filename gets parsed but not used.
+  - Strict base64 handling as of RFC4648 §4 (standard alphabet, optional padding, no separator bytes allowed).
+  - Payload size may not exceed CEIL(sizeParameter * 4 / 3).
+  - Image scaling beyond terminal viewport size is allowed (e.g. `width=200%`).
+  - Image pixel size is restricted by `pixelLimit` (pre- and post resizing).
+  - Size parameter is restricted by `iipSizeLimit`.
+  - Cursor positioning behaves the same as for sixel (see above).
+
+
+### Storage and Drawing Settings
+
+The internal storage holds images up to `storageLimit` (in MB, calculated as 4-channel RBGA unpacked, default 100 MB). Once hit images get evicted by FIFO rules. Furthermore images on the alternate buffer will always be erased on buffer changes.
+
+The addon exposes two properties to interact with the storage limits at runtime:
+- `storageLimit`  
+  Change the value to your needs at runtime. This is especially useful, if you have multiple terminal
+  instances running, that all add to one upper memory limit.
+- `storageUsage`  
+  Inspect the current memory usage of the image storage.
+
+By default the addon will show a placeholder pattern for evicted images that are still part
+of the terminal (e.g. in the scrollback). The pattern can be deactivated by toggling `showPlaceholder`.
+
+### Image Data Retrieval
+
+The addon provides the following API endpoints to retrieve raw image data as canvas:
+
+- `getImageAtBufferCell(x: number, y: number): HTMLCanvasElement | undefined`  
+  Returns the canvas containing the original image data (not resized) at the given buffer position.
+  The buffer position is the 0-based absolute index (including scrollback at top).
+
+- `extractTileAtBufferCell(x: number, y: number): HTMLCanvasElement | undefined`  
+  Returns a canvas containing the actual single tile image data (maybe resized) at the given buffer position.
+  The buffer position is the 0-based absolute index (including scrollback at top).
+  Note that the canvas gets created and data copied over for every call, thus it is not suitable for performance critical actions.
+
+### Memory Usage
+
+The addon does most image processing in Javascript and therefore can occupy a rather big amount of memory. To get an idea where the memory gets eaten, lets look at the data flow and processing steps:
+- Incomming image data chunk at `term.write` (terminal)  
+  `term.write` might stock up incoming chunks. To circumvent this, you will need proper flow control (see xterm.js docs). Note that with image output it is more likely to run into this issue, as it can create lots of MBs in very short time.
+- Sequence Parser (terminal)  
+  The parser operates on a buffer containing up to 2^17 codepoints (~0.5 MB).
+- Sequence Handler - Chunk Decoding (addon)  
+  Image data chunks are processed immediately by the SIXEL decoder (streamlined). The decoder allocates memory for image
+  pixels as needed. The allowed image size is restricted by `pixelLimit` (default 16M pixels), the decoder holds 2 pixel buffers at maximum during decoding (RGBA, ~128 MB for 16M pixels).
+- Sequence Handler - Image Finalization (addon) 
+  After decoding the final pixel buffer is grabbed by the sequence handler and written to a canvas of the same size (~64 MB for 16M pixels) and added to the storage.
+- Image Storage (addon)  
+  The image storage implements a FIFO cache, that will remove old images, if a new one arrives and `storageLimit` is hit (default 128 MB). The storage holds a canvas with the original image, and may additionally hold resized versions of images after a font rescaling. Both are accounted in `storageUsage` as a rough estimation of _pixels x 4 channels_.
+
+Following the steps above, a rough estimation of maximum memory usage by the addon can be calculated with these formulas (in bytes):
+```typescript
+// storage alone
+const storageBytes = storageUsage * storageLimit * 1024 * 1024;
+// decoding alone
+const decodingBytes = sixelSizeLimit + 2 * (pixelLimit * 4);
+
+// totals
+// inactive decoding
+const totalInactive = storageBytes;
+// active decoding
+const totalActive = storageBytes + decodingBytes;
+```
+
+Note that browsers have offloading tricks for rarely touched memory segments, esp. `storageBytes` might not directly translate into real memory usage. Usage peaks will happen during active decoding of multiple big images due to the need of 2 full pixel buffers at the same time, which cannot be offloaded. Thus you may want to keep an eye on `pixelLimit` under limited memory conditions.  
+Further note that the formulas above do not respect the Javascript object's overhead. Compared to the raw buffer needs the book keeping by these objects is rather small (<<5%).
+
+_Why should I care about memory usage at all?_  
+Well you don't have to, and it probably will just work fine with the addon defaults. But for bigger integrations, where much more data is held in the Javascript context (like multiple terminals on one page), it is likely to hit the engine's memory limit sooner or later under decoding and/or storage pressure.
+
+_How can I adjust the memory usage?_  
+- `pixelLimit`  
+  A constructor setting, thus you would have to anticipate, whether (multiple) terminals in your page gonna do lots of concurrent decoding. Since this is normally not the case and the memory usage is only temporarily peaking, a rather high value should work even with multiple terminals in one page.
+- `storageLimit`  
+  A constructor and a runtime setting. In conjunction with `storageUsage` you can do runtime checks and adjust the limit to your needs. If you have to lower the limit below the current usage, images will be removed in FIFO order and may turn into a placeholder in the terminal's scrollback (if `showPlaceholder` is set). When adjusting keep in mind to leave enough room for memory peaking for decoding.
+- `sixelSizeLimit`  
+  A constructor setting. This has only a small impact on peaking memory during decoding. It is meant to avoid processing of overly big or broken SIXEL sequences at an earlier phase, thus may stop the decoder from entering its memory intensive task for potentially invalid data.
+
+
+### Terminal Interaction
+
+- Images already on the terminal screen will reshape on font-rescaling to keep the terminal cell coverage intact.
+  This behavior might diverge from other terminals, but is in general the more desired one.
+- On terminal resize images may expand to the right automatically, if they were right-truncated before.
+  They never expand to the bottom, if they were bottom-truncated before (e.g. from scrolling-off).
+- Text autowrapping from terminal resize may break and wrap images into multiple parts. This is unfortunate,
+  but cannot be avoided, while sticking to the stronger terminal text-grid mechanics.
+  (Yes images are a second class citizen on a mainly text-driven interface.)
+- Characters written over an image will erase the image information for affected cells.
+- Images are painted above BG/FG data not erasing it. More advanced "composition tricks" like painting images
+  below FG/BG data are not possible. (We currently dont hook into BG/FG rendering itself.)
+- Previous image data at a cell will be erased on new image data. (We currently have no transparency composition.)
+
+
+### Performance & Latency
+
+- Performance should be good enough for occasional SIXEL output from REPLs, up to downscaled movies
+  from `mpv` with its SIXEL renderer (tested in the demo). For 3rd party xterm.js integrations this
+  furthermore depends highly on the overall incoming data throughput.
+- Image processing has a high latency. Most of the latency though is inherited from xterm.js' incoming data route
+  (PTY -> server process -> websocket -> xterm.js async parsing), where every step creates more waiting time.
+  Since we cannot do much about that "long line", keep that in mind when you try to run more demanding applications with realtime drawing and interactive response needs.
+
+
+### Status
+
+- Sixel support and image handling in xterm.js is considered beta quality.
+- IIP support is in alpha stage. Please file a bug for any awkwardities.
+
+
+### Changelog
+
+- 0.5.0 integrate with xtermjs base repo (at v0.4.3)
+- 0.4.3 defer canvas creation
+- 0.4.2 fix image canvas resize
+- 0.4.1 compat release for xterm.js 5.2.0
+- 0.4.0 IIP support
+- 0.3.1 compat release for xterm.js 5.1.0
+- 0.3.0 important change: worker removed from addon
+- 0.2.0 compat release for xterm.js 5.0.0
+- 0.1.3 bugfix: avoid striping
+- 0.1.2 bugfix: reset clear flag
+- 0.1.1 bugfixes:
+  - clear sticky image tiles on render
+  - create xterm-addon-image folder from bootstrap.sh
+  - fix peer dependency in package.json

addons/xterm-addon-image/fixture/endless.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+# sixel endless mode
+# Should print an endless sine curve, abort with Ctrl-C.
+
+period=200
+amplitude=50
+
+sixels=(@\$ A\$ C\$ G\$ O\$ _\$-)
+pi=$(echo "scale=10; 4*a(1)" | bc -l)
+run=true
+trap run=false INT
+
+echo -ne "\x1bP0;0;0q\"1;1#1;2;100;0;0#1"
+y=0
+while $run
+do
+  x=$(echo "s(2*${pi}*${y}/${period})*${amplitude}+2*${amplitude}+0.5" | bc -l)
+  echo -ne "!${x%%.*}?${sixels[$((y%6))]}"
+  (( y++ ))
+done
+echo -e "\x1b\\"

addons/xterm-addon-image/fixture/gcrglf.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+
+# GLF should move the text cursor downwards,
+# even if no pixels were modified,
+# when sixel scrolling is on.
+
+echo -n $'\e[?80l'		# Ensure sixel scrolling is on (disable DECSDM)
+
+clear
+echo "A test of Sixel GLF (Graphics Line Feed) when sixel scrolling is on"
+echo
+
+# Move cursor down three using GLF ("-")
+echo -e '\x1bPq$-$-$-$-\x1b\\'
+
+# Show a single sixel line that says, "Your terminal ->"
+cat <<'EOF'
+P0;0;0q"1;1;244;21#0;2;0;0;0#1;2;80;80;80#0~~~NFFFN~~~n!4FN!68~NFN!64~bbb!42~rbbbBB!41~$#1???owwwo???O!4wo!68?owo!64?[[[!42?K[[[{{-#0!5~{woBFB`o{}!4~NFBpp!4xpbBF~~~x@@@~~~xxp@@!5~xxp@@b`pxwxpz!17~zpp???!5px!5~NFBpxxwxxpBBN!4~xxp@@b`pxwxpz~x@@@xxp@@pxx@@F!4~xppp@@!8~x@@@pxxwxp@B!5~zxXXXWXX@BF!10~??!24~!10^FNN^~~~$#1!5?BFN{w{]NB@!4?ow{MM!4EM[{w???E}}}???EEM}}!5?EEM}}[]MEFEMC!17?CMM~~~!5ME!5?ow{MEEFEEM{{o!4?EEM}}[]MEFEMC?E}}}EEM}}MEE}}w!4?EMMM}}!8?E}}}MEEFEM}{!5?CEeeefee}{w!10?~~!24?!10_woo_-#0!5~nFFF??FFN!5~wo_FF!4NFb_o!4~{o_!4Ffb??Fn~~~NFF??!4FN!23~_??!5NFFn~~~w__C!7KCC!4~NFF??!4FN!4~N???N~~??Fn~???N~~N!4F??!4Fn~~~F???Fn~~nF??Fn~~p??KMMMEE???Fn~~~N!4F??!4Fn!29~{{}!4~$#1!5?Owww~~wwo!5?FN^ww!4ow[^N!4?BN^!4wW[~~wO???oww~~!4wo!23?^~~!5owwO???F^^z!7rzz!4?oww~~!4wo!4?o~~~o??~~wO?~~~o??o!4w~~!4wO???w~~~wO??Ow~~wO??M~~rpppxx~~~wO???o!4w~~!4wO!29?BB@-#0!25FE!63FE!15FE!77FE!60F$#1!25?@!63?@!15?@!77?@-\
+EOF
+
+sleep 1
+tput cup 2 30
+
+# Show four lines saying, "<- A genuine VT340 would end here"
+cat <<'EOF'
+P0;0;0q"1;1;144;80#0;2;0;0;0#1;2;80;80;80#0~~rpp@@`@BN!25~!11^!5~^^^N^^^!6~!7^N^^^!5~!4^~~~!5^!6~^^^WWW!8~!7^N^^^!8~^^^N^^^!5~$#1??KMM}}]}{o!25?!11_!5?___o___!6?!7_o___!5?!4_???!5_!6?___fff!8?!7_o___!8?___o___-#0~~NB??EFE??@F^!19~B??{!4}{W??}}~~B@?K!5MK??B~~~}???{!4}{??!4~}???~~~}}{??!6~}{{{??!8~}???{!4}{??!4~B@?K!5MK??B~~$#1??o{~~xwx~~}w_!19?{~~B!4@Bf~~@@??{}~r!5pr~~{???@~~~B!4@B~~!4?@~~~???@@B~~!6?@BBB~~!8?@~~~B!4@B~~!4?{}~r!5pr~~{-#0rpoopr~~~zpooopr!17~}{ww!4pwW??!4~}wwprrb!4rpp~~~pooopz~~zpoopz!4~{w!4pxwoopz~~~r!4poo!4pz~~~pooopz~~zpoopz~~}wwprrb!4rpp~~$#1KMNNMK???CMNNNMK!17?@BFF!4MFf~~!4?@FFMKK[!4KMM???MNNNMC??CMNNMC!4?BF!4MEFNNMC???K!4MNN!4MC???MNNNMC??CMNNMC??@FFMKK[!4KMM-#0!32~^NNNKWwww[[MNNN^~!13N!5~NN!5FNN^!10~N!4F!8~NN!4FN^!36~$#1!32?_ooorfFFFbbpooo_?!13o!5?oo!5woo_!10?o!4w!8?oo!4wo_-#0!32~}{o?AM!4~E?_w}}~o_o}}???}}}__!5~}}~fFFFAOw!6~^FB_w{???!6~B??}!4~{??!35~$#1!32?@BN~|p!4?x~^F@@?N^N@@~~~@@@^^!5?@@?Wwww|nF!6?_w{^FB~~~!6?{~~@!4?B~~-#0!36~{_?FB?o}!7~^NN???NN^!6~!8NE?_x!4~poooP@@???X!5~{o?F!4NB_o!35~$#1!36?B^~w{~N@!7?_oo~~~oo_!6?!8ox~^E!4?MNNNm}}~~~e!5?BN~w!4o{^N-#0!38~}}}!11~!8}!8~!6}!13~!6}!9~!4}!38~$#1!38?@@@!11?!8@!8?!6@!13?!6@!9?!4@-#0!5^!5~!5^!5~!7^!6~!4^~~~!5^!6~{www??!11~^^^N^\W???!22~^^^N^^^!6~!7^N^^^!8~^^^N^\W???~~$#1!5_!5?!5_!5?!7_!6?!4_???!5_!6?BFFF~~!11?___o_af~~~!22?___o___!6?!7_o___!8?___o_af~~~-#0}{??CMB@@FM??o{~~B@?{{!4}{w?@~~~}???~~~}}{??!10~??!8~B??{!5}{???!19~B@?K!5MK??B~~~}???{!4}{??!4~B??{!5}{???~~$#1@B~~zp{}}wp~~NB??{}~BB!4@BF~}???@~~~???@@B~~!10?~~!8?{~~B!5@B~~~!19?{}~r!5pr~~{???@~~~B!4@B~~!4?{~~B!5@B~~~-#0~~~woow~}woo{!4~}{wpprbrrpww{!5~{w!4pxwoopz~~~r!4poo!4pz~~~}{ww!5pwooopz!17~}wwprrb!4rpp~~~pooopz~~zpoopz~~}{ww!5pwooopz$#1???FNNF?@FNNB!4?@BFMMK[KKMFFB!5?BF!4MEFNNMC???K!4MNN!4MC???@BFF!5MFNNNMC!17?@FFMKK[!4KMM???MNNNMC??CMNNMC??@BFF!5MFNNNMC-#0!40~n!4F!99~$#1!40?O!4w-#0!10~^^n!29~???b!4rbBF!4~^NFbrrprrbFF^!4~rrbBBFBbrrrbv~~^NFbrrprrbFF^!42~$#1!10?__O!29?~~~[!4K[{w!4?_ow[KKMKK[ww_!4?KK[{{w{[KKK[G??_ow[KKMKK[ww_-#0!9~}{wq!10}!18~N???N^~~^N??N^~~o??H!6XWGG!4~^NN??!4N^!5~o??H!6XWGG!42~$#1!9?@BFL!10@!18?o~~~o_??_o~~o_??N~~u!6efvv!4?_oo~~!4o_!5?N~~u!6efvv-#0!41B!6ABB!6A!5BAAA?!6A!4B!10A!8BAAA?!6A!42B$#1!41?!6@??!6@!5?@@@B!6@!4?!10@!8?@@@B!6@$-\This text should be indented.
+EOF
+
+# For more details, please see:
+# https://github.com/jerch/xterm-addon-image/issues/37
+
+# By default, sixel is in a 2:1 aspect ratio, which means
+# every sixel graphics linefeed (GLF) adds another 12 pixels.
+# With four GLFs, we have five sixel lines = 5 * 12 =  60 pixels.
+
+# Which text line that ends up on depends upon the height of your
+# font. On the VT340, the font is 20 pixels high. 
+
+# On a VT340 sixel scrolling is on by default. DEC refers to this by
+# two different names "sixel scrolling" and its negation, "DECSDM"
+# (Sixel Display Mode). They control the same thing, so when DECSDM is
+# on, sixel scrolling is off, and vice versa. 
+
+# When DECSDM is on, the graphic line feeds do not affect the text cursor.
+
+
+# How hackerb9 created the two sixel test images:
+#
+# convert -family "Courier" -style normal -density 72 -pointsize 26 -interline-spacing -12 -gravity center -fill gray80 -background none label:$'A genuine\nVT340\nwould end\n← here  '  +trim +dither -colors 2 sixel:- > reference.six
+#
+# convert -family "Courier" -style normal -density 72 -pointsize 26 -interline-spacing -12 -gravity center -fill gray80 -background none label:$'Your terminal →'  +trim -bordercolor none -border 2 +dither -colors 2 sixel:- > yourterminal.six
+

addons/xterm-addon-image/fixture/growing_rect.js

@@ -0,0 +1,44 @@
+const sixelEncode = require('../node_modules/sixel/lib/SixelEncoder').image2sixel;
+const toRGBA8888 = require('../node_modules/sixel/lib/Colors').toRGBA8888;
+
+function createRect(size, color) {
+  const pixels = new Uint32Array(size * size);
+  pixels.fill(toRGBA8888(...color));
+  return sixelEncode(new Uint8ClampedArray(pixels.buffer), size, size);
+}
+
+function createRectMinusOne(size, color) {
+  const pixels = new Uint32Array(size * size);
+  if (size - 1) {
+    const sub = new Uint32Array(size - 1);
+    sub.fill(toRGBA8888(...color));
+    const last = size * (size - 1);
+    for (let y = 0; y < last; y += size) {
+      pixels.set(sub, y);
+    }
+  }
+  return sixelEncode(new Uint8ClampedArray(pixels.buffer), size, size);
+}
+
+async function main() {
+  // clear + cursor and sixelScrolling off
+  process.stdout.write('\x1b[2J\x1b[?25;80h');
+
+  for (let i = 1; i < 300; ++i) {
+    await new Promise(res => setTimeout(() => {
+      process.stdout.write(createRect(i, [0, 255, 0]));
+      res();
+    }, 5));
+  }
+  for (let i = 299; i >= 1; --i) {
+    await new Promise(res => setTimeout(() => {
+      process.stdout.write(createRectMinusOne(i, [0, 255, 0]));
+      res();
+    }, 5));
+  }
+
+  // re-enable cursor and sixel scrolling
+  process.stdout.write('\x1b[2J\x1b[?25;80l');
+}
+
+main();

addons/xterm-addon-image/fixture/iip/palette.iip

@@ -0,0 +1 @@
+]1337;File=inline=1;size=525;name=Li4vcGFsZXR0ZS5wbmc=:iVBORw0KGgoAAAANSUhEUgAAAoAAAABQCAYAAACJbMQlAAAABmJLR0QA/wD/AP+gvaeTAAABwklEQVR4nO3dwQnEMAwAQedIIem/yVwLBj0C3pm3uAO/Fj2ia631rh3P1lRu7vnof0+Z836zOe83m/N+sznvN5vzfrM57zeb+23+HAAAhxCAAAAxAhAAIEYAAgDECEAAgBgBCAAQIwABAGIEIABAjAAEAIi59z8tDQDACWwAAQBiBCAAQIwABACIEYAAADECEAAgRgACAMQIQACAGAEIABAjAAEAYlwCAQCIsQEEAIgRgAAAMQIQACBGAAIAxAhAAIAYAQgAECMAAQBiBCAAQIwABACIcQkEACDGBhAAIEYAAgDECEAAgBgBCAAQIwABAGIEIABAjAAEAIgRgAAAMQIQACDGJRAAgBgbQACAGAEIABAjAAEAYgQgAECMAAQAiBGAAAAxAhAAIEYAAgDECEAAgBiXQAAAYmwAAQBiBCAAQIwABACIEYAAADECEAAgRgACAMQIQACAGAEIABAjAAEAYlwCAQCIsQEEAIgRgAAAMQIQACBGAAIAxAhAAIAYAQgAECMAAQBiBCAAQIwABACIcQkEACDGBhAAIEYAAgDECEAAgBgBCAAQIwABAGIEIABAjAAEAIgRgAAAMQIQACDmDz4lC02AaqMRAAAAAElFTkSuQmCC

addons/xterm-addon-image/fixture/iip/w3c_gif.iip

@@ -0,0 +1 @@
+]1337;File=inline=1;size=1667;name=Li4vdGVzdGltYWdlcy93M2NfaG9tZV8yNTYuZ2lm:R0lGODlhSAAwAPcAAAQCBIyKjMzOzERGRHSOvAxCnLy6vNzm9DRmrCQiJGxubNze3HSWxJSq1JyenCRarPz+/FR+vBweHLzG5FxeXGSKxBROpOzu7ERytDw+PHx+fLTC5AwODIyOjExOTAxGnLy+vDxqtCwuLHR2dNTa7ISezKS23KyurMTO5GyKxOzy/ACCXwAAN7AAF+IAjIEAw8DPArtsAOSupIHW2HBvAsUBAHIAbwAAARwAiEdgA/caAr+CAgCIALAjAOMcJIGCAAB8EADGAAByiAAArcQcSrtHBOT3zYG/AaQA7sVgE3Ib9wCCv88AZ2wAAaIAANUAAG+M4wEjogAc9wCCv8SwGbvGBeRyAIEAAF/PrBZsxwCucgDWAIRvpMUBaHIAAQAAAFCMfEIjj/kcUb+CAAC4sLAZKOL3AIG/AECQoAfGowBy9wAAvwBQAABCAAD5UAC/ALgALBlguPcaUb+CAMRwpNUFaAAAAQAAAOAAAPgAAHIAAAAAAG24DBgZAPf3UL+/AM/QAGzWAKIAUNUAAADgfAD4jwByUQAAAKJtQNUYAH/3AFe/AGTPABNsAACuAADWAAAAMgAABUYAAAIAAACuGQDWBQh/AABXAAJH1AABx8QAcgsAAAMAUAAApTdG9wYCv3oAADMAAKUBULAAAEcCZwEApQCM9wDDv0ACAAcAAABfUAAWAKUAQ7AAAEelAAGwAPhHQ8UBAHIAAAAAABhwFIkFxX8AUIEAABClAtKwADxHAIIBABAUopPXKKZm99Iov/gf+MUXx3IAcgAAAAxwZsYFtHIA9wAAvxgAAIlgAH8aUIGCAHiM1QrDtD0C94IAvxAAAJMASqYChdIAgQxw78YFGXIA+AAAvw4AM6EAGvcA+L8AvyYAALMASveNhb+tgQBKLGAEuDzNUYIBAADRmwABbgAA9wAAv8+kFmzYxWYCUNYAAG+k4wHYKAACQgAAAAAAHmAAxTsoUIIAADwcvcZ6bnIC9wAAvxgAm4kAbn8A94EAv0QABAoAAD0MAIIXACH5BAAAAAAALAAAAABIADAABwj/AAEIHEiwoMGDCBMqXGgQgsOHECNKnEixosWLGDNq3Mixo8ePIEOKHCkxgMkRBkiq7BhAgEmXAlbKxBgAwoALAyDUnMlzYs0EA1LuVIGiKAoVEg8YRXFxQoOnJpZKLYpUY0wII2wKGLBg54EPYD+YkEgi7AemFS2AVRuW7Qe3aB8K8ACAA4UFDy+IcGhg54URFx4+CFthIlsLDCqiKGD2bWOzcSE4MOjAoQYAck0GCPyQweGJFcI+qMiA8eO2azFAFIDQwAUOAEBcRNGWhEQTZg9QRFDg8NrTkSUglKBAYOWLbhNHVGG2wcSvYVNE3GC28MPJA0VoUJCAIAfOFiOE/0UwEYPjCBMbmK0quC17CBkGHodwgcJADRlxO9YdMXTY9w6Jx1gIEZXg2AclQHSBfBLZ911GzIU1VkRufTCBRL8595AKbo0G0QkCUUCRdhuFEBZ6EJFQoXUPTWCWbQ/5B9aFEF0GAF4TCQAeRuqFVeBvH3gYo2gQ0eaYahHR5cFKZTm2AUQIPAajQ4OBpZxD5oXFH0TxzUdSlR9c+VWFFiToUJNgPemQfmCxyCUAO44ko5BsukWeQz1aYMGGg7kVwpQOZSDBTC46BqN4bxn4n0MmgoUiBD2iJhaXGfDUnENuHSCeWmNFCNaEEJRQoVmgalDpTIh+oBp1YJEXKXpsfv+wJQol1IqAbxZU5cCpMuHGlgoMrJUYdG9BEJpaBFKEQoVmLsDrSsSKBSaMYC4blpkUoVmsZT1FCVaj20Lg2bcvXnQsWDDKxtO4jbFoZGNCVsTqWxr2BEGTvtGIqaRuZmsWtvaO+sF7Moalr0VuAdxTwR88uuaBYAH43G8pqItRnBkVGla9DnmqlsOK/btkRhnguFGEbG35UJZg1TtBBHdGFCxbKHSA30UBAHCCRywnG1GksjrkrYXLgTnwAgB4KZEAsN3MUaRXQkSszzJaAGiwJzpUnNJywZa0R9BZEBlED6glpltlokDCuW+h9RoAO0EUgNd7fdQnaWBFpqjAWT9gBCIAxJ1wggLCCcSByR0F22+R4a7cWIUIAIjdQRxc9RFtoBq2uAopnPZBCBJL5jVBElgOUq4WVZB5kZt+u3pECygggkAZdICxvbjnrvvuvPfu++/ABy88Q8QXb/zxAgUEADs=

addons/xterm-addon-image/fixture/iip/w3c_jpg.iip

@@ -0,0 +1 @@
+]1337;File=inline=1;size=2159;name=Li4vdGVzdGltYWdlcy93M2NfaG9tZV8yNTYuanBn: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

addons/xterm-addon-image/fixture/iip/w3c_png.iip

@@ -0,0 +1 @@
+]1337;File=inline=1;size=1658;name=Li4vdGVzdGltYWdlcy93M2NfaG9tZV8yNTYucG5n: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

addons/xterm-addon-image/fixture/inspect_palette.sh

@@ -0,0 +1,67 @@
+#!/bin/bash
+
+function print_palette() {
+  L=$(( LOWER / 256))
+  U=$(( (UPPER-1) / 256))
+  for ((p = $L; p <= $U; p++))
+  do
+    echo "slot $((p*256))..$((p*256+255)):"
+    echo -ne "\x1bP;1q"
+    for i in {0..15}
+    do
+      a=$((i * 16 + p * 256))
+      for j in {0..15}
+      do
+        echo -ne "#$((a+j))!6~"
+      done
+      echo -ne "\$-"
+    done
+    echo -e "\x1b\\"
+  done
+}
+
+colors=undefined
+max_colors=undefined
+
+echo "Terminal Reports (XTSMGRAPHICS):"
+IFS=";" read -a REPLY -s -t 1 -d "S" -p $'\e[?1;1;0S'
+[[ ${REPLY[1]} == "0" ]] && colors=${REPLY[2]}
+echo "active colors: ${colors}"
+
+IFS=";" read -a REPLY -s -t 1 -d "S" -p $'\e[?1;4;0S'
+[[ ${REPLY[1]} == "0" ]] && max_colors=${REPLY[2]}
+echo "max colors   : ${max_colors}"
+echo
+
+
+# query up to colors by default
+# if colors is undefined (no XTSMGRAPHICS), assume 256
+ARG1=${1:-${colors}}
+if [[ $colors == "undefined" ]]
+then
+  ARG1=${1:-256}
+fi
+LOWER=0
+UPPER=$ARG1
+ARG2=${2:-undefined}
+if [[ $ARG2 != "undefined" ]]
+then
+  LOWER=ARG1
+  UPPER=ARG2
+fi
+
+if [[ $colors != "undefined" ]]
+then
+  if [[ $colors -lt $UPPER ]] || [[ $colors -lt 256 ]]
+  then
+    echo -e "\x1b[33mNote: Active colors is smaller than test range."
+    echo -e "A spec-conform terminal may repeat colors in 'slot mod ${colors}'.\x1b[m"
+    echo
+  fi
+else
+  echo -e "\x1b[33mNote: Cannot query active colors."
+  echo -e "The terminal may repeat colors beyond it max slot (e.g. slot mod 16).\x1b[m"
+  echo
+fi
+
+print_palette

addons/xterm-addon-image/fixture/overdraw.sh

@@ -0,0 +1,141 @@
+#!/bin/bash
+
+function smiling_smiley() {
+  echo -ne '\x1bP;2q"1;1;60;60
+#6!60~$-
+!60~$-
+!60~$
+!15?#1!4]!22?!4]$-
+#6!60~$-
+!60~$-
+!60~$-
+!60~$
+!15?#1!4~!22?!4~$-
+#6!60~$
+!15?#1!30N$-
+#6!60~$-
+!60~$-
+'
+  echo -ne '\x1b\\'
+}
+
+function indifferent_smiley() {
+  echo -ne '\x1bP;2q"1;1;60;60
+#6!60~$-
+!60~$-
+!60~$
+!15?#1!4]!22?!4]$-
+#6!60~$-
+!60~$-
+!60~$-
+!60~$-
+!60~$
+!15?#1!30N$-
+#6!60~$-
+!60~$-
+'
+  echo -ne '\x1b\\'
+}
+
+function sad_smiley() {
+  echo -ne '\x1bP;2q"1;1;60;60
+#6!60~$-
+!60~$-
+!60~$
+!15?#1!4]!22?!4]$-
+#6!60~$-
+!60~$-
+!60~$-
+!60~$-
+!60~$
+!15?#1!30N$
+!15?#1!4o!22?!4o$-
+#6!60~$
+!15?#1!4B!22?!4B$-
+#6!60~$-
+'
+  echo -ne '\x1b\\'
+}
+
+function smiling_smiley_slim() {
+  echo -ne '\x1bP;1q"1;1;60;60
+$-
+$-
+$-
+$-
+$-
+$-
+!15?#1!4~!22?!4~$-
+!15?#1!30N
+'
+  echo -ne '\x1b\\'
+}
+
+function indifferent_smiley_slim() {
+  echo -ne '\x1bP;1q"1;1;60;60
+$-
+$-
+$-
+$-
+$-
+$-
+!15?#6!4~!22?!4~$-
+!15?!4o!22?!4o$ !15?#1!30N$-
+!15?#6!4B!22?!4B
+'
+  echo -ne '\x1b\\'
+}
+
+function sad_smiley_slim() {
+  echo -ne '\x1bP;1q"1;1;60;60
+$-
+$-
+$-
+$-
+$-
+$-
+$-
+!15?#1!30N$
+!15?#1!4o!22?!4o$-
+!15?#1!4B!22?!4B$-
+'
+  echo -ne '\x1b\\'
+}
+
+function full() {
+  smiling_smiley
+  sleep .5
+  indifferent_smiley
+  sleep .5
+  sad_smiley
+  sleep .5
+  indifferent_smiley
+  sleep .5
+  smiling_smiley
+}
+
+function slim() {
+  smiling_smiley
+  sleep .5
+  indifferent_smiley_slim
+  sleep .5
+  sad_smiley_slim
+  sleep .5
+  indifferent_smiley_slim
+  sleep .5
+  smiling_smiley_slim
+}
+
+# clear screen and place cursor to 1;10
+echo -ne '\x1b[2J\x1b[10;1H'
+
+# switch sixel scrolling off
+echo -ne '\x1b[?80h'
+
+case "$1" in
+  full ) full ;;
+  slim ) slim ;;
+esac
+
+# re-enable sixel scrolling
+echo -ne '\x1b[?80l'

addons/xterm-addon-image/fixture/textcursor.sh

@@ -0,0 +1,288 @@
+#!/bin/bash
+
+# Test cursor row, column placement after sixel image is sent.
+
+# After a sixel image is displayed, the text cursor is moved to the
+# row of the last sixel cursor position, but the column stays the same
+# as it was before the sixel image was sent.
+#
+# This can be thought of as sixel images always ending with an
+# implicit Graphics Carriage Return (`$`). 
+
+# ADDENDUM: It is not as simple as I thought. When a row of sixels
+# straddles two rows of text, the text cursor can be left on the upper row.
+# It seems up to three lines of pixels may be beneath any words printed.
+#
+# The rule for when this happens is not obvious to me, but can be seen
+# with images of height: 21, 22, 23, 24, 41, 42, 81, 82, 83, 84...
+#
+# My guess:
+# for a sixel image of height h, let a=(h-1)%6 and b=(h-1)%20,
+# then, the text will overlap the image when a>b.
+#
+# If that is the case, then the entire list of heights for which this
+# will happen on the VT340's 480 pixel high screen is:
+#
+#  21  22  23  24   41  42   81  82  83  84
+# 101 102  141 142 143 144  161 162 
+# 201 202 203 204  221 222  261 262 263 264  281 282 
+# 321 322 323 324  341 342  381 382 383 384
+# 401 402  441 442 443 444  461 462
+#
+# Note that there are 48 entries, so that means there's a 10% chance
+# if heights are chosen randomly from 1 to 480. However, if one were
+# to always pick heights which are a multiple of the character cell
+# height (20px), then the chances are 0% as there are no problematic
+# heights divisible by 20. 
+
+
+# Sixel images often do *not* end with a `-` (Graphics New Line = GNL)
+# which sends the sixel cursor down 6 pixels. Any text printed next
+# will potentially overlap the last row of sixels!
+
+# I am not yet positive, but I believe that, in general, applications
+# should send sixel images without a GNL but then send `^J`, a text
+# newline (NL), before displaying more text or graphics.
+
+# IMPORTANT: sometimes neither a graphics nor a text newline is wanted. 
+# For example, if an image is full screen, either newline would cause
+# the top line to scroll off the screen.
+
+#         | Text cursor column | Text cursor row
+# --------|--------------------|-------------------------------------
+# !GNL !NL| Unchanged	       | Overlapping last line of graphics
+# !GNL  NL| Column=1	       | First line immediately after graphic (usually)
+#  GNL !NL| Unchanged	       | _Sometimes_ overlapping graphics
+#  GNL  NL| Column=1	       | First *or* second line after graphic
+
+
+CSI=$'\e['			# Control Sequence Introducer 
+DCS=$'\eP'			# Device Control String
+ST=$'\e\\'			# String Terminator
+
+set_cursor_pos() {
+    # Home, top left is row 1, col 1.
+    local row=$1 col=$2
+    echo -n ${CSI}${row}';'${col}'H'
+}
+
+reset_palette() {
+    # Send DECRSTS to load colors from a Color Table Report
+    echo -n ${DCS}'2$p'
+
+    echo -n "0;2;0;0;0/"        # VT color #0 is black and BG text color
+
+    echo -n "1;2;20;20;79/"	# VT color #1 is blue
+    echo -n "2;2;79;13;13/"	# VT color #2 is red
+    echo -n "3;2;20;79;20/"	# VT color #3 is green
+
+    echo -n "4;2;79;20;79/"	# VT color #4 is magenta
+    echo -n "5;2;20;79;79/"	# VT color #5 is cyan
+    echo -n "6;2;79;79;20/"	# VT color #6 is yellow
+
+    echo -n "7;2;46;46;46/"	# VT color #7 is gray 50% and FG text color
+    echo -n "8;2;26;26;26/"	# VT color #8 is gray 25%
+
+    echo -n "9;2;33;33;59/"	# VT color #9 is pastel blue
+    echo -n "10;2;59;26;26/"	# VT color #10 is pastel red
+    echo -n "11;2;33;59;33/"	# VT color #11 is pastel green
+
+    echo -n "12;2;59;33;59/"	# VT color #12 is pastel magenta
+    echo -n "13;2;33;59;59/"	# VT color #13 is pastel cyan
+    echo -n "14;2;59;59;33/"	# VT color #14 is pastel yellow
+
+    echo -n "15;2;79;79;79"	# VT color #15 is gray 75% and BOLD text color
+
+    echo -n ${ST}		# String Terminator
+}
+
+# Generate square of size w with final graphics new line removed
+square() {
+    # Given a color index number and (optionally) a size, row, and column, 
+    # draw a square with top left corner at (row, column) and of size×size px.
+    # Default size 100×100px  (10cols, 5 rows)
+
+    local -i color=${1:-1}	# Default is color index 1 (blue)
+    local -i size=${2:-100}	# Size in pixels (defaults to 100)
+    local -i row=$3 column=$4	# If set to 0, cursor is not moved
+
+    if [[ row -ne 0 && column -ne 0 ]]; then
+	set_cursor_pos $row $column
+    fi
+
+    # Draw a square of the right color & size 
+    squaresize $color $size
+}
+
+squaresize() {
+    # Helper for square() that uses convert to return a  sixel square of
+    # the right color ($1) and size ($2).
+
+    # Similar to this but with variable size squares:
+    #    echo -n ${DCS}'0;0;0q"1;1;100;100#'${color}'!100~-!100~-!100~-!100~-!100~-!100~-!100~-!100~-!100~-!100~-!100~-!100~-!100~-!100~-!100~-!100~-!100N'${ST}
+
+
+    local color=${1:-1}			# Default color index is 1 (blue)
+    local size=${2:-100}		# Default size is 100x100
+
+    # Get a sixel string 
+    local sq=$(convert -geometry ${size}x${size} xc:black sixel:-)
+
+    # Remove ImageMagick's extraneous Graphic New Line at end of image.
+    sq=${sq%-??}$'\e\\'
+
+    # VT340s always used the same color register for the first sixel
+    # color defined no matter what number it was assigned. That means,
+    # each time we send a new sixel image, the previous one's color
+    # palette gets changed. We don't want squares of all the same
+    # color, so remove the color definition and just use the defaults.
+    sq=${sq/\#0;2;0;0;0/}
+
+    # And finally, switch to the proper index for the color we want.
+    echo -n ${sq//\#0/#${color}}
+}
+
+squaregnl() {
+    # Same as square(), but sends a graphics newline at the end of the sixels.
+    # (Sticks a `-` before the String Terminator, "Esc \")
+    sq=$(square "${@}")
+    echo -n ${sq%??}$'-\e\\'
+}
+
+
+main() {
+    clear
+    reset_palette
+    show_labels
+    neither_graphic_nor_text 96 4 4 31 		# size, color, row, column
+    text_newline_only 96 9 4 1
+    text_newline_only 84 9 4 14
+    graphics_new_line_only 100 1 4 51
+    graphics_new_line_only 96 1 4 64
+    set_cursor_pos 1000 1
+}
+
+
+neither_graphic_nor_text() {
+    # Typically sixel images should not end with a Graphics New Line (GNL)
+    # However, if a text newline isn't sent, there will be overlap.
+
+    local -i size  color  row  column
+    read size color row column <<<"$@"
+
+    set_cursor_pos $((row++)) $column
+    echo -n "Height $size"
+    set_cursor_pos $((row++)) $column
+
+    # Three squares sent as separate sixel images, indented +1 
+    for i in {1..3}; do
+	square $((color++)) $size
+	tput cuf 1
+    done
+
+    echo -n "overlap?"
+}
+
+
+text_newline_only() {
+    # USING A TEXT NEWLINE (NL) after an sixel image that does NOT
+    # have GNL is probably the best way to be on the text line
+    # immediately below the image. However, the text will still
+    # occasionally overlap the last four rows of pixels.
+
+    # Also, if multiple images are intended to be shown, there will
+    # usually be a gap between them when using a text newline.
+
+    # Overlap happens because the height of a text cell is 20 pixels
+    # and the height of a sixel is 6. 
+    # for (h=0; h<480; h++) if ((h-1)%6 > (h-1)%20 ) { h }
+
+    # Let the pixel position of the top of the graphics cursor be 'Yg'
+    # and let the pixel position of the top of the corresponding cell
+    # of text which the text cursor will be placed on be 'Yt'. Note
+    # that Yg is evenly divisible by 6 and Yt, by 20. Taking the
+    # remainder, r, after dividing Yg by 20 tells us how many pixels
+    # down into a row of text the last line of sixels started. When
+    # r==0, the sixels started at the top of the text row.
+
+    # When r = 14, the sixels covered the bottom six pixels on the row
+    # of text. When 14 < r < 20, the sixel line impinged by r - 14
+    # pixels into the text row below and there is a chance the next
+    # text printed will overlap. 
+
+
+    local -i size  color  row  column
+    read size color row column <<<"$@"
+
+    local -i offset
+    offset=$((column-1))
+
+    set_cursor_pos $row 1
+
+    if ((offset)); then tput cuf $((offset)); fi
+    echo "Height $size"
+
+    # Three squares, separated by text new lines and indented +1 
+    for i in {1..3}; do
+	if ((offset)); then tput cuf $offset; fi
+	square $((color++)) $size
+	offset=offset+1
+	echo
+    done
+
+    tput cuf $((offset))
+    echo -n "overlap?"
+}
+
+graphics_new_line_only() {
+    # However, some sixel images end with a `-`, a Graphics New Line.
+    # This can be useful for writing another image starting at the same
+    # column without having to reposition the cursor.
+    #
+    # However, this runs the risk of having occasional overlap.
+
+    local -i size  color  row  column
+    read size color row column <<<"$@"
+
+    set_cursor_pos $((row++)) $column
+    echo -n "Height $size"
+    set_cursor_pos $((row++)) $column
+
+    # Three squares, separated by graphics new lines and indented +1 
+    for i in {1..3}; do
+	squaregnl $((color++))  $size
+	tput cuf 1
+    done
+
+    echo -n "overlap?"
+}
+
+
+show_labels() {
+    set_cursor_pos 1 10
+    echo -n "Should sixel images include a GNL ('-') at the end?"
+
+    set_cursor_pos 3 29
+    echo -n "Neither NL nor GNL"
+    set_cursor_pos 3 1
+    echo -n "Text New Line only"
+    set_cursor_pos 3 51
+    echo -n "Graphics New Line only"
+
+    set_cursor_pos 22 29
+    echo -n "Always overlaps"		# Neither NL nor GNL
+
+    set_cursor_pos 22 3
+    echo -n "Overlaps a little"		# NL only
+    set_cursor_pos 23 3
+    echo -n "    Gaps a little"		# NL only
+
+    set_cursor_pos 22 54
+    echo -n "Overlaps badly"		# GNL only
+    set_cursor_pos 23 54
+    echo -n "Never gaps"		# GNL only
+}
+
+
+main
+

addons/xterm-addon-image/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "xterm-addon-image",
+  "version": "0.6.0",
+  "author": {
+    "name": "The xterm.js authors",
+    "url": "https://xtermjs.org/"
+  },
+  "main": "lib/xterm-addon-image.js",
+  "types": "typings/xterm-addon-image.d.ts",
+  "repository": "https://github.com/xtermjs/xterm.js",
+  "license": "MIT",
+  "keywords": [
+    "terminal",
+    "image",
+    "sixel",
+    "xterm",
+    "xterm.js"
+  ],
+  "scripts": {
+    "prepackage": "../../node_modules/.bin/tsc -p .",
+    "package": "../../node_modules/.bin/webpack",
+    "prepublishOnly": "npm run package"
+  },
+  "peerDependencies": {
+    "xterm": "^5.2.0"
+  },
+  "devDependencies": {
+    "sixel": "^0.16.0",
+    "xterm-wasm-parts": "^0.1.0"
+  }
+}

addons/xterm-addon-image/src/IIPHandler.ts

@@ -0,0 +1,161 @@
+/**
+ * Copyright (c) 2023 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+import { IImageAddonOptions, IOscHandler, IResetHandler, ITerminalExt } from './Types';
+import { ImageRenderer } from './ImageRenderer';
+import { ImageStorage, CELL_SIZE_DEFAULT } from './ImageStorage';
+import Base64Decoder from 'xterm-wasm-parts/lib/base64/Base64Decoder.wasm';
+import { HeaderParser, IHeaderFields, HeaderState } from './IIPHeaderParser';
+import { imageType, UNSUPPORTED_TYPE } from './IIPMetrics';
+
+
+// eslint-disable-next-line
+declare const Buffer: any;
+
+// limit hold memory in base64 decoder
+const KEEP_DATA = 4194304;
+
+// default IIP header values
+const DEFAULT_HEADER: IHeaderFields = {
+  name: 'Unnamed file',
+  size: 0,
+  width: 'auto',
+  height: 'auto',
+  preserveAspectRatio: 1,
+  inline: 0
+};
+
+
+export class IIPHandler implements IOscHandler, IResetHandler {
+  private _aborted = false;
+  private _hp = new HeaderParser();
+  private _header: IHeaderFields = DEFAULT_HEADER;
+  private _dec = new Base64Decoder(KEEP_DATA);
+  private _metrics = UNSUPPORTED_TYPE;
+
+  constructor(
+    private readonly _opts: IImageAddonOptions,
+    private readonly _renderer: ImageRenderer,
+    private readonly _storage: ImageStorage,
+    private readonly _coreTerminal: ITerminalExt
+  ) {}
+
+  public reset(): void {}
+
+  public start(): void {
+    this._aborted = false;
+    this._header = DEFAULT_HEADER;
+    this._metrics  = UNSUPPORTED_TYPE;
+    this._hp.reset();
+  }
+
+  public put(data: Uint32Array, start: number, end: number): void {
+    if (this._aborted) return;
+
+    if (this._hp.state === HeaderState.END) {
+      if (this._dec.put(data, start, end)) {
+        this._dec.release();
+        this._aborted = true;
+      }
+    } else {
+      const dataPos = this._hp.parse(data, start, end);
+      if (dataPos === -1) {
+        this._aborted = true;
+        return;
+      }
+      if (dataPos > 0) {
+        this._header = Object.assign({}, DEFAULT_HEADER, this._hp.fields);
+        if (!this._header.inline || !this._header.size || this._header.size > this._opts.iipSizeLimit) {
+          this._aborted = true;
+          return;
+        }
+        this._dec.init(this._header.size);
+        if (this._dec.put(data, dataPos, end)) {
+          this._dec.release();
+          this._aborted = true;
+        }
+      }
+    }
+  }
+
+  public end(success: boolean): boolean | Promise<boolean> {
+    if (this._aborted) return true;
+
+    let w = 0;
+    let h = 0;
+
+    // early exit condition chain
+    let cond: number | boolean = true;
+    if (cond = success) {
+      if (cond = !this._dec.end()) {
+        this._metrics = imageType(this._dec.data8);
+        if (cond = this._metrics.mime !== 'unsupported') {
+          w = this._metrics.width;
+          h = this._metrics.height;
+          if (cond = w && h && w * h < this._opts.pixelLimit) {
+            [w, h] = this._resize(w, h).map(Math.floor);
+            cond = w && h && w * h < this._opts.pixelLimit;
+          }
+        }
+      }
+    }
+    if (!cond) {
+      this._dec.release();
+      return true;
+    }
+
+    const blob = new Blob([this._dec.data8], { type: this._metrics.mime });
+    this._dec.release();
+
+    if (!window.createImageBitmap) {
+      const url = URL.createObjectURL(blob);
+      const img = new Image();
+      return new Promise<boolean>(r => {
+        img.addEventListener('load', () => {
+          URL.revokeObjectURL(url);
+          const canvas = ImageRenderer.createCanvas(window.document, w, h);
+          canvas.getContext('2d')?.drawImage(img, 0, 0, w, h);
+          this._storage.addImage(canvas);
+          r(true);
+        });
+        img.src = url;
+        // sanity measure to avoid terminal blocking from dangling promise
+        // happens from corrupt data (onload never gets fired)
+        setTimeout(() => r(true), 1000);
+      });
+    }
+    return createImageBitmap(blob, { resizeWidth: w, resizeHeight: h })
+      .then(bm => {
+        this._storage.addImage(bm);
+        return true;
+      });
+  }
+
+  private _resize(w: number, h: number): [number, number] {
+    const cw = this._renderer.dimensions?.css.cell.width || CELL_SIZE_DEFAULT.width;
+    const ch = this._renderer.dimensions?.css.cell.height || CELL_SIZE_DEFAULT.height;
+    const width = this._renderer.dimensions?.css.canvas.width || cw * this._coreTerminal.cols;
+    const height = this._renderer.dimensions?.css.canvas.height || ch * this._coreTerminal.rows;
+
+    const rw = this._dim(this._header.width!, width, cw);
+    const rh = this._dim(this._header.height!, height, ch);
+    if (!rw && !rh) {
+      const wf = width / w;         // TODO: should this respect initial cursor offset?
+      const hf = (height - ch) / h; // TODO: fix offset issues from float cell height
+      const f = Math.min(wf, hf);
+      return f < 1 ? [w * f, h * f] : [w, h];
+    }
+    return !rw
+      ? [w * rh / h, rh]
+      : this._header.preserveAspectRatio || !rw || !rh
+        ? [rw, h * rw / w] : [rw, rh];
+  }
+
+  private _dim(s: string, total: number, cdim: number): number {
+    if (s === 'auto') return 0;
+    if (s.endsWith('%')) return parseInt(s.slice(0, -1)) * total / 100;
+    if (s.endsWith('px')) return parseInt(s.slice(0, -2));
+    return parseInt(s) * cdim;
+  }
+}

addons/xterm-addon-image/src/IIPHeaderParser.test.ts

@@ -0,0 +1,138 @@
+/**
+ * Copyright (c) 2023 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { assert } from 'chai';
+import { HeaderParser, HeaderState, IHeaderFields } from './IIPHeaderParser';
+
+
+const CASES: [string, IHeaderFields][] = [
+  ['File=size=123456;name=dGVzdA==:', {name: 'test', size: 123456}],
+  ['File=size=123456;name=dGVzdA:', {name: 'test', size: 123456}],
+  // utf-8 encoding in name
+  ['File=size=123456;name=w7xtbMOkdXTDnw==:', {name: 'ümläutß', size: 123456}],
+  ['File=size=123456;name=w7xtbMOkdXTDnw:', {name: 'ümläutß', size: 123456}],
+  // full header spec
+  [
+    'File=inline=1;width=10px;height=20%;preserveAspectRatio=1;size=123456;name=w7xtbMOkdXTDnw:',
+    {
+      inline: 1,
+      width: '10px',
+      height: '20%',
+      preserveAspectRatio: 1,
+      size: 123456,
+      name: 'ümläutß'
+    }
+  ],
+  [
+    'File=inline=1;width=auto;height=20;preserveAspectRatio=1;size=123456;name=w7xtbMOkdXTDnw:',
+    {
+      inline: 1,
+      width: 'auto',
+      height: '20',
+      preserveAspectRatio: 1,
+      size: 123456,
+      name: 'ümläutß'
+    }
+  ]
+];
+
+function fromBs(bs: string): Uint32Array {
+  const r = new Uint32Array(bs.length);
+  for (let i = 0; i < r.length; ++i) r[i] = bs.charCodeAt(i);
+  return r;
+}
+
+describe('IIPHeaderParser', () => {
+  it('at once', () => {
+    const hp = new HeaderParser();
+    for (const example of CASES) {
+      hp.reset();
+      const inp = fromBs(example[0]);
+      const res = hp.parse(inp, 0, inp.length);
+      assert.strictEqual(res, inp.length);
+      assert.strictEqual(hp.state, HeaderState.END);
+      assert.deepEqual(hp.fields, example[1]);
+    }
+  });
+  it('bytewise', () => {
+    const hp = new HeaderParser();
+    for (const example of CASES) {
+      hp.reset();
+      const inp = fromBs(example[0]);
+      let pos = 0;
+      let res = -2;
+      while (res === -2 && pos < inp.length) {
+        res = hp.parse(new Uint32Array([inp[pos++]]), 0, 1);
+      }
+      assert.strictEqual(res, 1);
+      assert.strictEqual(hp.state, HeaderState.END);
+      assert.deepEqual(hp.fields, example[1]);
+    }
+  });
+  it('no File= starter', () => {
+    const hp = new HeaderParser();
+    let inp = fromBs('size=123456;name=dGVzdA==:');
+    let res = hp.parse(inp, 0, inp.length);
+    assert.strictEqual(res, -1);
+    hp.reset();
+    inp = fromBs(CASES[0][0]);
+    res = hp.parse(inp, 0, inp.length);
+    assert.strictEqual(res, inp.length);
+    assert.strictEqual(hp.state, HeaderState.END);
+    assert.deepEqual(hp.fields, CASES[0][1]);
+  });
+  it('empty key - error', () => {
+    const hp = new HeaderParser();
+    let inp = fromBs('File=size=123456;=dGVzdA==:');
+    let res = hp.parse(inp, 0, inp.length);
+    assert.strictEqual(res, -1);
+    hp.reset();
+    inp = fromBs(CASES[0][0]);
+    res = hp.parse(inp, 0, inp.length);
+    assert.strictEqual(res, inp.length);
+    assert.strictEqual(hp.state, HeaderState.END);
+    assert.deepEqual(hp.fields, CASES[0][1]);
+  });
+  it('empty size value - set to 0', () => {
+    const hp = new HeaderParser();
+    let inp = fromBs('File=size=;name=dGVzdA==:');
+    let res = hp.parse(inp, 0, inp.length);
+    assert.strictEqual(res, inp.length);
+    assert.strictEqual(hp.state, HeaderState.END);
+    assert.deepEqual(hp.fields, {name: 'test', size: 0});
+    hp.reset();
+    inp = fromBs(CASES[0][0]);
+    res = hp.parse(inp, 0, inp.length);
+    assert.strictEqual(res, inp.length);
+    assert.strictEqual(hp.state, HeaderState.END);
+    assert.deepEqual(hp.fields, CASES[0][1]);
+  });
+  it('empty name value - set to empty string', () => {
+    const hp = new HeaderParser();
+    let inp = fromBs('File=size=123456;name=:');
+    let res = hp.parse(inp, 0, inp.length);
+    assert.strictEqual(res, inp.length);
+    assert.strictEqual(hp.state, HeaderState.END);
+    assert.deepEqual(hp.fields, {name: '', size: 123456});
+    hp.reset();
+    inp = fromBs(CASES[0][0]);
+    res = hp.parse(inp, 0, inp.length);
+    assert.strictEqual(res, inp.length);
+    assert.strictEqual(hp.state, HeaderState.END);
+    assert.deepEqual(hp.fields, CASES[0][1]);
+  });
+  it('empty size value - error', () => {
+    const hp = new HeaderParser();
+    let inp = fromBs('File=inline=1;width=;height=20%;preserveAspectRatio=1;size=123456;name=w7xtbMOkdXTDnw:');
+    let res = hp.parse(inp, 0, inp.length);
+    assert.strictEqual(res, -1);
+    hp.reset();
+    inp = fromBs(CASES[0][0]);
+    res = hp.parse(inp, 0, inp.length);
+    assert.strictEqual(res, inp.length);
+    assert.strictEqual(hp.state, HeaderState.END);
+    assert.deepEqual(hp.fields, CASES[0][1]);
+  });
+});

addons/xterm-addon-image/src/IIPHeaderParser.ts

@@ -0,0 +1,186 @@
+/**
+ * Copyright (c) 2023 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+// eslint-disable-next-line
+declare const Buffer: any;
+
+
+export interface IHeaderFields {
+  // base-64 encoded filename. Defaults to "Unnamed file".
+  name: string;
+  // File size in bytes. The file transfer will be canceled if this size is exceeded.
+  size: number;
+  /**
+   * Optional width and height to render:
+   * - N: N character cells.
+   * - Npx: N pixels.
+   * - N%: N percent of the session's width or height.
+   * - auto: The image's inherent size will be used to determine an appropriate dimension.
+   */
+  width?: string;
+  height?: string;
+  // Optional, defaults to 1 respecting aspect ratio (width takes precedence).
+  preserveAspectRatio?: number;
+  // Optional, defaults to 0. If set to 1, the file will be displayed inline, else downloaded
+  // (download not supported).
+  inline?: number;
+}
+
+export const enum HeaderState {
+  START = 0,
+  ABORT = 1,
+  KEY = 2,
+  VALUE = 3,
+  END = 4
+}
+
+// field value decoders
+
+// ASCII bytes to string
+function toStr(data: Uint32Array): string {
+  let s = '';
+  for (let i = 0; i < data.length; ++i) {
+    s += String.fromCharCode(data[i]);
+  }
+  return s;
+}
+
+// digits to integer
+function toInt(data: Uint32Array): number {
+  let v = 0;
+  for (let i = 0; i < data.length; ++i) {
+    if (data[i] < 48 || data[i] > 57) {
+      throw new Error('illegal char');
+    }
+    v = v * 10 + data[i] - 48;
+  }
+  return v;
+}
+
+// check for correct size entry
+function toSize(data: Uint32Array): string {
+  const v = toStr(data);
+  if (!v.match(/^((auto)|(\d+?((px)|(%)){0,1}))$/)) {
+    throw new Error('illegal size');
+  }
+  return v;
+}
+
+// name is base64 encoded utf-8
+function toName(data: Uint32Array): string {
+  if (typeof Buffer !== 'undefined') {
+    return Buffer.from(toStr(data), 'base64').toString();
+  }
+  const bs = atob(toStr(data));
+  const b = new Uint8Array(bs.length);
+  for (let i = 0; i < b.length; ++i) {
+    b[i] = bs.charCodeAt(i);
+  }
+  return new TextDecoder().decode(b);
+}
+
+const DECODERS: {[key: string]: (v: Uint32Array) => any} = {
+  inline: toInt,
+  size: toInt,
+  name: toName,
+  width: toSize,
+  height: toSize,
+  preserveAspectRatio: toInt
+};
+
+
+const FILE_MARKER = [70, 105, 108, 101];
+const MAX_FIELDCHARS = 1024;
+
+
+export class HeaderParser {
+  public state: HeaderState = HeaderState.START;
+  private _buffer = new Uint32Array(MAX_FIELDCHARS);
+  private _position = 0;
+  private _key = '';
+  public fields: {[key: string]: any} = {};
+
+  public reset(): void {
+    this._buffer.fill(0);
+    this.state = HeaderState.START;
+    this._position = 0;
+    this.fields = {};
+    this._key = '';
+  }
+
+  public parse(data: Uint32Array, start: number, end: number): number {
+    let state = this.state;
+    let pos = this._position;
+    const buffer = this._buffer;
+    if (state === HeaderState.ABORT || state === HeaderState.END) return -1;
+    if (state === HeaderState.START && pos > 6) return -1;
+    for (let i = start; i < end; ++i) {
+      const c = data[i];
+      switch (c) {
+        case 59: // ;
+          if (!this._storeValue(pos)) return this._a();
+          state = HeaderState.KEY;
+          pos = 0;
+          break;
+        case 61: // =
+          if (state === HeaderState.START) {
+            for (let k = 0; k < FILE_MARKER.length; ++k) {
+              if (buffer[k] !== FILE_MARKER[k]) return this._a();
+            }
+            state = HeaderState.KEY;
+            pos = 0;
+          } else if (state === HeaderState.KEY) {
+            if (!this._storeKey(pos)) return this._a();
+            state = HeaderState.VALUE;
+            pos = 0;
+          } else if (state === HeaderState.VALUE) {
+            if (pos >= MAX_FIELDCHARS) return this._a();
+            buffer[pos++] = c;
+          }
+          break;
+        case 58: // :
+          if (state === HeaderState.VALUE) {
+            if (!this._storeValue(pos)) return this._a();
+          }
+          this.state = HeaderState.END;
+          return i + 1;
+        default:
+          if (pos >= MAX_FIELDCHARS) return this._a();
+          buffer[pos++] = c;
+      }
+    }
+    this.state = state;
+    this._position = pos;
+    return -2;
+  }
+
+  private _a(): number {
+    this.state = HeaderState.ABORT;
+    return -1;
+  }
+
+  private _storeKey(pos: number): boolean {
+    const k = toStr(this._buffer.subarray(0, pos));
+    if (k) {
+      this._key = k;
+      this.fields[k] = null;
+      return true;
+    }
+    return false;
+  }
+
+  private _storeValue(pos: number): boolean {
+    if (this._key) {
+      try {
+        const v = this._buffer.slice(0, pos);
+        this.fields[this._key] = DECODERS[this._key] ? DECODERS[this._key](v) : v;
+      } catch (e) {
+        return false;
+      }
+      return true;
+    }
+    return false;
+  }
+}

addons/xterm-addon-image/src/IIPMetrics.test.ts

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2023 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { assert } from 'chai';
+import { imageType, IMetrics } from './IIPMetrics';
+
+// fix missing nodejs decl
+declare const require: (s: string) => any;
+const fs = require('fs');
+
+
+const TEST_IMAGES: [string, IMetrics][] = [
+  ['w3c_home_256.gif', { mime: 'image/gif', width: 72, height: 48 }],
+  ['w3c_home_256.jpg', { mime: 'image/jpeg', width: 72, height: 48 }],
+  ['w3c_home_256.png', { mime: 'image/png', width: 72, height: 48 }],
+  ['w3c_home_2.gif', { mime: 'image/gif', width: 72, height: 48 }],
+  ['w3c_home_2.jpg', { mime: 'image/jpeg', width: 72, height: 48 }],
+  ['w3c_home_2.png', { mime: 'image/png', width: 72, height: 48 }],
+  ['w3c_home_animation.gif', { mime: 'image/gif', width: 72, height: 48 }],
+  ['w3c_home.gif', { mime: 'image/gif', width: 72, height: 48 }],
+  ['w3c_home_gray.gif', { mime: 'image/gif', width: 72, height: 48 }],
+  ['w3c_home_gray.jpg', { mime: 'image/jpeg', width: 72, height: 48 }],
+  ['w3c_home_gray.png', { mime: 'image/png', width: 72, height: 48 }],
+  ['w3c_home.jpg', { mime: 'image/jpeg', width: 72, height: 48 }],
+  ['w3c_home.png', { mime: 'image/png', width: 72, height: 48 }],
+  ['spinfox.png', { mime: 'image/png', width: 148, height: 148 }],
+  ['iphone_hdr_YES.jpg', { mime: 'image/jpeg', width: 3264, height: 2448 }],
+  ['nikon-e950.jpg', { mime: 'image/jpeg', width: 800, height: 600 }],
+  ['agfa-makernotes.jpg', { mime: 'image/jpeg', width: 8, height: 8 }],
+  ['sony-alpha-6000.jpg', { mime: 'image/jpeg', width: 6000, height: 4000 }]
+];
+
+
+describe('IIPMetrics', () => {
+  it('bunch of testimages', () => {
+    for (let i = 0; i < TEST_IMAGES.length; ++i) {
+      const imageData = fs.readFileSync('./addons/xterm-addon-image/fixture/testimages/' + TEST_IMAGES[i][0]);
+      assert.deepStrictEqual(imageType(imageData), TEST_IMAGES[i][1]);
+    }
+  });
+});

addons/xterm-addon-image/src/IIPMetrics.ts

@@ -0,0 +1,81 @@
+/**
+ * Copyright (c) 2023 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+
+export type ImageType = 'image/png' | 'image/jpeg' | 'image/gif' | 'unsupported' | '';
+
+export interface IMetrics {
+  mime: ImageType;
+  width: number;
+  height: number;
+}
+
+export const UNSUPPORTED_TYPE: IMetrics = {
+  mime: 'unsupported',
+  width: 0,
+  height: 0
+};
+
+export function imageType(d: Uint8Array): IMetrics {
+  if (d.length < 24) {
+    return UNSUPPORTED_TYPE;
+  }
+  const d32 = new Uint32Array(d.buffer, d.byteOffset, 6);
+  // PNG: 89 50 4E 47 0D 0A 1A 0A (8 first bytes == magic number for PNG)
+  // + first chunk must be IHDR
+  if (d32[0] === 0x474E5089 && d32[1] === 0x0A1A0A0D && d32[3] === 0x52444849) {
+    return {
+      mime: 'image/png',
+      width: d[16] << 24 | d[17] << 16 | d[18] << 8 | d[19],
+      height: d[20] << 24 | d[21] << 16 | d[22] << 8 | d[23]
+    };
+  }
+  // JPEG: FF D8 FF E0 xx xx JFIF  or  FF D8 FF E1 xx xx Exif 00 00
+  if ((d32[0] === 0xE0FFD8FF || d32[0] === 0xE1FFD8FF)
+    &&  (
+      (d[6] === 0x4a && d[7] === 0x46 && d[8] === 0x49 && d[9] === 0x46)
+        ||  (d[6] === 0x45 && d[7] === 0x78 && d[8] === 0x69 && d[9] === 0x66)
+    )
+  ) {
+    const [width, height] = jpgSize(d);
+    return { mime: 'image/jpeg', width, height };
+  }
+  // GIF: GIF87a or GIF89a
+  if (d32[0] === 0x38464947 && (d[4] === 0x37 || d[4] === 0x39) && d[5] === 0x61) {
+    return {
+      mime: 'image/gif',
+      width: d[7] << 8 | d[6],
+      height: d[9] << 8 | d[8]
+    };
+  }
+  return UNSUPPORTED_TYPE;
+}
+
+function jpgSize(d: Uint8Array): [number, number] {
+  const len = d.length;
+  let i = 4;
+  let blockLength = d[i] << 8 | d[i + 1];
+  while (true) {
+    i += blockLength;
+    if (i >= len) {
+      // exhausted without size info
+      return [0, 0];
+    }
+    if (d[i] !== 0xFF) {
+      return [0, 0];
+    }
+    if (d[i + 1] === 0xC0 || d[i + 1] === 0xC2) {
+      if (i + 8 < len) {
+        return [
+          d[i + 7] << 8 | d[i + 8],
+          d[i + 5] << 8 | d[i + 6]
+        ];
+      }
+      return [0, 0];
+    }
+    i += 2;
+    blockLength = d[i] << 8 | d[i + 1];
+  }
+}

addons/xterm-addon-image/src/ImageAddon.ts

@@ -0,0 +1,317 @@
+/**
+ * Copyright (c) 2020 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { IIPHandler } from './IIPHandler';
+import { ITerminalAddon, IDisposable } from 'xterm';
+import { ImageRenderer } from './ImageRenderer';
+import { ImageStorage, CELL_SIZE_DEFAULT } from './ImageStorage';
+import { SixelHandler } from './SixelHandler';
+import { ITerminalExt, IImageAddonOptions, IResetHandler } from './Types';
+
+
+// default values of addon ctor options
+const DEFAULT_OPTIONS: IImageAddonOptions = {
+  enableSizeReports: true,
+  pixelLimit: 16777216, // limit to 4096 * 4096 pixels
+  sixelSupport: true,
+  sixelScrolling: true,
+  sixelPaletteLimit: 256,
+  sixelSizeLimit: 25000000,
+  storageLimit: 128,
+  showPlaceholder: true,
+  iipSupport: true,
+  iipSizeLimit: 20000000
+};
+
+// max palette size supported by the sixel lib (compile time setting)
+const MAX_SIXEL_PALETTE_SIZE = 4096;
+
+// definitions for _xtermGraphicsAttributes sequence
+const enum GaItem {
+  COLORS = 1,
+  SIXEL_GEO = 2,
+  REGIS_GEO = 3
+}
+const enum GaAction {
+  READ = 1,
+  SET_DEFAULT = 2,
+  SET = 3,
+  READ_MAX = 4
+}
+const enum GaStatus {
+  SUCCESS = 0,
+  ITEM_ERROR = 1,
+  ACTION_ERROR = 2,
+  FAILURE = 3
+}
+
+
+export class ImageAddon implements ITerminalAddon {
+  private _opts: IImageAddonOptions;
+  private _defaultOpts: IImageAddonOptions;
+  private _storage: ImageStorage | undefined;
+  private _renderer: ImageRenderer | undefined;
+  private _disposables: IDisposable[] = [];
+  private _terminal: ITerminalExt | undefined;
+  private _handlers: Map<String, IResetHandler> = new Map();
+
+  constructor(opts?: Partial<IImageAddonOptions>) {
+    this._opts = Object.assign({}, DEFAULT_OPTIONS, opts);
+    this._defaultOpts = Object.assign({}, DEFAULT_OPTIONS, opts);
+  }
+
+  public dispose(): void {
+    for (const obj of this._disposables) {
+      obj.dispose();
+    }
+    this._disposables.length = 0;
+    this._handlers.clear();
+  }
+
+  private _disposeLater(...args: IDisposable[]): void {
+    for (const obj of args) {
+      this._disposables.push(obj);
+    }
+  }
+
+  public activate(terminal: ITerminalExt): void {
+    this._terminal = terminal;
+
+    // internal data structures
+    this._renderer = new ImageRenderer(terminal);
+    this._storage = new ImageStorage(terminal, this._renderer, this._opts);
+
+    // enable size reports
+    if (this._opts.enableSizeReports) {
+      // const windowOptions = terminal.getOption('windowOptions');
+      // windowOptions.getWinSizePixels = true;
+      // windowOptions.getCellSizePixels = true;
+      // windowOptions.getWinSizeChars = true;
+      // terminal.setOption('windowOptions', windowOptions);
+      const windowOps = terminal.options.windowOptions || {};
+      windowOps.getWinSizePixels = true;
+      windowOps.getCellSizePixels = true;
+      windowOps.getWinSizeChars = true;
+      terminal.options.windowOptions = windowOps;
+    }
+
+    this._disposeLater(
+      this._renderer,
+      this._storage,
+
+      // DECSET/DECRST/DA1/XTSMGRAPHICS handlers
+      terminal.parser.registerCsiHandler({ prefix: '?', final: 'h' }, params => this._decset(params)),
+      terminal.parser.registerCsiHandler({ prefix: '?', final: 'l' }, params => this._decrst(params)),
+      terminal.parser.registerCsiHandler({ final: 'c' }, params => this._da1(params)),
+      terminal.parser.registerCsiHandler({ prefix: '?', final: 'S' }, params => this._xtermGraphicsAttributes(params)),
+
+      // render hook
+      terminal.onRender(range => this._storage?.render(range)),
+
+      /**
+       * reset handlers covered:
+       * - DECSTR
+       * - RIS
+       * - Terminal.reset()
+       */
+      terminal.parser.registerCsiHandler({ intermediates: '!', final: 'p' }, () => this.reset()),
+      terminal.parser.registerEscHandler({ final: 'c' }, () => this.reset()),
+      terminal._core._inputHandler.onRequestReset(() => this.reset()),
+
+      // wipe canvas and delete alternate images on buffer switch
+      terminal.buffer.onBufferChange(() => this._storage?.wipeAlternate()),
+
+      // extend images to the right on resize
+      terminal.onResize(metrics => this._storage?.viewportResize(metrics))
+    );
+
+    // SIXEL handler
+    if (this._opts.sixelSupport) {
+      const sixelHandler = new SixelHandler(this._opts, this._storage!, terminal);
+      this._handlers.set('sixel', sixelHandler);
+      this._disposeLater(
+        terminal._core._inputHandler._parser.registerDcsHandler({ final: 'q' }, sixelHandler)
+      );
+    }
+
+    // iTerm IIP handler
+    if (this._opts.iipSupport) {
+      const iipHandler = new IIPHandler(this._opts, this._renderer!, this._storage!, terminal);
+      this._handlers.set('iip', iipHandler);
+      this._disposeLater(
+        terminal._core._inputHandler._parser.registerOscHandler(1337, iipHandler)
+      );
+    }
+  }
+
+  // Note: storageLimit is skipped here to not intoduce a surprising side effect.
+  public reset(): boolean {
+    // reset options customizable by sequences to defaults
+    this._opts.sixelScrolling = this._defaultOpts.sixelScrolling;
+    this._opts.sixelPaletteLimit = this._defaultOpts.sixelPaletteLimit;
+    // also clear image storage
+    this._storage?.reset();
+    // reset protocol handlers
+    for (const handler of this._handlers.values()) {
+      handler.reset();
+    }
+    return false;
+  }
+
+  public get storageLimit(): number {
+    return this._storage?.getLimit() || -1;
+  }
+
+  public set storageLimit(limit: number) {
+    this._storage?.setLimit(limit);
+    this._opts.storageLimit = limit;
+  }
+
+  public get storageUsage(): number {
+    if (this._storage) {
+      return this._storage.getUsage();
+    }
+    return -1;
+  }
+
+  public get showPlaceholder(): boolean {
+    return this._opts.showPlaceholder;
+  }
+
+  public set showPlaceholder(value: boolean) {
+    this._opts.showPlaceholder = value;
+    this._renderer?.showPlaceholder(value);
+  }
+
+  public getImageAtBufferCell(x: number, y: number): HTMLCanvasElement | undefined {
+    return this._storage?.getImageAtBufferCell(x, y);
+  }
+
+  public extractTileAtBufferCell(x: number, y: number): HTMLCanvasElement | undefined {
+    return this._storage?.extractTileAtBufferCell(x, y);
+  }
+
+  private _report(s: string): void {
+    this._terminal?._core.coreService.triggerDataEvent(s);
+  }
+
+  private _decset(params: (number | number[])[]): boolean {
+    for (let i = 0; i < params.length; ++i) {
+      switch (params[i]) {
+        case 80:
+          this._opts.sixelScrolling = false;
+          break;
+      }
+    }
+    return false;
+  }
+
+  private _decrst(params: (number | number[])[]): boolean {
+    for (let i = 0; i < params.length; ++i) {
+      switch (params[i]) {
+        case 80:
+          this._opts.sixelScrolling = true;
+          break;
+      }
+    }
+    return false;
+  }
+
+  // overload DA to return something more appropriate
+  private _da1(params: (number | number[])[]): boolean {
+    if (params[0]) {
+      return true;
+    }
+    // reported features:
+    // 62 - VT220
+    // 4 - SIXEL support
+    // 9 - charsets
+    // 22 - ANSI colors
+    if (this._opts.sixelSupport) {
+      this._report(`\x1b[?62;4;9;22c`);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Implementation of xterm's graphics attribute sequence.
+   *
+   * Supported features:
+   * - read/change palette limits (max 4096 by sixel lib)
+   * - read SIXEL canvas geometry (reports current window canvas or
+   *   squared pixelLimit if canvas > pixel limit)
+   *
+   * Everything else is deactivated.
+   */
+  private _xtermGraphicsAttributes(params: (number | number[])[]): boolean {
+    if (params.length < 2) {
+      return true;
+    }
+    if (params[0] === GaItem.COLORS) {
+      switch (params[1]) {
+        case GaAction.READ:
+          this._report(`\x1b[?${params[0]};${GaStatus.SUCCESS};${this._opts.sixelPaletteLimit}S`);
+          return true;
+        case GaAction.SET_DEFAULT:
+          this._opts.sixelPaletteLimit = this._defaultOpts.sixelPaletteLimit;
+          this._report(`\x1b[?${params[0]};${GaStatus.SUCCESS};${this._opts.sixelPaletteLimit}S`);
+          // also reset protocol handlers for now
+          for (const handler of this._handlers.values()) {
+            handler.reset();
+          }
+          return true;
+        case GaAction.SET:
+          if (params.length > 2 && !(params[2] instanceof Array) && params[2] <= MAX_SIXEL_PALETTE_SIZE) {
+            this._opts.sixelPaletteLimit = params[2];
+            this._report(`\x1b[?${params[0]};${GaStatus.SUCCESS};${this._opts.sixelPaletteLimit}S`);
+          } else {
+            this._report(`\x1b[?${params[0]};${GaStatus.ACTION_ERROR}S`);
+          }
+          return true;
+        case GaAction.READ_MAX:
+          this._report(`\x1b[?${params[0]};${GaStatus.SUCCESS};${MAX_SIXEL_PALETTE_SIZE}S`);
+          return true;
+        default:
+          this._report(`\x1b[?${params[0]};${GaStatus.ACTION_ERROR}S`);
+          return true;
+      }
+    }
+    if (params[0] === GaItem.SIXEL_GEO) {
+      switch (params[1]) {
+        // we only implement read and read_max here
+        case GaAction.READ:
+          let width = this._renderer?.dimensions?.css.canvas.width;
+          let height = this._renderer?.dimensions?.css.canvas.height;
+          if (!width || !height) {
+            // for some reason we have no working image renderer
+            // --> fallback to default cell size
+            const cellSize = CELL_SIZE_DEFAULT;
+            width = (this._terminal?.cols || 80) * cellSize.width;
+            height = (this._terminal?.rows || 24) * cellSize.height;
+          }
+          if (width * height < this._opts.pixelLimit) {
+            this._report(`\x1b[?${params[0]};${GaStatus.SUCCESS};${width.toFixed(0)};${height.toFixed(0)}S`);
+          } else {
+            // if we overflow pixelLimit report that squared instead
+            const x = Math.floor(Math.sqrt(this._opts.pixelLimit));
+            this._report(`\x1b[?${params[0]};${GaStatus.SUCCESS};${x};${x}S`);
+          }
+          return true;
+        case GaAction.READ_MAX:
+          // read_max returns pixelLimit as square area
+          const x = Math.floor(Math.sqrt(this._opts.pixelLimit));
+          this._report(`\x1b[?${params[0]};${GaStatus.SUCCESS};${x};${x}S`);
+          return true;
+        default:
+          this._report(`\x1b[?${params[0]};${GaStatus.ACTION_ERROR}S`);
+          return true;
+      }
+    }
+    // exit with error on ReGIS or any other requests
+    this._report(`\x1b[?${params[0]};${GaStatus.ITEM_ERROR}S`);
+    return true;
+  }
+}

addons/xterm-addon-image/src/ImageRenderer.ts

@@ -0,0 +1,379 @@
+/**
+ * Copyright (c) 2020 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { toRGBA8888 } from 'sixel/lib/Colors';
+import { IDisposable } from 'xterm';
+import { ICellSize, ITerminalExt, IImageSpec, IRenderDimensions, IRenderService } from './Types';
+import { Disposable, MutableDisposable, toDisposable } from 'common/Lifecycle';
+
+
+const PLACEHOLDER_LENGTH = 4096;
+const PLACEHOLDER_HEIGHT = 24;
+
+/**
+ * ImageRenderer - terminal frontend extension:
+ * - provide primitives for canvas, ImageData, Bitmap (static)
+ * - add canvas layer to DOM (browser only for now)
+ * - draw image tiles onRender
+ */
+export class ImageRenderer extends Disposable implements IDisposable {
+  public canvas: HTMLCanvasElement | undefined;
+  private _ctx: CanvasRenderingContext2D | null | undefined;
+  private _placeholder: HTMLCanvasElement | undefined;
+  private _placeholderBitmap: ImageBitmap | undefined;
+  private _optionsRefresh = this.register(new MutableDisposable());
+  private _oldOpen: ((parent: HTMLElement) => void) | undefined;
+  private _renderService: IRenderService | undefined;
+  private _oldSetRenderer: ((renderer: any) => void) | undefined;
+
+  // drawing primitive - canvas
+  public static createCanvas(localDocument: Document | undefined, width: number, height: number): HTMLCanvasElement {
+    /**
+     * NOTE: We normally dont care, from which document the canvas
+     * gets created, so we can fall back to global document,
+     * if the terminal has no document associated yet.
+     * This way early image loads before calling .open keep working
+     * (still discouraged though, as the metrics will be screwed up).
+     * Only the DOM output canvas should be on the terminal's document,
+     * which gets explicitly checked in `insertLayerToDom`.
+     */
+    const canvas = (localDocument || document).createElement('canvas');
+    canvas.width = width | 0;
+    canvas.height = height | 0;
+    return canvas;
+  }
+
+  // drawing primitive - ImageData with optional buffer
+  public static createImageData(ctx: CanvasRenderingContext2D, width: number, height: number, buffer?: ArrayBuffer): ImageData {
+    if (typeof ImageData !== 'function') {
+      const imgData = ctx.createImageData(width, height);
+      if (buffer) {
+        imgData.data.set(new Uint8ClampedArray(buffer, 0, width * height * 4));
+      }
+      return imgData;
+    }
+    return buffer
+      ? new ImageData(new Uint8ClampedArray(buffer, 0, width * height * 4), width, height)
+      : new ImageData(width, height);
+  }
+
+  // drawing primitive - ImageBitmap
+  public static createImageBitmap(img: ImageBitmapSource): Promise<ImageBitmap | undefined> {
+    if (typeof createImageBitmap !== 'function') {
+      return Promise.resolve(undefined);
+    }
+    return createImageBitmap(img);
+  }
+
+
+  constructor(private _terminal: ITerminalExt) {
+    super();
+    this._oldOpen = this._terminal._core.open;
+    this._terminal._core.open = (parent: HTMLElement): void => {
+      this._oldOpen?.call(this._terminal._core, parent);
+      this._open();
+    };
+    if (this._terminal._core.screenElement) {
+      this._open();
+    }
+    // hack to spot fontSize changes
+    this._optionsRefresh.value = this._terminal._core.optionsService.onOptionChange(option => {
+      if (option === 'fontSize') {
+        this.rescaleCanvas();
+        this._renderService?.refreshRows(0, this._terminal.rows);
+      }
+    });
+    this.register(toDisposable(() => {
+      this.removeLayerFromDom();
+      if (this._terminal._core && this._oldOpen) {
+        this._terminal._core.open = this._oldOpen;
+        this._oldOpen = undefined;
+      }
+      if (this._renderService && this._oldSetRenderer) {
+        this._renderService.setRenderer = this._oldSetRenderer;
+        this._oldSetRenderer = undefined;
+      }
+      this._renderService = undefined;
+      this.canvas = undefined;
+      this._ctx = undefined;
+      this._placeholderBitmap?.close();
+      this._placeholderBitmap = undefined;
+      this._placeholder = undefined;
+    }));
+  }
+
+  /**
+   * Enable the placeholder.
+   */
+  public showPlaceholder(value: boolean): void {
+    if (value) {
+      if (!this._placeholder && this.cellSize.height !== -1) {
+        this._createPlaceHolder(Math.max(this.cellSize.height + 1, PLACEHOLDER_HEIGHT));
+      }
+    } else {
+      this._placeholderBitmap?.close();
+      this._placeholderBitmap = undefined;
+      this._placeholder = undefined;
+    }
+    this._renderService?.refreshRows(0, this._terminal.rows);
+  }
+
+  /**
+   * Dimensions of the terminal.
+   * Forwarded from internal render service.
+   */
+  public get dimensions(): IRenderDimensions | undefined {
+    return this._renderService?.dimensions;
+  }
+
+  /**
+   * Current cell size (float).
+   */
+  public get cellSize(): ICellSize {
+    return {
+      width: this.dimensions?.css.cell.width || -1,
+      height: this.dimensions?.css.cell.height || -1
+    };
+  }
+
+  /**
+   * Clear a region of the image layer canvas.
+   */
+  public clearLines(start: number, end: number): void {
+    this._ctx?.clearRect(
+      0,
+      start * (this.dimensions?.css.cell.height || 0),
+      this.dimensions?.css.canvas.width || 0,
+      (++end - start) * (this.dimensions?.css.cell.height || 0)
+    );
+  }
+
+  /**
+   * Clear whole image canvas.
+   */
+  public clearAll(): void {
+    this._ctx?.clearRect(0, 0, this.canvas?.width || 0, this.canvas?.height || 0);
+  }
+
+  /**
+   * Draw neighboring tiles on the image layer canvas.
+   */
+  public draw(imgSpec: IImageSpec, tileId: number, col: number, row: number, count: number = 1): void {
+    if (!this._ctx) {
+      return;
+    }
+    const { width, height } = this.cellSize;
+
+    // Don't try to draw anything, if we cannot get valid renderer metrics.
+    if (width === -1 || height === -1) {
+      return;
+    }
+
+    this._rescaleImage(imgSpec, width, height);
+    const img = imgSpec.actual!;
+    const cols = Math.ceil(img.width / width);
+
+    const sx = (tileId % cols) * width;
+    const sy = Math.floor(tileId / cols) * height;
+    const dx = col * width;
+    const dy = row * height;
+
+    // safari bug: never access image source out of bounds
+    const finalWidth = count * width + sx > img.width ? img.width - sx : count * width;
+    const finalHeight = sy + height > img.height ? img.height - sy : height;
+
+    // Floor all pixel offsets to get stable tile mapping without any overflows.
+    // Note: For not pixel perfect aligned cells like in the DOM renderer
+    // this will move a tile slightly to the top/left (subpixel range, thus ignore it).
+    // FIX #34: avoid striping on displays with pixelDeviceRatio != 1 by ceiling height and width
+    this._ctx.drawImage(
+      img,
+      Math.floor(sx), Math.floor(sy), Math.ceil(finalWidth), Math.ceil(finalHeight),
+      Math.floor(dx), Math.floor(dy), Math.ceil(finalWidth), Math.ceil(finalHeight)
+    );
+  }
+
+  /**
+   * Extract a single tile from an image.
+   */
+  public extractTile(imgSpec: IImageSpec, tileId: number): HTMLCanvasElement | undefined {
+    const { width, height } = this.cellSize;
+    // Don't try to draw anything, if we cannot get valid renderer metrics.
+    if (width === -1 || height === -1) {
+      return;
+    }
+    this._rescaleImage(imgSpec, width, height);
+    const img = imgSpec.actual!;
+    const cols = Math.ceil(img.width / width);
+    const sx = (tileId % cols) * width;
+    const sy = Math.floor(tileId / cols) * height;
+    const finalWidth = width + sx > img.width ? img.width - sx : width;
+    const finalHeight = sy + height > img.height ? img.height - sy : height;
+
+    const canvas = ImageRenderer.createCanvas(this.document, finalWidth, finalHeight);
+    const ctx = canvas.getContext('2d');
+    if (ctx) {
+      ctx.drawImage(
+        img,
+        Math.floor(sx), Math.floor(sy), Math.floor(finalWidth), Math.floor(finalHeight),
+        0, 0, Math.floor(finalWidth), Math.floor(finalHeight)
+      );
+      return canvas;
+    }
+  }
+
+  /**
+   * Draw a line with placeholder on the image layer canvas.
+   */
+  public drawPlaceholder(col: number, row: number, count: number = 1): void {
+    if (this._ctx) {
+      const { width, height } = this.cellSize;
+
+      // Don't try to draw anything, if we cannot get valid renderer metrics.
+      if (width === -1 || height === -1) {
+        return;
+      }
+
+      if (!this._placeholder) {
+        this._createPlaceHolder(Math.max(height + 1, PLACEHOLDER_HEIGHT));
+      } else if (height >= this._placeholder!.height) {
+        this._createPlaceHolder(height + 1);
+      }
+      if (!this._placeholder) return;
+      this._ctx.drawImage(
+        this._placeholderBitmap || this._placeholder!,
+        col * width,
+        (row * height) % 2 ? 0 : 1,  // needs %2 offset correction
+        width * count,
+        height,
+        col * width,
+        row * height,
+        width * count,
+        height
+      );
+    }
+  }
+
+  /**
+   * Rescale image layer canvas if needed.
+   * Checked once from `ImageStorage.render`.
+   */
+  public rescaleCanvas(): void {
+    if (!this.canvas) {
+      return;
+    }
+    if (this.canvas.width !== this.dimensions!.css.canvas.width || this.canvas.height !== this.dimensions!.css.canvas.height) {
+      this.canvas.width = this.dimensions!.css.canvas.width || 0;
+      this.canvas.height = this.dimensions!.css.canvas.height || 0;
+    }
+  }
+
+  /**
+   * Rescale image in storage if needed.
+   */
+  private _rescaleImage(spec: IImageSpec, currentWidth: number, currentHeight: number): void {
+    if (currentWidth === spec.actualCellSize.width && currentHeight === spec.actualCellSize.height) {
+      return;
+    }
+    const { width: originalWidth, height: originalHeight } = spec.origCellSize;
+    if (currentWidth === originalWidth && currentHeight === originalHeight) {
+      spec.actual = spec.orig;
+      spec.actualCellSize.width = originalWidth;
+      spec.actualCellSize.height = originalHeight;
+      return;
+    }
+    const canvas = ImageRenderer.createCanvas(
+      this.document,
+      Math.ceil(spec.orig!.width * currentWidth / originalWidth),
+      Math.ceil(spec.orig!.height * currentHeight / originalHeight)
+    );
+    const ctx = canvas.getContext('2d');
+    if (ctx) {
+      ctx.drawImage(spec.orig!, 0, 0, canvas.width, canvas.height);
+      spec.actual = canvas;
+      spec.actualCellSize.width = currentWidth;
+      spec.actualCellSize.height = currentHeight;
+    }
+  }
+
+  /**
+   * Lazy init for the renderer.
+   */
+  private _open(): void {
+    this._renderService = this._terminal._core._renderService;
+    this._oldSetRenderer = this._renderService.setRenderer.bind(this._renderService);
+    this._renderService.setRenderer = (renderer: any) => {
+      this.removeLayerFromDom();
+      this._oldSetRenderer?.call(this._renderService, renderer);
+    };
+  }
+
+  public insertLayerToDom(): void {
+    // make sure that the terminal is attached to a document and to DOM
+    if (this.document && this._terminal._core.screenElement) {
+      if (!this.canvas) {
+        this.canvas = ImageRenderer.createCanvas(
+          this.document, this.dimensions?.css.canvas.width || 0,
+          this.dimensions?.css.canvas.height || 0
+        );
+        this.canvas.classList.add('xterm-image-layer');
+        this._terminal._core.screenElement.appendChild(this.canvas);
+        this._ctx = this.canvas.getContext('2d', { alpha: true, desynchronized: true });
+        this.clearAll();
+      }
+    } else {
+      console.warn('image addon: cannot insert output canvas to DOM, missing document or screenElement');
+    }
+  }
+
+  public removeLayerFromDom(): void {
+    if (this.canvas) {
+      this._ctx = undefined;
+      this.canvas.remove();
+      this.canvas = undefined;
+    }
+  }
+
+  private _createPlaceHolder(height: number = PLACEHOLDER_HEIGHT): void {
+    this._placeholderBitmap?.close();
+    this._placeholderBitmap = undefined;
+
+    // create blueprint to fill placeholder with
+    const bWidth = 32;  // must be 2^n
+    const blueprint = ImageRenderer.createCanvas(this.document, bWidth, height);
+    const ctx = blueprint.getContext('2d', { alpha: false });
+    if (!ctx) return;
+    const imgData = ImageRenderer.createImageData(ctx, bWidth, height);
+    const d32 = new Uint32Array(imgData.data.buffer);
+    const black = toRGBA8888(0, 0, 0);
+    const white = toRGBA8888(255, 255, 255);
+    d32.fill(black);
+    for (let y = 0; y < height; ++y) {
+      const shift = y % 2;
+      const offset = y * bWidth;
+      for (let x = 0; x < bWidth; x += 2) {
+        d32[offset + x + shift] = white;
+      }
+    }
+    ctx.putImageData(imgData, 0, 0);
+
+    // create placeholder line, width aligned to blueprint width
+    const width = (screen.width + bWidth - 1) & ~(bWidth - 1) || PLACEHOLDER_LENGTH;
+    this._placeholder = ImageRenderer.createCanvas(this.document, width, height);
+    const ctx2 = this._placeholder.getContext('2d', { alpha: false });
+    if (!ctx2) {
+      this._placeholder = undefined;
+      return;
+    }
+    for (let i = 0; i < width; i += bWidth) {
+      ctx2.drawImage(blueprint, i, 0);
+    }
+    ImageRenderer.createImageBitmap(this._placeholder).then(bitmap => this._placeholderBitmap = bitmap);
+  }
+
+  public get document(): Document | undefined {
+    return this._terminal._core._coreBrowserService?.window.document;
+  }
+}

addons/xterm-addon-image/src/ImageStorage.ts

@@ -0,0 +1,592 @@
+/**
+ * Copyright (c) 2020 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { IDisposable } from 'xterm';
+import { ImageRenderer } from './ImageRenderer';
+import { ITerminalExt, IExtendedAttrsImage, IImageAddonOptions, IImageSpec, IBufferLineExt, BgFlags, Cell, Content, ICellSize, ExtFlags, Attributes, UnderlineStyle } from './Types';
+
+
+// fallback default cell size
+export const CELL_SIZE_DEFAULT: ICellSize = {
+  width: 7,
+  height: 14
+};
+
+/**
+ * Extend extended attribute to also hold image tile information.
+ *
+ * Object definition is copied from base repo to fully mimick its behavior.
+ * Image data is added as additional public properties `imageId` and `tileId`.
+ */
+class ExtendedAttrsImage implements IExtendedAttrsImage {
+  private _ext: number = 0;
+  public get ext(): number {
+    if (this._urlId) {
+      return (
+        (this._ext & ~ExtFlags.UNDERLINE_STYLE) |
+        (this.underlineStyle << 26)
+      );
+    }
+    return this._ext;
+  }
+  public set ext(value: number) { this._ext = value; }
+
+  public get underlineStyle(): UnderlineStyle {
+    // Always return the URL style if it has one
+    if (this._urlId) {
+      return UnderlineStyle.DASHED;
+    }
+    return (this._ext & ExtFlags.UNDERLINE_STYLE) >> 26;
+  }
+  public set underlineStyle(value: UnderlineStyle) {
+    this._ext &= ~ExtFlags.UNDERLINE_STYLE;
+    this._ext |= (value << 26) & ExtFlags.UNDERLINE_STYLE;
+  }
+
+  public get underlineColor(): number {
+    return this._ext & (Attributes.CM_MASK | Attributes.RGB_MASK);
+  }
+  public set underlineColor(value: number) {
+    this._ext &= ~(Attributes.CM_MASK | Attributes.RGB_MASK);
+    this._ext |= value & (Attributes.CM_MASK | Attributes.RGB_MASK);
+  }
+
+  private _urlId: number = 0;
+  public get urlId(): number {
+    return this._urlId;
+  }
+  public set urlId(value: number) {
+    this._urlId = value;
+  }
+
+  constructor(
+    ext: number = 0,
+    urlId: number = 0,
+    public imageId = -1,
+    public tileId = -1
+  ) {
+    this._ext = ext;
+    this._urlId = urlId;
+  }
+
+  public clone(): IExtendedAttrsImage {
+    /**
+     * Technically we dont need a clone variant of ExtendedAttrsImage,
+     * as we never clone a cell holding image data.
+     * Note: Clone is only meant to be used by the InputHandler for
+     * sticky attributes, which is never the case for image data.
+     * We still provide a proper clone method to reflect the full ext attr
+     * state in case there are future use cases for clone.
+     */
+    return new ExtendedAttrsImage(this._ext, this._urlId, this.imageId, this.tileId);
+  }
+
+  public isEmpty(): boolean {
+    return this.underlineStyle === UnderlineStyle.NONE && this._urlId === 0 && this.imageId === -1;
+  }
+}
+const EMPTY_ATTRS = new ExtendedAttrsImage();
+
+
+/**
+ * ImageStorage - extension of CoreTerminal:
+ * - hold image data
+ * - write/read image data to/from buffer
+ *
+ * TODO: image composition for overwrites
+ */
+export class ImageStorage implements IDisposable {
+  // storage
+  private _images: Map<number, IImageSpec> = new Map();
+  // last used id
+  private _lastId = 0;
+  // last evicted id
+  private _lowestId = 0;
+  // whether a full clear happened before
+  private _fullyCleared = false;
+  // whether render should do a full clear
+  private _needsFullClear = false;
+  // hard limit of stored pixels (fallback limit of 10 MB)
+  private _pixelLimit: number = 2500000;
+
+  private _viewportMetrics: { cols: number, rows: number };
+
+  constructor(
+    private _terminal: ITerminalExt,
+    private _renderer: ImageRenderer,
+    private _opts: IImageAddonOptions
+  ) {
+    try {
+      this.setLimit(this._opts.storageLimit);
+    } catch (e: any) {
+      console.error(e.message);
+      console.warn(`storageLimit is set to ${this.getLimit()} MB`);
+    }
+    this._viewportMetrics = {
+      cols: this._terminal.cols,
+      rows: this._terminal.rows
+    };
+  }
+
+  public dispose(): void {
+    this.reset();
+  }
+
+  public reset(): void {
+    for (const spec of this._images.values()) {
+      spec.marker?.dispose();
+    }
+    // NOTE: marker.dispose above already calls ImageBitmap.close
+    // therefore we can just wipe the map here
+    this._images.clear();
+    this._renderer.clearAll();
+  }
+
+  public getLimit(): number {
+    return this._pixelLimit * 4 / 1000000;
+  }
+
+  public setLimit(value: number): void {
+    if (value < 0.5 || value > 1000) {
+      throw RangeError('invalid storageLimit, should be at least 0.5 MB and not exceed 1G');
+    }
+    this._pixelLimit = (value / 4 * 1000000) >>> 0;
+    this._evictOldest(0);
+  }
+
+  public getUsage(): number {
+    return this._getStoredPixels() * 4 / 1000000;
+  }
+
+  private _getStoredPixels(): number {
+    let storedPixels = 0;
+    for (const spec of this._images.values()) {
+      if (spec.orig) {
+        storedPixels += spec.orig.width * spec.orig.height;
+        if (spec.actual && spec.actual !== spec.orig) {
+          storedPixels += spec.actual.width * spec.actual.height;
+        }
+      }
+    }
+    return storedPixels;
+  }
+
+  private _delImg(id: number): void {
+    const spec = this._images.get(id);
+    this._images.delete(id);
+    // FIXME: really ugly workaround to get bitmaps deallocated :(
+    if (spec && window.ImageBitmap && spec.orig instanceof ImageBitmap) {
+      spec.orig.close();
+    }
+  }
+
+  /**
+   * Wipe canvas and images on alternate buffer.
+   */
+  public wipeAlternate(): void {
+    // remove all alternate tagged images
+    const zero = [];
+    for (const [id, spec] of this._images.entries()) {
+      if (spec.bufferType === 'alternate') {
+        spec.marker?.dispose();
+        zero.push(id);
+      }
+    }
+    for (const id of zero) {
+      this._delImg(id);
+    }
+    // mark canvas to be wiped on next render
+    this._needsFullClear = true;
+    this._fullyCleared = false;
+  }
+
+  /**
+   * Only advance text cursor.
+   * This is an edge case from empty sixels carrying only a height but no pixels.
+   * Partially fixes https://github.com/jerch/xterm-addon-image/issues/37.
+   */
+  public advanceCursor(height: number): void {
+    if (this._opts.sixelScrolling) {
+      let cellSize = this._renderer.cellSize;
+      if (cellSize.width === -1 || cellSize.height === -1) {
+        cellSize = CELL_SIZE_DEFAULT;
+      }
+      const rows = Math.ceil(height / cellSize.height);
+      for (let i = 1; i < rows; ++i) {
+        this._terminal._core._inputHandler.lineFeed();
+      }
+    }
+  }
+
+  /**
+   * Method to add an image to the storage.
+   */
+  public addImage(img: HTMLCanvasElement | ImageBitmap): void {
+    // never allow storage to exceed memory limit
+    this._evictOldest(img.width * img.height);
+
+    // calc rows x cols needed to display the image
+    let cellSize = this._renderer.cellSize;
+    if (cellSize.width === -1 || cellSize.height === -1) {
+      cellSize = CELL_SIZE_DEFAULT;
+    }
+    const cols = Math.ceil(img.width / cellSize.width);
+    const rows = Math.ceil(img.height / cellSize.height);
+
+    const imageId = ++this._lastId;
+
+    const buffer = this._terminal._core.buffer;
+    const termCols = this._terminal.cols;
+    const termRows = this._terminal.rows;
+    const originX = buffer.x;
+    const originY = buffer.y;
+    let offset = originX;
+    let tileCount = 0;
+
+    if (!this._opts.sixelScrolling) {
+      buffer.x = 0;
+      buffer.y = 0;
+      offset = 0;
+    }
+
+    this._terminal._core._inputHandler._dirtyRowTracker.markDirty(buffer.y);
+    for (let row = 0; row < rows; ++row) {
+      const line = buffer.lines.get(buffer.y + buffer.ybase);
+      for (let col = 0; col < cols; ++col) {
+        if (offset + col >= termCols) break;
+        this._writeToCell(line as IBufferLineExt, offset + col, imageId, row * cols + col);
+        tileCount++;
+      }
+      if (this._opts.sixelScrolling) {
+        if (row < rows - 1) this._terminal._core._inputHandler.lineFeed();
+      } else {
+        if (++buffer.y >= termRows) break;
+      }
+      buffer.x = offset;
+    }
+    this._terminal._core._inputHandler._dirtyRowTracker.markDirty(buffer.y);
+
+    // cursor positioning modes
+    if (this._opts.sixelScrolling) {
+      buffer.x = offset;
+    } else {
+      buffer.x = originX;
+      buffer.y = originY;
+    }
+
+    // deleted images with zero tile count
+    const zero = [];
+    for (const [id, spec] of this._images.entries()) {
+      if (spec.tileCount < 1) {
+        spec.marker?.dispose();
+        zero.push(id);
+      }
+    }
+    for (const id of zero) {
+      this._delImg(id);
+    }
+
+    // eviction marker:
+    // delete the image when the marker gets disposed
+    const endMarker = this._terminal.registerMarker(0);
+    endMarker?.onDispose(() => {
+      const spec = this._images.get(imageId);
+      if (spec) {
+        this._delImg(imageId);
+      }
+    });
+
+    // since markers do not work on alternate for some reason,
+    // we evict images here manually
+    if (this._terminal.buffer.active.type === 'alternate') {
+      this._evictOnAlternate();
+    }
+
+    // create storage entry
+    const imgSpec: IImageSpec = {
+      orig: img,
+      origCellSize: cellSize,
+      actual: img,
+      actualCellSize: { ...cellSize },  // clone needed, since later modified
+      marker: endMarker || undefined,
+      tileCount,
+      bufferType: this._terminal.buffer.active.type
+    };
+
+    // finally add the image
+    this._images.set(imageId, imgSpec);
+  }
+
+
+  /**
+   * Render method. Collects buffer information and triggers
+   * canvas updates.
+   */
+  // TODO: Should we move this to the ImageRenderer?
+  public render(range: { start: number, end: number }): void {
+    // setup image canvas in case we have none yet, but have images in store
+    if (!this._renderer.canvas && this._images.size) {
+      this._renderer.insertLayerToDom();
+      // safety measure - in case we cannot spawn a canvas at all, just exit
+      if (!this._renderer.canvas) {
+        return;
+      }
+    }
+    // rescale if needed
+    this._renderer.rescaleCanvas();
+    // exit early if we dont have any images to test for
+    if (!this._images.size) {
+      if (!this._fullyCleared) {
+        this._renderer.clearAll();
+        this._fullyCleared = true;
+        this._needsFullClear = false;
+      }
+      if (this._renderer.canvas) {
+        this._renderer.removeLayerFromDom();
+      }
+      return;
+    }
+
+    // buffer switches force a full clear
+    if (this._needsFullClear) {
+      this._renderer.clearAll();
+      this._fullyCleared = true;
+      this._needsFullClear = false;
+    }
+
+    const { start, end } = range;
+    const buffer = this._terminal._core.buffer;
+    const cols = this._terminal._core.cols;
+
+    // clear drawing area
+    this._renderer.clearLines(start, end);
+
+    // walk all cells in viewport and draw tiles found
+    for (let row = start; row <= end; ++row) {
+      const line = buffer.lines.get(row + buffer.ydisp) as IBufferLineExt;
+      if (!line) return;
+      for (let col = 0; col < cols; ++col) {
+        if (line.getBg(col) & BgFlags.HAS_EXTENDED) {
+          let e: IExtendedAttrsImage = line._extendedAttrs[col] || EMPTY_ATTRS;
+          const imageId = e.imageId;
+          if (imageId === undefined || imageId === -1) {
+            continue;
+          }
+          const imgSpec = this._images.get(imageId);
+          if (e.tileId !== -1) {
+            const startTile = e.tileId;
+            const startCol = col;
+            let count = 1;
+            /**
+             * merge tiles to the right into a single draw call, if:
+             * - not at end of line
+             * - cell has same image id
+             * - cell has consecutive tile id
+             */
+            while (
+              ++col < cols
+              && (line.getBg(col) & BgFlags.HAS_EXTENDED)
+              && (e = line._extendedAttrs[col] || EMPTY_ATTRS)
+              && (e.imageId === imageId)
+              && (e.tileId === startTile + count)
+            ) {
+              count++;
+            }
+            col--;
+            if (imgSpec) {
+              if (imgSpec.actual) {
+                this._renderer.draw(imgSpec, startTile, startCol, row, count);
+              }
+            } else if (this._opts.showPlaceholder) {
+              this._renderer.drawPlaceholder(startCol, row, count);
+            }
+            this._fullyCleared = false;
+          }
+        }
+      }
+    }
+  }
+
+  public viewportResize(metrics: { cols: number, rows: number }): void {
+    // exit early if we have nothing in storage
+    if (!this._images.size) {
+      this._viewportMetrics = metrics;
+      return;
+    }
+
+    // handle only viewport width enlargements, exit all other cases
+    // TODO: needs patch for tile counter
+    if (this._viewportMetrics.cols >= metrics.cols) {
+      this._viewportMetrics = metrics;
+      return;
+    }
+
+    // walk scrollbuffer at old col width to find all possible expansion matches
+    const buffer = this._terminal._core.buffer;
+    const rows = buffer.lines.length;
+    const oldCol = this._viewportMetrics.cols - 1;
+    for (let row = 0; row < rows; ++row) {
+      const line = buffer.lines.get(row) as IBufferLineExt;
+      if (line.getBg(oldCol) & BgFlags.HAS_EXTENDED) {
+        const e: IExtendedAttrsImage = line._extendedAttrs[oldCol] || EMPTY_ATTRS;
+        const imageId = e.imageId;
+        if (imageId === undefined || imageId === -1) {
+          continue;
+        }
+        const imgSpec = this._images.get(imageId);
+        if (!imgSpec) {
+          continue;
+        }
+        // found an image tile at oldCol, check if it qualifies for right exapansion
+        const tilesPerRow = Math.ceil((imgSpec.actual?.width || 0) / imgSpec.actualCellSize.width);
+        if ((e.tileId % tilesPerRow) + 1 >= tilesPerRow) {
+          continue;
+        }
+        // expand only if right side is empty (nothing got wrapped from below)
+        let hasData = false;
+        for (let rightCol = oldCol + 1; rightCol > metrics.cols; ++rightCol) {
+          if (line._data[rightCol * Cell.SIZE + Cell.CONTENT] & Content.HAS_CONTENT_MASK) {
+            hasData = true;
+            break;
+          }
+        }
+        if (hasData) {
+          continue;
+        }
+        // do right expansion on terminal buffer
+        const end = Math.min(metrics.cols, tilesPerRow - (e.tileId % tilesPerRow) + oldCol);
+        let lastTile = e.tileId;
+        for (let expandCol = oldCol + 1; expandCol < end; ++expandCol) {
+          this._writeToCell(line as IBufferLineExt, expandCol, imageId, ++lastTile);
+          imgSpec.tileCount++;
+        }
+      }
+    }
+    // store new viewport metrics
+    this._viewportMetrics = metrics;
+  }
+
+  /**
+   * Retrieve original canvas at buffer position.
+   */
+  public getImageAtBufferCell(x: number, y: number): HTMLCanvasElement | undefined {
+    const buffer = this._terminal._core.buffer;
+    const line = buffer.lines.get(y) as IBufferLineExt;
+    if (line && line.getBg(x) & BgFlags.HAS_EXTENDED) {
+      const e: IExtendedAttrsImage = line._extendedAttrs[x] || EMPTY_ATTRS;
+      if (e.imageId && e.imageId !== -1) {
+        const orig = this._images.get(e.imageId)?.orig;
+        if (window.ImageBitmap && orig instanceof ImageBitmap) {
+          const canvas = ImageRenderer.createCanvas(window.document, orig.width, orig.height);
+          canvas.getContext('2d')?.drawImage(orig, 0, 0, orig.width, orig.height);
+          return canvas;
+        }
+        return orig as HTMLCanvasElement;
+      }
+    }
+  }
+
+  /**
+   * Extract active single tile at buffer position.
+   */
+  public extractTileAtBufferCell(x: number, y: number): HTMLCanvasElement | undefined {
+    const buffer = this._terminal._core.buffer;
+    const line = buffer.lines.get(y) as IBufferLineExt;
+    if (line && line.getBg(x) & BgFlags.HAS_EXTENDED) {
+      const e: IExtendedAttrsImage = line._extendedAttrs[x] || EMPTY_ATTRS;
+      if (e.imageId && e.imageId !== -1 && e.tileId !== -1) {
+        const spec = this._images.get(e.imageId);
+        if (spec) {
+          return this._renderer.extractTile(spec, e.tileId);
+        }
+      }
+    }
+  }
+
+  // TODO: Do we need some blob offloading tricks here to avoid early eviction?
+  // also see https://stackoverflow.com/questions/28307789/is-there-any-limitation-on-javascript-max-blob-size
+  private _evictOldest(room: number): number {
+    const used = this._getStoredPixels();
+    let current = used;
+    while (this._pixelLimit < current + room && this._images.size) {
+      const spec = this._images.get(++this._lowestId);
+      if (spec && spec.orig) {
+        current -= spec.orig.width * spec.orig.height;
+        if (spec.actual && spec.orig !== spec.actual) {
+          current -= spec.actual.width * spec.actual.height;
+        }
+        spec.marker?.dispose();
+        this._delImg(this._lowestId);
+      }
+    }
+    return used - current;
+  }
+
+  private _writeToCell(line: IBufferLineExt, x: number, imageId: number, tileId: number): void {
+    if (line._data[x * Cell.SIZE + Cell.BG] & BgFlags.HAS_EXTENDED) {
+      const old = line._extendedAttrs[x];
+      if (old) {
+        if (old.imageId !== undefined) {
+          // found an old ExtendedAttrsImage, since we know that
+          // they are always isolated instances (single cell usage),
+          // we can re-use it and just update their id entries
+          const oldSpec = this._images.get(old.imageId);
+          if (oldSpec) {
+            // early eviction for in-viewport overwrites
+            oldSpec.tileCount--;
+          }
+          old.imageId = imageId;
+          old.tileId = tileId;
+          return;
+        }
+        // found a plain ExtendedAttrs instance, clone it to new entry
+        line._extendedAttrs[x] = new ExtendedAttrsImage(old.ext, old.urlId, imageId, tileId);
+        return;
+      }
+    }
+    // fall-through: always create new ExtendedAttrsImage entry
+    line._data[x * Cell.SIZE + Cell.BG] |= BgFlags.HAS_EXTENDED;
+    line._extendedAttrs[x] = new ExtendedAttrsImage(0, 0, imageId, tileId);
+  }
+
+  private _evictOnAlternate(): void {
+    // nullify tile count of all images on alternate buffer
+    for (const spec of this._images.values()) {
+      if (spec.bufferType === 'alternate') {
+        spec.tileCount = 0;
+      }
+    }
+    // re-count tiles on whole buffer
+    const buffer = this._terminal._core.buffer;
+    for (let y = 0; y < this._terminal.rows; ++y) {
+      const line = buffer.lines.get(y) as IBufferLineExt;
+      if (!line) {
+        continue;
+      }
+      for (let x = 0; x < this._terminal.cols; ++x) {
+        if (line._data[x * Cell.SIZE + Cell.BG] & BgFlags.HAS_EXTENDED) {
+          const imgId = line._extendedAttrs[x]?.imageId;
+          if (imgId) {
+            const spec = this._images.get(imgId);
+            if (spec) {
+              spec.tileCount++;
+            }
+          }
+        }
+      }
+    }
+    // deleted images with zero tile count
+    const zero = [];
+    for (const [id, spec] of this._images.entries()) {
+      if (spec.bufferType === 'alternate' && !spec.tileCount) {
+        spec.marker?.dispose();
+        zero.push(id);
+      }
+    }
+    for (const id of zero) {
+      this._delImg(id);
+    }
+  }
+}

addons/xterm-addon-image/src/SixelHandler.ts

@@ -0,0 +1,151 @@
+/**
+ * Copyright (c) 2020, 2023 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { ImageStorage } from './ImageStorage';
+import { IDcsHandler, IParams, IImageAddonOptions, ITerminalExt, AttributeData, IResetHandler, ReadonlyColorSet } from './Types';
+import { toRGBA8888, BIG_ENDIAN, PALETTE_ANSI_256, PALETTE_VT340_COLOR } from 'sixel/lib/Colors';
+import { RGBA8888 } from 'sixel/lib/Types';
+import { ImageRenderer } from './ImageRenderer';
+
+import { DecoderAsync, Decoder } from 'sixel/lib/Decoder';
+
+// always free decoder ressources after decoding if it exceeds this limit
+const MEM_PERMA_LIMIT = 4194304; // 1024 pixels * 1024 pixels * 4 channels = 4MB
+
+// custom default palette: VT340 (lower 16 colors) + ANSI256 (up to 256) + zeroed (up to 4096)
+const DEFAULT_PALETTE = PALETTE_ANSI_256;
+DEFAULT_PALETTE.set(PALETTE_VT340_COLOR);
+
+
+export class SixelHandler implements IDcsHandler, IResetHandler {
+  private _size = 0;
+  private _aborted = false;
+  private _dec: Decoder | undefined;
+
+  constructor(
+    private readonly _opts: IImageAddonOptions,
+    private readonly _storage: ImageStorage,
+    private readonly _coreTerminal: ITerminalExt
+  ) {
+    DecoderAsync({
+      memoryLimit: this._opts.pixelLimit * 4,
+      palette: DEFAULT_PALETTE,
+      paletteLimit: this._opts.sixelPaletteLimit
+    }).then(d => this._dec = d);
+  }
+
+  public reset(): void {
+    /**
+     * reset sixel decoder to defaults:
+     * - release all memory
+     * - nullify palette (4096)
+     * - apply default palette (256)
+     */
+    if (this._dec) {
+      this._dec.release();
+      // FIXME: missing interface on decoder to nullify full palette
+      (this._dec as any)._palette.fill(0);
+      this._dec.init(0, DEFAULT_PALETTE, this._opts.sixelPaletteLimit);
+    }
+  }
+
+  public hook(params: IParams): void {
+    this._size = 0;
+    this._aborted = false;
+    if (this._dec) {
+      const fillColor = params.params[1] === 1 ? 0 : extractActiveBg(
+        this._coreTerminal._core._inputHandler._curAttrData,
+        this._coreTerminal._core._themeService?.colors);
+      this._dec.init(fillColor, null, this._opts.sixelPaletteLimit);
+    }
+  }
+
+  public put(data: Uint32Array, start: number, end: number): void {
+    if (this._aborted || !this._dec) {
+      return;
+    }
+    this._size += end - start;
+    if (this._size > this._opts.sixelSizeLimit) {
+      console.warn(`SIXEL: too much data, aborting`);
+      this._aborted = true;
+      this._dec.release();
+      return;
+    }
+    try {
+      this._dec.decode(data, start, end);
+    } catch (e) {
+      console.warn(`SIXEL: error while decoding image - ${e}`);
+      this._aborted = true;
+      this._dec.release();
+    }
+  }
+
+  public unhook(success: boolean): boolean | Promise<boolean> {
+    if (this._aborted || !success || !this._dec) {
+      return true;
+    }
+
+    const width = this._dec.width;
+    const height = this._dec.height;
+
+    // partial fix for https://github.com/jerch/xterm-addon-image/issues/37
+    if (!width || ! height) {
+      if (height) {
+        this._storage.advanceCursor(height);
+      }
+      return true;
+    }
+
+    const canvas = ImageRenderer.createCanvas(undefined, width, height);
+    canvas.getContext('2d')?.putImageData(new ImageData(this._dec.data8, width, height), 0, 0);
+    if (this._dec.memoryUsage > MEM_PERMA_LIMIT) {
+      this._dec.release();
+    }
+    this._storage.addImage(canvas);
+    return true;
+  }
+}
+
+
+/**
+ * Some helpers to extract current terminal colors.
+ */
+
+// get currently active background color from terminal
+// also respect INVERSE setting
+function extractActiveBg(attr: AttributeData, colors: ReadonlyColorSet | undefined): RGBA8888 {
+  let bg = 0;
+  if (!colors) {
+    // FIXME: theme service is prolly not available yet,
+    // happens if .open() was not called yet (bug in core?)
+    return bg;
+  }
+  if (attr.isInverse()) {
+    if (attr.isFgDefault()) {
+      bg = convertLe(colors.foreground.rgba);
+    } else if (attr.isFgRGB()) {
+      const t = (attr.constructor as typeof AttributeData).toColorRGB(attr.getFgColor());
+      bg = toRGBA8888(...t);
+    } else {
+      bg = convertLe(colors.ansi[attr.getFgColor()].rgba);
+    }
+  } else {
+    if (attr.isBgDefault()) {
+      bg = convertLe(colors.background.rgba);
+    } else if (attr.isBgRGB()) {
+      const t = (attr.constructor as typeof AttributeData).toColorRGB(attr.getBgColor());
+      bg = toRGBA8888(...t);
+    } else {
+      bg = convertLe(colors.ansi[attr.getBgColor()].rgba);
+    }
+  }
+  return bg;
+}
+
+// rgba values on the color managers are always in BE, thus convert to LE
+function convertLe(color: number): RGBA8888 {
+  if (BIG_ENDIAN) return color;
+  return (color & 0xFF) << 24 | (color >>> 8 & 0xFF) << 16 | (color >>> 16 & 0xFF) << 8 | color >>> 24 & 0xFF;
+}

addons/xterm-addon-image/src/Types.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) 2020 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { IDisposable, IMarker, Terminal } from 'xterm';
+
+// private imports from base repo we build against
+import { Attributes, BgFlags, Content, ExtFlags, UnderlineStyle } from 'common/buffer/Constants';
+import type { AttributeData } from 'common/buffer/AttributeData';
+import type { IParams, IDcsHandler, IOscHandler, IEscapeSequenceParser } from 'common/parser/Types';
+import type { IBufferLine, IExtendedAttrs, IInputHandler } from 'common/Types';
+import type { ITerminal, ReadonlyColorSet } from 'browser/Types';
+import type { IRenderDimensions } from 'browser/renderer/shared/Types';
+import type { ICoreBrowserService, IRenderService, IThemeService } from 'browser/services/Services';
+
+export const enum Cell {
+  CONTENT = 0,  // codepoint and wcwidth information (enum Content)
+  FG = 1,       // foreground color in lower 3 bytes (rgb), attrs in 4th byte (enum FgFlags)
+  BG = 2,       // background color in lower 3 bytes (rgb), attrs in 4th byte (enum BgFlags)
+  SIZE = 3      // size of single cell on buffer array
+}
+
+// export some privates for local usage
+export { AttributeData, IParams, IDcsHandler, IOscHandler, BgFlags, IRenderDimensions, IRenderService, Content, ExtFlags, Attributes, UnderlineStyle, ReadonlyColorSet };
+
+/**
+ * Plugin ctor options.
+ */
+export interface IImageAddonOptions {
+  enableSizeReports: boolean;
+  pixelLimit: number;
+  storageLimit: number;
+  showPlaceholder: boolean;
+  sixelSupport: boolean;
+  sixelScrolling: boolean;
+  sixelPaletteLimit: number;
+  sixelSizeLimit: number;
+  iipSupport: boolean;
+  iipSizeLimit: number;
+}
+
+export interface IResetHandler {
+  // attached to RIS and DECSTR
+  reset(): void;
+}
+
+/**
+ * Stub into private interfaces.
+ * This should be kept in line with common libs.
+ * Any change made here should be replayed in the accessors test case to
+ * have a somewhat reliable testing against code changes in the core repo.
+ */
+
+// overloaded IExtendedAttrs to hold image refs
+export interface IExtendedAttrsImage extends IExtendedAttrs {
+  imageId: number;
+  tileId: number;
+  clone(): IExtendedAttrsImage;
+}
+
+/* eslint-disable */
+export interface IBufferLineExt extends IBufferLine {
+  _extendedAttrs: {[index: number]: IExtendedAttrsImage | undefined};
+  _data: Uint32Array;
+}
+
+interface IInputHandlerExt extends IInputHandler {
+  _parser: IEscapeSequenceParser;
+  _curAttrData: AttributeData;
+  _dirtyRowTracker: {
+    markRangeDirty(y1: number, y2: number): void;
+    markAllDirty(): void;
+    markDirty(y: number): void;
+  };
+  onRequestReset(handler: () => void): IDisposable;
+}
+
+export interface ICoreTerminalExt extends ITerminal {
+  _themeService: IThemeService | undefined;
+  _inputHandler: IInputHandlerExt;
+  _renderService: IRenderService;
+  _coreBrowserService: ICoreBrowserService | undefined;
+}
+
+export interface ITerminalExt extends Terminal {
+  _core: ICoreTerminalExt;
+}
+/* eslint-enable */
+
+
+/**
+ * Some storage definitions.
+ */
+export interface ICellSize {
+  width: number;
+  height: number;
+}
+
+export interface IImageSpec {
+  orig: HTMLCanvasElement | ImageBitmap | undefined;
+  origCellSize: ICellSize;
+  actual: HTMLCanvasElement | ImageBitmap | undefined;
+  actualCellSize: ICellSize;
+  marker: IMarker | undefined;
+  tileCount: number;
+  bufferType: 'alternate' | 'normal';
+}

addons/xterm-addon-image/src/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "target": "es2017",
+    "module": "commonjs",
+    "sourceMap": true,
+    "outDir": "../out",
+    "rootDir": ".",
+    "strict": true,
+    "noUnusedLocals": true,
+    "preserveWatchOutput": true,
+    "types": [
+      "../../../node_modules/@types/mocha"
+    ],
+    "baseUrl": ".",
+    "paths": {
+      "browser/*": [ "../../../src/browser/*" ],
+      "common/*": [ "../../../src/common/*" ]
+    }
+  },
+  "include": [
+    "./**/*",
+    "../../../typings/xterm.d.ts"
+  ],
+  "references": [
+    { "path": "../../../src/browser" },
+    { "path": "../../../src/common" }
+  ]
+}

addons/xterm-addon-image/test/ImageAddon.api.ts

@@ -0,0 +1,321 @@
+/**
+ * Copyright (c) 2020 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { assert } from 'chai';
+import { openTerminal, launchBrowser, pollFor } from '../../../out-test/api/TestUtils';
+import { Browser, Page } from '@playwright/test';
+import { IImageAddonOptions } from '../src/Types';
+import { FINALIZER, introducer, sixelEncode } from 'sixel';
+import { readFileSync } from 'fs';
+
+const APP = 'http://127.0.0.1:3001/test';
+
+let browser: Browser;
+let page: Page;
+const width = 800;
+const height = 600;
+
+// eslint-disable-next-line
+declare const ImageAddon: {
+  new(options?: Partial<IImageAddonOptions>): any;
+};
+
+interface ITestData {
+  width: number;
+  height: number;
+  bytes: Uint8Array;
+  palette: number[];
+  sixel: string;
+}
+
+interface IDimensions {
+  cellWidth: number;
+  cellHeight: number;
+  width: number;
+  height: number;
+}
+
+// image: 640 x 80, 512 color
+const TESTDATA: ITestData = (() => {
+  const data8 = readFileSync('./addons/xterm-addon-image/fixture/palette.blob');
+  const data32 = new Uint32Array(data8.buffer);
+  const palette = new Set<number>();
+  for (let i = 0; i < data32.length; ++i) palette.add(data32[i]);
+  const sixel = sixelEncode(data8, 640, 80, [...palette]);
+  return {
+    width: 640,
+    height: 80,
+    bytes: data8,
+    palette: [...palette],
+    sixel
+  };
+})();
+const SIXEL_SEQ_0 = introducer(0) + TESTDATA.sixel + FINALIZER;
+// const SIXEL_SEQ_1 = introducer(1) + TESTDATA.sixel + FINALIZER;
+// const SIXEL_SEQ_2 = introducer(2) + TESTDATA.sixel + FINALIZER;
+
+// NOTE: the data is loaded as string for easier transport through playwright
+const TESTDATA_IIP: [string, [number, number]][] = [
+  [readFileSync('./addons/xterm-addon-image/fixture/iip/palette.iip', { encoding: 'utf-8' }), [640, 80]],
+  [readFileSync('./addons/xterm-addon-image/fixture/iip/spinfox.iip', { encoding: 'utf-8' }), [148, 148]],
+  [readFileSync('./addons/xterm-addon-image/fixture/iip/w3c_gif.iip', { encoding: 'utf-8' }), [72, 48]],
+  [readFileSync('./addons/xterm-addon-image/fixture/iip/w3c_jpg.iip', { encoding: 'utf-8' }), [72, 48]],
+  [readFileSync('./addons/xterm-addon-image/fixture/iip/w3c_png.iip', { encoding: 'utf-8' }), [72, 48]]
+];
+
+describe('ImageAddon', () => {
+  before(async () => {
+    browser = await launchBrowser();
+    page = await (await browser.newContext()).newPage();
+    await page.setViewportSize({ width, height });
+  });
+
+  after(async () => {
+    await browser.close();
+  });
+
+  beforeEach(async () => {
+    await page.goto(APP);
+    await openTerminal(page);
+    await page.evaluate(opts => {
+      (window as any).imageAddon = new ImageAddon(opts.opts);
+      (window as any).term.loadAddon((window as any).imageAddon);
+    }, { opts: { sixelPaletteLimit: 512 } });
+  });
+
+  it('test for private accessors', async () => {
+    // terminal privates
+    const accessors = [
+      '_core',
+      '_core._renderService',
+      '_core._inputHandler',
+      '_core._inputHandler._parser',
+      '_core._inputHandler._curAttrData',
+      '_core._inputHandler._dirtyRowTracker',
+      '_core._themeService.colors',
+      '_core._coreBrowserService'
+    ];
+    for (const prop of accessors) {
+      assert.equal(
+        await page.evaluate('(() => { const v = window.term.' + prop + '; return v !== undefined && v !== null; })()'),
+        true, `problem at ${prop}`
+      );
+    }
+    // bufferline privates
+    assert.equal(await page.evaluate('window.term._core.buffer.lines.get(0)._data instanceof Uint32Array'), true);
+    assert.equal(await page.evaluate('window.term._core.buffer.lines.get(0)._extendedAttrs instanceof Object'), true);
+    // inputhandler privates
+    assert.equal(await page.evaluate('window.term._core._inputHandler._curAttrData.constructor.name'), 'AttributeData');
+    assert.equal(await page.evaluate('window.term._core._inputHandler._parser.constructor.name'), 'EscapeSequenceParser');
+  });
+
+  describe('ctor options', () => {
+    it('empty settings should load defaults', async () => {
+      const DEFAULT_OPTIONS: IImageAddonOptions = {
+        enableSizeReports: true,
+        pixelLimit: 16777216,
+        sixelSupport: true,
+        sixelScrolling: true,
+        sixelPaletteLimit: 512,  // set to 512 to get example image working
+        sixelSizeLimit: 25000000,
+        storageLimit: 128,
+        showPlaceholder: true,
+        iipSupport: true,
+        iipSizeLimit: 20000000
+      };
+      assert.deepEqual(await page.evaluate(`window.imageAddon._opts`), DEFAULT_OPTIONS);
+    });
+    it('custom settings should overload defaults', async () => {
+      const customSettings: IImageAddonOptions = {
+        enableSizeReports: false,
+        pixelLimit: 5,
+        sixelSupport: false,
+        sixelScrolling: false,
+        sixelPaletteLimit: 1024,
+        sixelSizeLimit: 1000,
+        storageLimit: 10,
+        showPlaceholder: false,
+        iipSupport: false,
+        iipSizeLimit: 1000
+      };
+      await page.evaluate(opts => {
+        (window as any).imageAddonCustom = new ImageAddon(opts.opts);
+        (window as any).term.loadAddon((window as any).imageAddonCustom);
+      }, { opts: customSettings });
+      assert.deepEqual(await page.evaluate(`window.imageAddonCustom._opts`), customSettings);
+    });
+  });
+
+  describe('scrolling & cursor modes', () => {
+    it('testdata default (scrolling with VT240 cursor pos)', async () => {
+      const dim = await getDimensions();
+      await writeToTerminal(SIXEL_SEQ_0);
+      assert.deepEqual(await getCursor(), [0, Math.floor(TESTDATA.height/dim.cellHeight)]);
+      // moved to right by 10 cells
+      await writeToTerminal('#'.repeat(10) + SIXEL_SEQ_0);
+      assert.deepEqual(await getCursor(), [10, Math.floor(TESTDATA.height/dim.cellHeight) * 2]);
+    });
+    it('write testdata noScrolling', async () => {
+      await writeToTerminal('\x1b[?80h' + SIXEL_SEQ_0);
+      assert.deepEqual(await getCursor(), [0, 0]);
+      // second draw does not change anything
+      await writeToTerminal(SIXEL_SEQ_0);
+      assert.deepEqual(await getCursor(), [0, 0]);
+    });
+    it('testdata cursor always at VT240 pos', async () => {
+      const dim = await getDimensions();
+      // offset 0
+      await writeToTerminal(SIXEL_SEQ_0);
+      assert.deepEqual(await getCursor(), [0, Math.floor(TESTDATA.height/dim.cellHeight)]);
+      // moved to right by 10 cells
+      await writeToTerminal('#'.repeat(10) + SIXEL_SEQ_0);
+      assert.deepEqual(await getCursor(), [10, Math.floor(TESTDATA.height/dim.cellHeight) * 2]);
+      // moved by 30 cells (+10 prev)
+      await writeToTerminal('#'.repeat(30) + SIXEL_SEQ_0);
+      assert.deepEqual(await getCursor(), [10 + 30, Math.floor(TESTDATA.height/dim.cellHeight) * 3]);
+    });
+  });
+
+  describe('image lifecycle & eviction', () => {
+    it('delete image once scrolled off', async () => {
+      await writeToTerminal(SIXEL_SEQ_0);
+      pollFor(page, 'window.imageAddon._storage._images.size', 1);
+      // scroll to scrollback + rows - 1
+      await page.evaluate(
+        scrollback => new Promise(res => (window as any).term.write('\n'.repeat(scrollback), res)),
+        (await getScrollbackPlusRows() - 1)
+      );
+      // wait here, as we have to make sure, that eviction did not yet occur
+      await new Promise(r => setTimeout(r, 100));
+      pollFor(page, 'window.imageAddon._storage._images.size', 1);
+      // scroll one further should delete the image
+      await page.evaluate(() => new Promise(res => (window as any).term.write('\n', res)));
+      pollFor(page, 'window.imageAddon._storage._images.size', 0);
+    });
+    it('get storageUsage', async () => {
+      assert.equal(await page.evaluate('imageAddon.storageUsage'), 0);
+      await writeToTerminal(SIXEL_SEQ_0);
+      assert.closeTo(await page.evaluate('imageAddon.storageUsage'), 640 * 80 * 4 / 1000000, 0.05);
+    });
+    it('get/set storageLimit', async () => {
+      assert.equal(await page.evaluate('imageAddon.storageLimit'), 128);
+      assert.equal(await page.evaluate('imageAddon.storageLimit = 1'), 1);
+      assert.equal(await page.evaluate('imageAddon.storageLimit'), 1);
+    });
+    it('remove images by storage limit pressure', async () => {
+      assert.equal(await page.evaluate('imageAddon.storageLimit = 1'), 1);
+      // never go beyond storage limit
+      await writeToTerminal(SIXEL_SEQ_0);
+      await writeToTerminal(SIXEL_SEQ_0);
+      await writeToTerminal(SIXEL_SEQ_0);
+      await writeToTerminal(SIXEL_SEQ_0);
+      await new Promise(r => setTimeout(r, 50));
+      const usage = await page.evaluate('imageAddon.storageUsage');
+      await writeToTerminal(SIXEL_SEQ_0);
+      await writeToTerminal(SIXEL_SEQ_0);
+      await writeToTerminal(SIXEL_SEQ_0);
+      await writeToTerminal(SIXEL_SEQ_0);
+      await new Promise(r => setTimeout(r, 50));
+      assert.equal(await page.evaluate('imageAddon.storageUsage'), usage);
+      assert.equal(usage as number < 1, true);
+    });
+    it('set storageLimit removes images synchronously', async () => {
+      await writeToTerminal(SIXEL_SEQ_0 + SIXEL_SEQ_0 + SIXEL_SEQ_0);
+      const usage: number = await page.evaluate('imageAddon.storageUsage');
+      const newUsage: number = await page.evaluate('imageAddon.storageLimit = 0.5; imageAddon.storageUsage');
+      assert.equal(newUsage < usage, true);
+      assert.equal(newUsage < 0.5, true);
+    });
+    it('clear alternate images on buffer change', async () => {
+      assert.equal(await page.evaluate('imageAddon.storageUsage'), 0);
+      await writeToTerminal('\x1b[?1049h' + SIXEL_SEQ_0);
+      assert.closeTo(await page.evaluate('imageAddon.storageUsage'), 640 * 80 * 4 / 1000000, 0.05);
+      await writeToTerminal('\x1b[?1049l');
+      assert.equal(await page.evaluate('imageAddon.storageUsage'), 0);
+    });
+    it('evict tiles by in-place overwrites (only full overwrite tested)', async () => {
+      await new Promise(r => setTimeout(r, 50));
+      await writeToTerminal('\x1b[H' + SIXEL_SEQ_0 + '\x1b[100;100H');
+      let usage = await page.evaluate('imageAddon.storageUsage');
+      while (usage === 0) {
+        await new Promise(r => setTimeout(r, 50));
+        usage = await page.evaluate('imageAddon.storageUsage');
+      }
+      await writeToTerminal('\x1b[H' + SIXEL_SEQ_0 + '\x1b[100;100H');
+      await new Promise(r => setTimeout(r, 200));  // wait some time and re-check
+      assert.equal(await page.evaluate('imageAddon.storageUsage'), usage);
+    });
+    it('manual eviction on alternate buffer must not miss images', async () => {
+      await writeToTerminal('\x1b[?1049h');
+      await writeToTerminal(SIXEL_SEQ_0 + SIXEL_SEQ_0 + SIXEL_SEQ_0 + SIXEL_SEQ_0 + SIXEL_SEQ_0 + SIXEL_SEQ_0);
+      await new Promise(r => setTimeout(r, 50));
+      const usage: number = await page.evaluate('imageAddon.storageUsage');
+      await writeToTerminal(SIXEL_SEQ_0 + SIXEL_SEQ_0 + SIXEL_SEQ_0 + SIXEL_SEQ_0 + SIXEL_SEQ_0 + SIXEL_SEQ_0);
+      await writeToTerminal(SIXEL_SEQ_0 + SIXEL_SEQ_0 + SIXEL_SEQ_0 + SIXEL_SEQ_0 + SIXEL_SEQ_0 + SIXEL_SEQ_0);
+      await new Promise(r => setTimeout(r, 50));
+      const newUsage: number = await page.evaluate('imageAddon.storageUsage');
+      assert.equal(newUsage, usage);
+    });
+  });
+
+  describe('IIP support - testimages', () => {
+    it('palette.png', async () => {
+      await writeToTerminal(TESTDATA_IIP[0][0]);
+      assert.deepEqual(await getOrigSize(1), TESTDATA_IIP[0][1]);
+    });
+    it('spinfox.png', async () => {
+      await writeToTerminal(TESTDATA_IIP[1][0]);
+      assert.deepEqual(await getOrigSize(1), TESTDATA_IIP[1][1]);
+    });
+    it('w3c gif', async () => {
+      await writeToTerminal(TESTDATA_IIP[2][0]);
+      assert.deepEqual(await getOrigSize(1), TESTDATA_IIP[2][1]);
+    });
+    it('w3c jpeg', async () => {
+      await writeToTerminal(TESTDATA_IIP[3][0]);
+      assert.deepEqual(await getOrigSize(1), TESTDATA_IIP[3][1]);
+    });
+    it('w3c png', async () => {
+      await writeToTerminal(TESTDATA_IIP[4][0]);
+      assert.deepEqual(await getOrigSize(1), TESTDATA_IIP[4][1]);
+    });
+  });
+});
+
+/**
+ * terminal access helpers.
+ */
+async function getDimensions(): Promise<IDimensions> {
+  const dimensions: any = await page.evaluate(`term._core._renderService.dimensions`);
+  return {
+    cellWidth: Math.round(dimensions.css.cell.width),
+    cellHeight: Math.round(dimensions.css.cell.height),
+    width: Math.round(dimensions.css.canvas.width),
+    height: Math.round(dimensions.css.canvas.height)
+  };
+}
+
+async function getCursor(): Promise<[number, number]> {
+  return page.evaluate('[window.term.buffer.active.cursorX, window.term.buffer.active.cursorY]');
+}
+
+async function getImageStorageLength(): Promise<number> {
+  return page.evaluate('window.imageAddon._storage._images.size');
+}
+
+async function getScrollbackPlusRows(): Promise<number> {
+  return page.evaluate('window.term.options.scrollback + window.term.rows');
+}
+
+async function writeToTerminal(d: string): Promise<any> {
+  return page.evaluate(data => new Promise(res => (window as any).term.write(data, res)), d);
+}
+
+async function getOrigSize(id: number): Promise<[number, number]> {
+  return page.evaluate<any>(`[
+    window.imageAddon._storage._images.get(${id}).orig.width,
+    window.imageAddon._storage._images.get(${id}).orig.height
+  ]`);
+}

addons/xterm-addon-image/test/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es2017",
+    "rootDir": ".",
+    "outDir": "../out-test",
+    "sourceMap": true,
+    "removeComments": true,
+    "strict": true,
+    "baseUrl": ".",
+    "paths": {
+      "browser/*": [ "../../../src/browser/*" ],
+      "common/*": [ "../../../src/common/*" ]
+    },
+    "types": [
+      "../../../node_modules/@types/mocha",
+      "../../../node_modules/@types/node",
+      "../../../out-test/api/TestUtils"
+    ]
+  },
+  "include": [
+    "./**/*",
+    "../../../typings/xterm.d.ts"
+  ],
+  "references": [
+    { "path": "../../../src/browser" },
+    { "path": "../../../src/common" }
+  ]
+}

addons/xterm-addon-image/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "files": [],
+  "include": [],
+  "references": [
+    { "path": "./src" },
+    { "path": "./test" }
+  ]
+}

addons/xterm-addon-image/typings/xterm-addon-image.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Copyright (c) 2022 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { Terminal, ITerminalAddon } from 'xterm';
+
+declare module 'xterm-addon-image' {
+  export interface IImageAddonOptions {
+    /**
+     * Enable size reports in windowOptions:
+     * - getWinSizePixels (CSI 14 t)
+     * - getCellSizePixels (CSI 16 t)
+     * - getWinSizeChars (CSI 18 t)
+     *
+     * If `true` (default), the reports will be activated during addon loading.
+     * If `false`, no settings will be touched. Use `false`, if you have high
+     * security constraints and/or deal with windowOptions by other means.
+     * On addon disposal, the settings will not change.
+     */
+    enableSizeReports?: boolean;
+
+    /**
+     * Maximum pixels a single image may hold. Images exceeding this number will
+     * be discarded during processing with no changes to the terminal buffer
+     * (no cursor advance, no placeholder).
+     * This setting is mainly used to restrict images sizes during initial decoding
+     * including the final canvas creation.
+     *
+     * Note: The image worker decoder may hold additional memory up to
+     * `pixelLimit` * 4 bytes permanently, plus the same amount on top temporarily
+     * for pixel transfers, which should be taken into account under memory pressure conditions.
+     *
+     * Note: Browsers restrict allowed canvas dimensions further. We dont reflect those
+     * limits here, thus the construction of an oddly shaped image having most pixels
+     * in one dimension still can fail.
+     *
+     * Note: `storageLimit` bytes are calculated from images by multiplying the pixels with 4
+     * (4 channels with one byte, images are stored as RGBA8888).
+     * 
+     * Default is 2^16 (4096 x 4096 pixels).
+     */
+    pixelLimit?: number;
+
+    /**
+     * Storage limit in MB.
+     * The storage implements a FIFO cache removing old images, when the limit gets hit.
+     * Also exposed as addon property for runtime adjustments.
+     * Default is 128 MB.
+     */
+    storageLimit?: number;
+
+    /**
+     * Whether to show a placeholder for images removed from cache, default is true.
+     */
+    showPlaceholder?: boolean;
+
+    /**
+     * SIXEL settings
+     */
+
+    /** Whether SIXEL is enabled (default is true). */
+    sixelSupport?: boolean;
+    /** Whether SIXEL scrolling is enabled (default is true). Same as DECSET 80. */
+    sixelScrolling?: boolean;
+    /** Palette color limit (default 256). */
+    sixelPaletteLimit?: number;
+    /** SIXEL image size limit in bytes (default 25000000 bytes). */
+    sixelSizeLimit?: number;
+
+    /**
+     * IIP settings (iTerm image protocol)
+     */
+
+    /** Whether iTerm image protocol style is enabled (default is true). */
+    iipSupport?: boolean;
+    /** IIP sequence size limit (default 20000000 bytes). */
+    iipSizeLimit?: number;
+  }
+
+  export class ImageAddon implements ITerminalAddon {
+    constructor(options?: IImageAddonOptions);
+    public activate(terminal: Terminal): void;
+    public dispose(): void;
+
+    /**
+     * Reset the image addon.
+     *
+     * This resets all runtime options to default values (as given to the ctor)
+     * and resets the image storage.
+     */
+    public reset(): void;
+
+    /**
+     * Getter/Setter for the storageLimit in MB.
+     * Synchronously deletes images if the stored data exceeds the new value.
+     */
+    public storageLimit: number;
+
+    /**
+     * Current memory usage of the stored images in MB.
+     */
+    public readonly storageUsage: number;
+
+    /**
+     * Getter/Setter whether the placeholder should be shown.
+     */
+    public showPlaceholder: boolean;
+
+    /**
+     * Get original image canvas at buffer position.
+     */
+    public getImageAtBufferCell(x: number, y: number): HTMLCanvasElement | undefined;
+
+    /**
+     * Extract single tile canvas at buffer position.
+     */
+    public extractTileAtBufferCell(x: number, y: number): HTMLCanvasElement | undefined;
+  }
+}

addons/xterm-addon-image/webpack.config.js

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) 2020 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+const path = require('path');
+
+const addonName = 'ImageAddon';
+const mainFile = 'xterm-addon-image.js';
+
+const addon = {
+  entry: `./out/${addonName}.js`,
+  devtool: 'source-map',
+  module: {
+    rules: [
+      {
+        test: /\.js$/,
+        use: ["source-map-loader"],
+        enforce: "pre",
+        exclude: /node_modules/
+      }
+    ]
+  },
+  output: {
+    filename: mainFile,
+    path: path.resolve('./lib'),
+    library: addonName,
+    libraryTarget: 'umd'
+  },
+  mode: 'production'
+};
+
+module.exports = [addon];

addons/xterm-addon-ligatures/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xterm-addon-ligatures",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Add support for programming ligatures to xterm.js",
   "author": {
     "name": "The xterm.js authors",

addons/xterm-addon-ligatures/src/font.ts

@@ -65,7 +65,7 @@ export default async function load(fontFamily: string, cacheSize: number): Promi
       }
     }
     // Latest proposal https://bugs.chromium.org/p/chromium/issues/detail?id=1312603
-    else if (typeof process !== 'object' && 'queryLocalFonts' in window) {
+    else if (typeof window !== 'undefined' && 'queryLocalFonts' in window) {
       const fonts: Record<string, IFontMetadata[]> = {};
       try {
         const fontsIterator = await (window as any).queryLocalFonts();

addons/xterm-addon-search/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xterm-addon-search",
-  "version": "0.10.0",
+  "version": "0.13.0",
   "author": {
     "name": "The xterm.js authors",
     "url": "https://xtermjs.org/"

addons/xterm-addon-search/src/SearchAddon.ts

@@ -3,8 +3,9 @@
  * @license MIT
  */
 
-import { Terminal, IDisposable, ITerminalAddon, IBufferRange, IDecoration } from 'xterm';
+import { Terminal, IDisposable, ITerminalAddon, IDecoration } from 'xterm';
 import { EventEmitter } from 'common/EventEmitter';
+import { Disposable, toDisposable, disposeArray, MutableDisposable } from 'common/Lifecycle';
 
 export interface ISearchOptions {
   regex?: boolean;
@@ -29,6 +30,10 @@ export interface ISearchPosition {
   startRow: number;
 }
 
+export interface ISearchAddonOptions {
+  highlightLimit: number;
+}
+
 export interface ISearchResult {
   term: string;
   col: number;
@@ -47,17 +52,22 @@ type LineCacheEntry = [
   lineOffsets: number[]
 ];
 
+interface IHighlight extends IDisposable {
+  decoration: IDecoration;
+  match: ISearchResult;
+}
+
 const NON_WORD_CHARACTERS = ' ~!@#$%^&*()+`-=[]{}|\\;:"\',./<>?';
 const LINES_CACHE_TIME_TO_LIVE = 15 * 1000; // 15 secs
+const DEFAULT_HIGHLIGHT_LIMIT = 1000;
 
-export class SearchAddon implements ITerminalAddon {
+export class SearchAddon extends Disposable implements ITerminalAddon {
   private _terminal: Terminal | undefined;
   private _cachedSearchTerm: string | undefined;
-  private _selectedDecoration: IDecoration | undefined;
-  private _resultDecorations: Map<number, IDecoration[]> | undefined;
-  private _searchResults: Map<string, ISearchResult> | undefined;
-  private _onDataDisposable: IDisposable | undefined;
-  private _onResizeDisposable: IDisposable | undefined;
+  private _highlightedLines: Set<number> = new Set();
+  private _highlightDecorations: IHighlight[] = [];
+  private _selectedDecoration: MutableDisposable<IHighlight> = this.register(new MutableDisposable());
+  private _highlightLimit: number;
   private _lastSearchOptions: ISearchOptions | undefined;
   private _highlightTimeout: number | undefined;
   /**
@@ -70,15 +80,20 @@ export class SearchAddon implements ITerminalAddon {
   private _cursorMoveListener: IDisposable | undefined;
   private _resizeListener: IDisposable | undefined;
 
-  private _resultIndex: number | undefined;
-
-  private readonly _onDidChangeResults = new EventEmitter<{ resultIndex: number, resultCount: number } | undefined>();
+  private readonly _onDidChangeResults = this.register(new EventEmitter<{ resultIndex: number, resultCount: number }>());
   public readonly onDidChangeResults = this._onDidChangeResults.event;
 
+  constructor(options?: Partial<ISearchAddonOptions>) {
+    super();
+
+    this._highlightLimit = options?.highlightLimit ?? DEFAULT_HIGHLIGHT_LIMIT;
+  }
+
   public activate(terminal: Terminal): void {
     this._terminal = terminal;
-    this._onDataDisposable = this._terminal.onWriteParsed(() => this._updateMatches());
-    this._onResizeDisposable = this._terminal.onResize(() => this._updateMatches());
+    this.register(this._terminal.onWriteParsed(() => this._updateMatches()));
+    this.register(this._terminal.onResize(() => this._updateMatches()));
+    this.register(toDisposable(() => this.clearDecorations()));
   }
 
   private _updateMatches(): void {
@@ -87,46 +102,29 @@ export class SearchAddon implements ITerminalAddon {
     }
     if (this._cachedSearchTerm && this._lastSearchOptions?.decorations) {
       this._highlightTimeout = setTimeout(() => {
-        this.findPrevious(this._cachedSearchTerm!, { ...this._lastSearchOptions, incremental: true, noScroll: true });
-        this._resultIndex = this._searchResults ? this._searchResults.size - 1 : -1;
-        this._onDidChangeResults.fire({ resultIndex: this._resultIndex, resultCount: this._searchResults?.size ?? -1 });
+        const term = this._cachedSearchTerm;
+        this._cachedSearchTerm = undefined;
+        this.findPrevious(term!, { ...this._lastSearchOptions, incremental: true, noScroll: true });
       }, 200);
     }
   }
 
-  public dispose(): void {
-    this.clearDecorations();
-    this._onDataDisposable?.dispose();
-    this._onResizeDisposable?.dispose();
-  }
-
   public clearDecorations(retainCachedSearchTerm?: boolean): void {
-    this._selectedDecoration?.dispose();
-    this._searchResults?.clear();
-    this._resultDecorations?.forEach(decorations => {
-      for (const d of decorations) {
-        d.dispose();
-      }
-    });
-    this._resultDecorations?.clear();
-    this._searchResults = undefined;
-    this._resultDecorations = undefined;
+    this._selectedDecoration.clear();
+    disposeArray(this._highlightDecorations);
+    this._highlightDecorations = [];
+    this._highlightedLines.clear();
     if (!retainCachedSearchTerm) {
       this._cachedSearchTerm = undefined;
     }
   }
 
-  public clearActiveDecoration(): void {
-    this._selectedDecoration?.dispose();
-    this._selectedDecoration = undefined;
-  }
-
   /**
    * Find the next instance of the term, then scroll to and select it. If it
    * doesn't exist, do nothing.
    * @param term The search term.
    * @param searchOptions Search options.
-   * @return Whether a result was found.
+   * @returns Whether a result was found.
    */
   public findNext(term: string, searchOptions?: ISearchOptions): boolean {
     if (!this._terminal) {
@@ -134,11 +132,16 @@ export class SearchAddon implements ITerminalAddon {
     }
     this._lastSearchOptions = searchOptions;
     if (searchOptions?.decorations) {
-      if (this._resultIndex !== undefined || this._cachedSearchTerm === undefined || term !== this._cachedSearchTerm) {
+      if (this._cachedSearchTerm === undefined || term !== this._cachedSearchTerm) {
         this._highlightAllMatches(term, searchOptions);
       }
     }
-    return this._fireResults(term, this._findNextAndSelect(term, searchOptions), searchOptions);
+
+    const found = this._findNextAndSelect(term, searchOptions);
+    this._fireResults(searchOptions);
+    this._cachedSearchTerm = term;
+
+    return found;
   }
 
   private _highlightAllMatches(term: string, searchOptions: ISearchOptions): void {
@@ -153,32 +156,30 @@ export class SearchAddon implements ITerminalAddon {
 
     // new search, clear out the old decorations
     this.clearDecorations(true);
-    this._searchResults = new Map<string, ISearchResult>();
-    this._resultDecorations = new Map<number, IDecoration[]>();
-    const resultDecorations = this._resultDecorations;
+
+    const searchResultsWithHighlight: ISearchResult[] = [];
+    let prevResult: ISearchResult | undefined = undefined;
     let result = this._find(term, 0, 0, searchOptions);
-    while (result && !this._searchResults.get(`${result.row}-${result.col}`)) {
-      this._searchResults.set(`${result.row}-${result.col}`, result);
+    while (result && (prevResult?.row !== result.row || prevResult?.col !== result.col)) {
+      if (searchResultsWithHighlight.length >= this._highlightLimit) {
+        break;
+      }
+      prevResult = result;
+      searchResultsWithHighlight.push(prevResult);
       result = this._find(
         term,
-        result.col + result.term.length >= this._terminal.cols ? result.row + 1 : result.row,
-        result.col + result.term.length >= this._terminal.cols ? 0 : result.col + 1,
+        prevResult.col + prevResult.term.length >= this._terminal.cols ? prevResult.row + 1 : prevResult.row,
+        prevResult.col + prevResult.term.length >= this._terminal.cols ? 0 : prevResult.col + 1,
         searchOptions
       );
-      if (this._searchResults.size > 1000) {
-        this.clearDecorations();
-        this._resultIndex = undefined;
-        return;
+    }
+    for (const match of searchResultsWithHighlight) {
+      const decoration = this._createResultDecoration(match, searchOptions.decorations!);
+      if (decoration) {
+        this._highlightedLines.add(decoration.marker.line);
+        this._highlightDecorations.push({ decoration, match, dispose() { decoration.dispose(); } });
       }
     }
-    this._searchResults.forEach(result => {
-      const resultDecoration = this._createResultDecoration(result, searchOptions.decorations!);
-      if (resultDecoration) {
-        const decorationsForLine = resultDecorations.get(resultDecoration.marker.line) || [];
-        decorationsForLine.push(resultDecoration);
-        resultDecorations.set(resultDecoration.marker.line, decorationsForLine);
-      }
-    });
   }
 
   private _find(term: string, startRow: number, startCol: number, searchOptions?: ISearchOptions): ISearchResult | undefined {
@@ -223,26 +224,22 @@ export class SearchAddon implements ITerminalAddon {
     if (!this._terminal || !term || term.length === 0) {
       this._terminal?.clearSelection();
       this.clearDecorations();
-      this._cachedSearchTerm = undefined;
-      this._resultIndex = -1;
       return false;
     }
 
-    if (this._cachedSearchTerm !== term) {
-      this._resultIndex = undefined;
-      this._terminal.clearSelection();
-    }
+    const prevSelectedPos = this._terminal.getSelectionPosition();
+    this._terminal.clearSelection();
 
     let startCol = 0;
     let startRow = 0;
-    let currentSelection: IBufferRange | undefined;
-    if (this._terminal.hasSelection()) {
-      const incremental = searchOptions ? searchOptions.incremental : false;
-      // Start from the selection end if there is a selection
-      // For incremental search, use existing row
-      currentSelection = this._terminal.getSelectionPosition()!;
-      startRow = incremental ? currentSelection.start.y : currentSelection.end.y;
-      startCol = incremental ? currentSelection.start.x : currentSelection.end.x;
+    if (prevSelectedPos) {
+      if (this._cachedSearchTerm === term) {
+        startCol = prevSelectedPos.end.x;
+        startRow = prevSelectedPos.end.y;
+      } else {
+        startCol = prevSelectedPos.start.x;
+        startRow = prevSelectedPos.start.y;
+      }
     }
 
     this._initLinesCache();
@@ -281,24 +278,12 @@ export class SearchAddon implements ITerminalAddon {
     }
 
     // If there is only one result, wrap back and return selection if it exists.
-    if (!result && currentSelection) {
-      searchPosition.startRow = currentSelection.start.y;
+    if (!result && prevSelectedPos) {
+      searchPosition.startRow = prevSelectedPos.start.y;
       searchPosition.startCol = 0;
       result = this._findInLine(term, searchPosition, searchOptions);
     }
 
-    if (this._searchResults) {
-      if (this._searchResults.size === 0) {
-        this._resultIndex = -1;
-      } else if (this._resultIndex === undefined) {
-        this._resultIndex = 0;
-      } else {
-        this._resultIndex++;
-        if (this._resultIndex >= this._searchResults.size) {
-          this._resultIndex = 0;
-        }
-      }
-    }
     // Set selection and scroll if a result was found
     return this._selectResult(result, searchOptions?.decorations, searchOptions?.noScroll);
   }
@@ -307,7 +292,7 @@ export class SearchAddon implements ITerminalAddon {
    * doesn't exist, do nothing.
    * @param term The search term.
    * @param searchOptions Search options.
-   * @return Whether a result was found.
+   * @returns Whether a result was found.
    */
   public findPrevious(term: string, searchOptions?: ISearchOptions): boolean {
     if (!this._terminal) {
@@ -315,75 +300,74 @@ export class SearchAddon implements ITerminalAddon {
     }
     this._lastSearchOptions = searchOptions;
     if (searchOptions?.decorations) {
-      if (this._resultIndex !== undefined || this._cachedSearchTerm === undefined || term !== this._cachedSearchTerm) {
+      if (this._cachedSearchTerm === undefined || term !== this._cachedSearchTerm) {
         this._highlightAllMatches(term, searchOptions);
       }
     }
-    return this._fireResults(term, this._findPreviousAndSelect(term, searchOptions), searchOptions);
+
+    const found = this._findPreviousAndSelect(term, searchOptions);
+    this._fireResults(searchOptions);
+    this._cachedSearchTerm = term;
+
+    return found;
   }
 
-  private _fireResults(term: string, found: boolean, searchOptions?: ISearchOptions): boolean {
+  private _fireResults(searchOptions?: ISearchOptions): void {
     if (searchOptions?.decorations) {
-      if (this._resultIndex !== undefined && this._searchResults?.size !== undefined) {
-        this._onDidChangeResults.fire({ resultIndex: this._resultIndex, resultCount: this._searchResults.size });
-      } else {
-        this._onDidChangeResults.fire(undefined);
+      let resultIndex = -1;
+      if (this._selectedDecoration.value) {
+        const selectedMatch = this._selectedDecoration.value.match;
+        for (let i = 0; i < this._highlightDecorations.length; i++) {
+          const match = this._highlightDecorations[i].match;
+          if (match.row === selectedMatch.row && match.col === selectedMatch.col && match.size === selectedMatch.size) {
+            resultIndex = i;
+            break;
+          }
+        }
       }
+      this._onDidChangeResults.fire({ resultIndex, resultCount: this._highlightDecorations.length });
     }
-    this._cachedSearchTerm = term;
-    return found;
   }
 
   private _findPreviousAndSelect(term: string, searchOptions?: ISearchOptions): boolean {
     if (!this._terminal) {
       throw new Error('Cannot use addon until it has been loaded');
     }
-    let result: ISearchResult | undefined;
     if (!this._terminal || !term || term.length === 0) {
-      result = undefined;
       this._terminal?.clearSelection();
       this.clearDecorations();
-      this._resultIndex = -1;
       return false;
     }
 
-    if (this._cachedSearchTerm !== term) {
-      this._resultIndex = undefined;
-      this._terminal.clearSelection();
-    }
+    const prevSelectedPos = this._terminal.getSelectionPosition();
+    this._terminal.clearSelection();
 
-    let startRow = this._terminal.buffer.active.baseY + this._terminal.rows;
+    let startRow = this._terminal.buffer.active.baseY + this._terminal.rows - 1;
     let startCol = this._terminal.cols;
     const isReverseSearch = true;
 
-    const incremental = searchOptions ? searchOptions.incremental : false;
-    let currentSelection: IBufferRange | undefined;
-    if (this._terminal.hasSelection()) {
-      currentSelection = this._terminal.getSelectionPosition()!;
-      // Start from selection start if there is a selection
-      startRow = currentSelection.start.y;
-      startCol = currentSelection.start.x;
-    }
-
     this._initLinesCache();
     const searchPosition: ISearchPosition = {
       startRow,
       startCol
     };
 
-    if (incremental) {
-      // Try to expand selection to right first.
-      result = this._findInLine(term, searchPosition, searchOptions, false);
-      const isOldResultHighlighted = result && result.row === startRow && result.col === startCol;
-      if (!isOldResultHighlighted) {
-        // If selection was not able to be expanded to the right, then try reverse search
-        if (currentSelection) {
-          searchPosition.startRow = currentSelection.end.y;
-          searchPosition.startCol = currentSelection.end.x;
+    let result: ISearchResult | undefined;
+    if (prevSelectedPos) {
+      searchPosition.startRow = startRow = prevSelectedPos.start.y;
+      searchPosition.startCol = startCol = prevSelectedPos.start.x;
+      if (this._cachedSearchTerm !== term) {
+        // Try to expand selection to right first.
+        result = this._findInLine(term, searchPosition, searchOptions, false);
+        if (!result) {
+          // If selection was not able to be expanded to the right, then try reverse search
+          searchPosition.startRow = startRow = prevSelectedPos.end.y;
+          searchPosition.startCol = startCol = prevSelectedPos.end.x;
         }
-        result = this._findInLine(term, searchPosition, searchOptions, true);
       }
-    } else {
+    }
+
+    if (!result) {
       result = this._findInLine(term, searchPosition, searchOptions, isReverseSearch);
     }
 
@@ -399,8 +383,8 @@ export class SearchAddon implements ITerminalAddon {
       }
     }
     // If we hit the top and didn't search from the very bottom wrap back down
-    if (!result && startRow !== (this._terminal.buffer.active.baseY + this._terminal.rows)) {
-      for (let y = (this._terminal.buffer.active.baseY + this._terminal.rows); y >= startRow; y--) {
+    if (!result && startRow !== (this._terminal.buffer.active.baseY + this._terminal.rows - 1)) {
+      for (let y = (this._terminal.buffer.active.baseY + this._terminal.rows - 1); y >= startRow; y--) {
         searchPosition.startRow = y;
         result = this._findInLine(term, searchPosition, searchOptions, isReverseSearch);
         if (result) {
@@ -409,22 +393,6 @@ export class SearchAddon implements ITerminalAddon {
       }
     }
 
-    if (this._searchResults) {
-      if (this._searchResults.size === 0) {
-        this._resultIndex = -1;
-      } else if (this._resultIndex === undefined || this._resultIndex < 0) {
-        this._resultIndex = this._searchResults.size - 1;
-      } else {
-        this._resultIndex--;
-        if (this._resultIndex === -1) {
-          this._resultIndex = this._searchResults.size - 1;
-        }
-      }
-    }
-
-    // If there is only one result, return true.
-    if (!result && currentSelection) return true;
-
     // Set selection and scroll if a result was found
     return this._selectResult(result, searchOptions?.decorations, searchOptions?.noScroll);
   }
@@ -461,7 +429,8 @@ export class SearchAddon implements ITerminalAddon {
   }
 
   /**
-   * A found substring is a whole word if it doesn't have an alphanumeric character directly adjacent to it.
+   * A found substring is a whole word if it doesn't have an alphanumeric character directly
+   * adjacent to it.
    * @param searchIndex starting indext of the potential whole word substring
    * @param line entire string in which the potential whole word was found
    * @param term the substring that starts at searchIndex
@@ -472,15 +441,16 @@ export class SearchAddon implements ITerminalAddon {
   }
 
   /**
-   * Searches a line for a search term. Takes the provided terminal line and searches the text line, which may contain
-   * subsequent terminal lines if the text is wrapped. If the provided line number is part of a wrapped text line that
-   * started on an earlier line then it is skipped since it will be properly searched when the terminal line that the
-   * text starts on is searched.
+   * Searches a line for a search term. Takes the provided terminal line and searches the text line,
+   * which may contain subsequent terminal lines if the text is wrapped. If the provided line number
+   * is part of a wrapped text line that started on an earlier line then it is skipped since it will
+   * be properly searched when the terminal line that the text starts on is searched.
    * @param term The search term.
-   * @param position The position to start the search.
+   * @param searchPosition The position to start the search.
    * @param searchOptions Search options.
-   * @param isReverseSearch Whether the search should start from the right side of the terminal and search to the left.
-   * @return The search result if it was found.
+   * @param isReverseSearch Whether the search should start from the right side of the terminal and
+   * search to the left.
+   * @returns The search result if it was found.
    */
   protected _findInLine(term: string, searchPosition: ISearchPosition, searchOptions: ISearchOptions = {}, isReverseSearch: boolean = false): ISearchResult | undefined {
     const terminal = this._terminal!;
@@ -547,7 +517,8 @@ export class SearchAddon implements ITerminalAddon {
         return;
       }
 
-      // Adjust the row number and search index if needed since a "line" of text can span multiple rows
+      // Adjust the row number and search index if needed since a "line" of text can span multiple
+      // rows
       let startRowOffset = 0;
       while (startRowOffset < offsets.length - 1 && resultIndex >= offsets[startRowOffset + 1]) {
         startRowOffset++;
@@ -627,7 +598,7 @@ export class SearchAddon implements ITerminalAddon {
    * Wide characters will count as two columns in the resulting string. This
    * function is useful for getting the actual text underneath the raw selection
    * position.
-   * @param line The line being translated.
+   * @param lineIndex The index of the line being translated.
    * @param trimRight Whether to trim whitespace to the right.
    */
   private _translateBufferLineToStringWithWrap(lineIndex: number, trimRight: boolean): LineCacheEntry {
@@ -662,11 +633,11 @@ export class SearchAddon implements ITerminalAddon {
   /**
    * Selects and scrolls to a result.
    * @param result The result to select.
-   * @return Whether a result was selected.
+   * @returns Whether a result was selected.
    */
   private _selectResult(result: ISearchResult | undefined, options?: ISearchDecorationOptions, noScroll?: boolean): boolean {
     const terminal = this._terminal!;
-    this.clearActiveDecoration();
+    this._selectedDecoration.clear();
     if (!result) {
       terminal.clearSelection();
       return false;
@@ -675,7 +646,7 @@ export class SearchAddon implements ITerminalAddon {
     if (options) {
       const marker = terminal.registerMarker(-terminal.buffer.active.baseY - terminal.buffer.active.cursorY + result.row);
       if (marker) {
-        this._selectedDecoration = terminal.registerDecoration({
+        const decoration = terminal.registerDecoration({
           marker,
           x: result.col,
           width: result.size,
@@ -685,8 +656,13 @@ export class SearchAddon implements ITerminalAddon {
             color: options.activeMatchColorOverviewRuler
           }
         });
-        this._selectedDecoration?.onRender((e) => this._applyStyles(e, options.activeMatchBorder, true));
-        this._selectedDecoration?.onDispose(() => marker.dispose());
+        if (decoration) {
+          const disposables: IDisposable[] = [];
+          disposables.push(marker);
+          disposables.push(decoration.onRender((e) => this._applyStyles(e, options.activeMatchBorder, true)));
+          disposables.push(decoration.onDispose(() => disposeArray(disposables)));
+          this._selectedDecoration.value = { decoration, match: result, dispose() { decoration.dispose(); } };
+        }
       }
     }
 
@@ -702,16 +678,13 @@ export class SearchAddon implements ITerminalAddon {
   }
 
   /**
-   * Applies styles to the decoration when it is rendered
-   * @param element the decoration's element
-   * @param backgroundColor the background color to apply
-   * @param borderColor the border color to apply
+   * Applies styles to the decoration when it is rendered.
+   * @param element The decoration's element.
+   * @param borderColor The border color to apply.
+   * @param isActiveResult Whether the element is part of the active search result.
    * @returns
    */
   private _applyStyles(element: HTMLElement, borderColor: string | undefined, isActiveResult: boolean): void {
-    if (element.clientWidth <= 0) {
-      return;
-    }
     if (!element.classList.contains('xterm-find-result-decoration')) {
       element.classList.add('xterm-find-result-decoration');
       if (borderColor) {
@@ -740,13 +713,17 @@ export class SearchAddon implements ITerminalAddon {
       x: result.col,
       width: result.size,
       backgroundColor: options.matchBackground,
-      overviewRulerOptions: this._resultDecorations?.get(marker.line) ? undefined : {
+      overviewRulerOptions: this._highlightedLines.has(marker.line) ? undefined : {
         color: options.matchOverviewRuler,
         position: 'center'
       }
     });
-    findResultDecoration?.onRender((e) => this._applyStyles(e, options.matchBorder, false));
-    findResultDecoration?.onDispose(() => marker.dispose());
+    if (findResultDecoration) {
+      const disposables: IDisposable[] = [];
+      disposables.push(marker);
+      disposables.push(findResultDecoration.onRender((e) => this._applyStyles(e, options.matchBorder, false)));
+      disposables.push(findResultDecoration.onDispose(() => disposeArray(disposables)));
+    }
     return findResultDecoration;
   }
 }

addons/xterm-addon-search/test/SearchAddon.api.ts

@@ -7,7 +7,7 @@ import { assert } from 'chai';
 import { readFile } from 'fs';
 import { resolve } from 'path';
 import { openTerminal, writeSync, launchBrowser, timeout } from '../../../out-test/api/TestUtils';
-import { Browser, Page } from 'playwright';
+import { Browser, Page } from '@playwright/test';
 
 const APP = 'http://127.0.0.1:3001/test';
 
@@ -178,7 +178,7 @@ describe('Search Tests', function (): void {
           window.calls = [];
           window.search.onDidChangeResults(e => window.calls.push(e));
         `);
-        await writeSync(page, 'abc aabc');
+        await writeSync(page, 'd abc aabc d');
         assert.deepStrictEqual(await page.evaluate(`window.search.findNext('a', { incremental: true, decorations: { activeMatchColorOverviewRuler: '#ff0000' } })`), true);
         assert.deepStrictEqual(await page.evaluate('window.calls'), [
           { resultCount: 3, resultIndex: 0 }
@@ -201,15 +201,64 @@ describe('Search Tests', function (): void {
           { resultCount: 2, resultIndex: 0 },
           { resultCount: 2, resultIndex: 1 }
         ]);
+        assert.deepStrictEqual(await page.evaluate(`window.search.findNext('d', { incremental: true, decorations: { activeMatchColorOverviewRuler: '#ff0000' } })`), true);
+        assert.deepStrictEqual(await page.evaluate('window.calls'), [
+          { resultCount: 3, resultIndex: 0 },
+          { resultCount: 2, resultIndex: 0 },
+          { resultCount: 2, resultIndex: 0 },
+          { resultCount: 2, resultIndex: 1 },
+          { resultCount: 2, resultIndex: 1 }
+        ]);
         assert.deepStrictEqual(await page.evaluate(`window.search.findNext('abcd', { incremental: true, decorations: { activeMatchColorOverviewRuler: '#ff0000' } })`), false);
         assert.deepStrictEqual(await page.evaluate('window.calls'), [
           { resultCount: 3, resultIndex: 0 },
           { resultCount: 2, resultIndex: 0 },
           { resultCount: 2, resultIndex: 0 },
           { resultCount: 2, resultIndex: 1 },
+          { resultCount: 2, resultIndex: 1 },
           { resultCount: 0, resultIndex: -1 }
         ]);
       });
+      it('should fire with more than 1k matches', async () => {
+        await page.evaluate(`
+          window.calls = [];
+          window.search.onDidChangeResults(e => window.calls.push(e));
+        `);
+        const data = ('a bc'.repeat(10) + '\\n\\r').repeat(150);
+        await writeSync(page, data);
+        assert.strictEqual(await page.evaluate(`window.search.findNext('a', { decorations: { activeMatchColorOverviewRuler: '#ff0000' } })`), true);
+        assert.deepStrictEqual(await page.evaluate('window.calls'), [
+          { resultCount: 1000, resultIndex: 0 }
+        ]);
+        assert.strictEqual(await page.evaluate(`window.search.findNext('a', { decorations: { activeMatchColorOverviewRuler: '#ff0000' } })`), true);
+        assert.deepStrictEqual(await page.evaluate('window.calls'), [
+          { resultCount: 1000, resultIndex: 0 },
+          { resultCount: 1000, resultIndex: 1 }
+        ]);
+        assert.strictEqual(await page.evaluate(`window.search.findNext('bc', { decorations: { activeMatchColorOverviewRuler: '#ff0000' } })`), true);
+        assert.deepStrictEqual(await page.evaluate('window.calls'), [
+          { resultCount: 1000, resultIndex: 0 },
+          { resultCount: 1000, resultIndex: 1 },
+          { resultCount: 1000, resultIndex: 1 }
+        ]);
+      });
+      it('should fire when writing to terminal', async () => {
+        await page.evaluate(`
+          window.calls = [];
+          window.search.onDidChangeResults(e => window.calls.push(e));
+        `);
+        await writeSync(page, 'abc bc c\\n\\r'.repeat(2));
+        assert.strictEqual(await page.evaluate(`window.search.findNext('abc', { decorations: { activeMatchColorOverviewRuler: '#ff0000' } })`), true);
+        assert.deepStrictEqual(await page.evaluate('window.calls'), [
+          { resultCount: 2, resultIndex: 0 }
+        ]);
+        await writeSync(page, 'abc bc c\\n\\r');
+        await timeout(300);
+        assert.deepStrictEqual(await page.evaluate('window.calls'), [
+          { resultCount: 2, resultIndex: 0 },
+          { resultCount: 3, resultIndex: 0 }
+        ]);
+      });
     });
     describe('findPrevious', () => {
       it('should not fire unless the decorations option is set', async () => {
@@ -233,6 +282,7 @@ describe('Search Tests', function (): void {
         assert.deepStrictEqual(await page.evaluate('window.calls'), [
           { resultCount: 1, resultIndex: 0 }
         ]);
+        await page.evaluate(`window.term.clearSelection()`);
         assert.strictEqual(await page.evaluate(`window.search.findPrevious('b', { decorations: { activeMatchColorOverviewRuler: '#ff0000' } })`), true);
         assert.deepStrictEqual(await page.evaluate('window.calls'), [
           { resultCount: 1, resultIndex: 0 },
@@ -262,7 +312,7 @@ describe('Search Tests', function (): void {
           window.calls = [];
           window.search.onDidChangeResults(e => window.calls.push(e));
         `);
-        await writeSync(page, 'abc aabc');
+        await writeSync(page, 'd abc aabc d');
         assert.deepStrictEqual(await page.evaluate(`window.search.findPrevious('a', { incremental: true, decorations: { activeMatchColorOverviewRuler: '#ff0000' } })`), true);
         assert.deepStrictEqual(await page.evaluate('window.calls'), [
           { resultCount: 3, resultIndex: 2 }
@@ -285,15 +335,64 @@ describe('Search Tests', function (): void {
           { resultCount: 2, resultIndex: 1 },
           { resultCount: 2, resultIndex: 0 }
         ]);
+        assert.deepStrictEqual(await page.evaluate(`window.search.findPrevious('d', { incremental: true, decorations: { activeMatchColorOverviewRuler: '#ff0000' } })`), true);
+        assert.deepStrictEqual(await page.evaluate('window.calls'), [
+          { resultCount: 3, resultIndex: 2 },
+          { resultCount: 2, resultIndex: 1 },
+          { resultCount: 2, resultIndex: 1 },
+          { resultCount: 2, resultIndex: 0 },
+          { resultCount: 2, resultIndex: 1 }
+        ]);
         assert.deepStrictEqual(await page.evaluate(`window.search.findPrevious('abcd', { incremental: true, decorations: { activeMatchColorOverviewRuler: '#ff0000' } })`), false);
         assert.deepStrictEqual(await page.evaluate('window.calls'), [
           { resultCount: 3, resultIndex: 2 },
           { resultCount: 2, resultIndex: 1 },
           { resultCount: 2, resultIndex: 1 },
           { resultCount: 2, resultIndex: 0 },
+          { resultCount: 2, resultIndex: 1 },
           { resultCount: 0, resultIndex: -1 }
         ]);
       });
+      it('should fire with more than 1k matches', async () => {
+        await page.evaluate(`
+          window.calls = [];
+          window.search.onDidChangeResults(e => window.calls.push(e));
+        `);
+        const data = ('a bc'.repeat(10) + '\\n\\r').repeat(150);
+        await writeSync(page, data);
+        assert.strictEqual(await page.evaluate(`window.search.findPrevious('a', { decorations: { activeMatchColorOverviewRuler: '#ff0000' } })`), true);
+        assert.deepStrictEqual(await page.evaluate('window.calls'), [
+          { resultCount: 1000, resultIndex: -1 }
+        ]);
+        assert.strictEqual(await page.evaluate(`window.search.findPrevious('a', { decorations: { activeMatchColorOverviewRuler: '#ff0000' } })`), true);
+        assert.deepStrictEqual(await page.evaluate('window.calls'), [
+          { resultCount: 1000, resultIndex: -1 },
+          { resultCount: 1000, resultIndex: -1 }
+        ]);
+        assert.strictEqual(await page.evaluate(`window.search.findPrevious('bc', { decorations: { activeMatchColorOverviewRuler: '#ff0000' } })`), true);
+        assert.deepStrictEqual(await page.evaluate('window.calls'), [
+          { resultCount: 1000, resultIndex: -1 },
+          { resultCount: 1000, resultIndex: -1 },
+          { resultCount: 1000, resultIndex: -1 }
+        ]);
+      });
+      it('should fire when writing to terminal', async () => {
+        await page.evaluate(`
+          window.calls = [];
+          window.search.onDidChangeResults(e => window.calls.push(e));
+        `);
+        await writeSync(page, 'abc bc c\\n\\r'.repeat(2));
+        assert.strictEqual(await page.evaluate(`window.search.findPrevious('abc', { decorations: { activeMatchColorOverviewRuler: '#ff0000' } })`), true);
+        assert.deepStrictEqual(await page.evaluate('window.calls'), [
+          { resultCount: 2, resultIndex: 1 }
+        ]);
+        await writeSync(page, 'abc bc c\\n\\r');
+        await timeout(300);
+        assert.deepStrictEqual(await page.evaluate('window.calls'), [
+          { resultCount: 2, resultIndex: 1 },
+          { resultCount: 3, resultIndex: 1 }
+        ]);
+      });
     });
   });
 

addons/xterm-addon-search/typings/xterm-addon-search.d.ts

@@ -75,10 +75,28 @@ declare module 'xterm-addon-search' {
     activeMatchColorOverviewRuler: string;
   }
 
+  /**
+   * Options for the search addon.
+   */
+  export interface ISearchAddonOptions {
+    /**
+     * Max number of matches highlighted when decorations are enabled.
+     * Defaults to 1000 highlighted matches
+     */
+    highlightLimit: number
+  }
+
   /**
    * An xterm.js addon that provides search functionality.
    */
   export class SearchAddon implements ITerminalAddon {
+
+    /**
+     * Creates a new search addon.
+     * @param options Options for the search addon.
+     */
+    constructor(options?: Partial<ISearchAddonOptions>);
+
     /**
      * Activates the addon
      * @param terminal The terminal the addon is being loaded in.
@@ -121,10 +139,8 @@ declare module 'xterm-addon-search' {
     /**
      * When decorations are enabled, fires when
      * the search results change.
-     * @returns -1 for resultIndex for a resultCount of 0
-     * and @returns undefined when the threshold of 1k results
-     * is exceeded and decorations are disposed of.
+     * @returns -1 for resultIndex when the threshold of matches is exceeded.
      */
-    readonly onDidChangeResults: IEvent<{ resultIndex: number, resultCount: number } | undefined>;
+    readonly onDidChangeResults: IEvent<{ resultIndex: number, resultCount: number }>;
   }
 }

addons/xterm-addon-serialize/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xterm-addon-serialize",
-  "version": "0.8.0",
+  "version": "0.11.0",
   "author": {
     "name": "The xterm.js authors",
     "url": "https://xtermjs.org/"

addons/xterm-addon-serialize/src/SerializeAddon.test.ts

@@ -7,9 +7,10 @@ import jsdom = require('jsdom');
 import { assert } from 'chai';
 import { SerializeAddon } from './SerializeAddon';
 import { Terminal } from 'browser/public/Terminal';
-import { ColorManager } from 'browser/ColorManager';
 import { SelectionModel } from 'browser/selection/SelectionModel';
 import { IBufferService } from 'common/services/Services';
+import { OptionsService } from 'common/services/OptionsService';
+import { ThemeService } from 'browser/services/ThemeService';
 
 function sgr(...seq: string[]): string {
   return `\x1b[${seq.join(';')}m`;
@@ -44,14 +45,11 @@ class TestSelectionService {
 }
 
 describe('xterm-addon-serialize', () => {
-  let cm: ColorManager;
   let dom: jsdom.JSDOM;
-  let document: Document;
   let window: jsdom.DOMWindow;
 
   let serializeAddon: SerializeAddon;
   let terminal: Terminal;
-  let selectionService: any;
 
   before(() => {
     serializeAddon = new SerializeAddon();
@@ -60,7 +58,6 @@ describe('xterm-addon-serialize', () => {
   beforeEach(() => {
     dom = new jsdom.JSDOM('');
     window = dom.window;
-    document = window.document;
 
     (window as any).HTMLCanvasElement.prototype.getContext = () => ({
       createLinearGradient(): any {
@@ -77,10 +74,8 @@ describe('xterm-addon-serialize', () => {
     terminal = new Terminal({ cols: 10, rows: 2, allowProposedApi: true });
     terminal.loadAddon(serializeAddon);
 
-    selectionService = new TestSelectionService((terminal as any)._core._bufferService);
-    cm = new ColorManager(document, false);
-    (terminal as any)._core._colorManager = cm;
-    (terminal as any)._core._selectionService = selectionService;
+    (terminal as any)._core._themeService = new ThemeService((terminal as any)._core.optionsService);
+    (terminal as any)._core._selectionService = new TestSelectionService((terminal as any)._core._bufferService);
   });
 
   describe('text', () => {
@@ -210,5 +205,25 @@ describe('xterm-addon-serialize', () => {
       });
       assert.equal((output.match(/color: #ffffff; background-color: #000000; font-family: courier-new, courier, monospace; font-size: 15px;/g) || []).length, 1, output);
     });
+
+    it('cells with custom color styling', async () => {
+      terminal.options.theme.black = '#ffa500';
+      terminal.options.theme = { ... terminal.options.theme };
+
+      await writeP(terminal, ' ' + sgr('38;5;0') + 'terminal' + sgr('39') + ' ');
+
+      const output = serializeAddon.serializeAsHTML();
+      assert.equal((output.match(/<span style='color: #ffa500;'>terminal<\/span>/g) || []).length, 1, output);
+    });
+
+    it('cells with color styling - xterm headless', async () => {
+      // a headless terminal doesn't have a themeservice
+      (terminal as any)._core._themeService = undefined;
+
+      await writeP(terminal, ' ' + sgr('38;5;46') + 'terminal' + sgr('39') + ' ');
+
+      const output = serializeAddon.serializeAsHTML();
+      assert.equal((output.match(/<span style='color: #00ff00;'>terminal<\/span>/g) || []).length, 1, output);
+    });
   });
 });

addons/xterm-addon-serialize/src/SerializeAddon.ts

@@ -5,9 +5,9 @@
  * (EXPERIMENTAL) This Addon is still under development
  */
 
-import { Terminal, ITerminalAddon, IBuffer, IBufferCell, IBufferRange } from 'xterm';
-import { IColorSet } from 'browser/Types';
-import { IAttributeData } from 'common/Types';
+import { DEFAULT_ANSI_COLORS } from 'browser/services/ThemeService';
+import { IAttributeData, IColor } from 'common/Types';
+import { IBuffer, IBufferCell, IBufferRange, ITerminalAddon, Terminal } from 'xterm';
 
 function constrain(value: number, low: number, high: number): number {
   return Math.max(low, Math.min(value, high));
@@ -77,6 +77,7 @@ function equalFlags(cell1: IBufferCell | IAttributeData, cell2: IBufferCell): bo
   return cell1.isInverse() === cell2.isInverse()
     && cell1.isBold() === cell2.isBold()
     && cell1.isUnderline() === cell2.isUnderline()
+    && cell1.isOverline() === cell2.isOverline()
     && cell1.isBlink() === cell2.isBlink()
     && cell1.isInvisible() === cell2.isInvisible()
     && cell1.isItalic() === cell2.isItalic()
@@ -129,7 +130,8 @@ class StringSerializeHandler extends BaseSerializeHandler {
   private _thisRowLastSecondChar: IBufferCell = this._buffer.getNullCell();
   private _nextRowFirstChar: IBufferCell = this._buffer.getNullCell();
   protected _rowEnd(row: number, isLastRow: boolean): void {
-    // if there is colorful empty cell at line end, whe must pad it back, or the the color block will missing
+    // if there is colorful empty cell at line end, whe must pad it back, or the the color block
+    // will missing
     if (this._nullCellCount > 0 && !equalBg(this._cursorStyle, this._backgroundCell)) {
       // use clear right to set background.
       this._currentRow += `\u001b[${this._nullCellCount}X`;
@@ -264,6 +266,7 @@ class StringSerializeHandler extends BaseSerializeHandler {
           if (cell.isInverse() !== oldCell.isInverse()) { sgrSeq.push(cell.isInverse() ? 7 : 27); }
           if (cell.isBold() !== oldCell.isBold()) { sgrSeq.push(cell.isBold() ? 1 : 22); }
           if (cell.isUnderline() !== oldCell.isUnderline()) { sgrSeq.push(cell.isUnderline() ? 4 : 24); }
+          if (cell.isOverline() !== oldCell.isOverline()) { sgrSeq.push(cell.isOverline() ? 53 : 55); }
           if (cell.isBlink() !== oldCell.isBlink()) { sgrSeq.push(cell.isBlink() ? 5 : 25); }
           if (cell.isInvisible() !== oldCell.isInvisible()) { sgrSeq.push(cell.isInvisible() ? 8 : 28); }
           if (cell.isItalic() !== oldCell.isItalic()) { sgrSeq.push(cell.isItalic() ? 3 : 23); }
@@ -289,7 +292,8 @@ class StringSerializeHandler extends BaseSerializeHandler {
 
     const sgrSeq = this._diffStyle(cell, this._cursorStyle);
 
-    // the empty cell style is only assumed to be changed when background changed, because foreground is always 0.
+    // the empty cell style is only assumed to be changed when background changed, because
+    // foreground is always 0.
     const styleChanged = isEmptyCell ? !equalBg(this._cursorStyle, cell) : sgrSeq.length > 0;
 
     /**
@@ -410,8 +414,6 @@ class StringSerializeHandler extends BaseSerializeHandler {
 export class SerializeAddon implements ITerminalAddon {
   private _terminal: Terminal | undefined;
 
-  constructor() { }
-
   public activate(terminal: Terminal): void {
     this._terminal = terminal;
   }
@@ -534,7 +536,7 @@ export class HTMLSerializeHandler extends BaseSerializeHandler {
 
   private _htmlContent = '';
 
-  private _colors: IColorSet;
+  private _ansiColors: Readonly<IColor[]>;
 
   constructor(
     buffer: IBuffer,
@@ -543,8 +545,13 @@ export class HTMLSerializeHandler extends BaseSerializeHandler {
   ) {
     super(buffer);
 
-    // https://github.com/xtermjs/xterm.js/issues/3601
-    this._colors = (_terminal as any)._core._colorManager.colors;
+    // For xterm headless: fallback to ansi colors
+    if ((_terminal as any)._core._themeService) {
+      this._ansiColors = (_terminal as any)._core._themeService.colors.ansi;
+    }
+    else {
+      this._ansiColors = DEFAULT_ANSI_COLORS;
+    }
   }
 
   private _padStart(target: string, targetLength: number, padString: string): string {
@@ -600,7 +607,7 @@ export class HTMLSerializeHandler extends BaseSerializeHandler {
       return rgb.map(x => this._padStart(x.toString(16), 2, '0')).join('');
     }
     if (isFg ? cell.isFgPalette() : cell.isBgPalette()) {
-      return this._colors.ansi[color].css;
+      return this._ansiColors[color].css;
     }
     return undefined;
   }
@@ -625,7 +632,9 @@ export class HTMLSerializeHandler extends BaseSerializeHandler {
 
       if (cell.isInverse()) { content.push('color: #000000; background-color: #BFBFBF;'); }
       if (cell.isBold()) { content.push('font-weight: bold;'); }
-      if (cell.isUnderline()) { content.push('text-decoration: underline;'); }
+      if (cell.isUnderline() && cell.isOverline()) { content.push('text-decoration: overline underline;'); }
+      else if (cell.isUnderline()) { content.push('text-decoration: underline;'); }
+      else if (cell.isOverline()) { content.push('text-decoration: overline;'); }
       if (cell.isBlink()) { content.push('text-decoration: blink;'); }
       if (cell.isInvisible()) { content.push('visibility: hidden;'); }
       if (cell.isItalic()) { content.push('font-style: italic;'); }

addons/xterm-addon-serialize/test/SerializeAddon.api.ts

@@ -5,7 +5,7 @@
 
 import { assert } from 'chai';
 import { openTerminal, writeSync, launchBrowser } from '../../../out-test/api/TestUtils';
-import { Browser, Page } from 'playwright';
+import { Browser, Page } from '@playwright/test';
 
 const APP = 'http://127.0.0.1:3001/test';
 
@@ -204,7 +204,6 @@ describe('SerializeAddon', () => {
       sgr(NO_INVISIBLE) + line,
       sgr(NO_STRIKETHROUGH) + line
     ];
-    const rows = lines.length;
     await writeSync(page, lines.join('\\r\\n'));
     assert.equal(await page.evaluate(`serializeAddon.serialize();`), lines.join('\r\n'));
   });
@@ -220,6 +219,18 @@ describe('SerializeAddon', () => {
     assert.equal(await page.evaluate(`serializeAddon.serialize();`), lines.join('\r\n'));
   });
 
+  it('serialize all rows of content with overline', async () => {
+    const cols = 10;
+    const line = '+'.repeat(cols);
+    const lines: string[] = [
+      sgr(OVERLINED) + line,                   // Overlined
+      sgr(UNDERLINED) + line,                  // Overlined, Underlined
+      sgr(NORMAL) + line                       // Normal
+    ];
+    await writeSync(page, lines.join('\\r\\n'));
+    assert.equal(await page.evaluate(`serializeAddon.serialize();`), lines.join('\r\n'));
+  });
+
   it('serialize all rows of content with color16 and style separately', async function(): Promise<any> {
     const cols = 10;
     const line = '+'.repeat(cols);
@@ -581,7 +592,6 @@ const FG_RGB_GREEN = '38;2;0;255;0';
 const FG_RGB_YELLOW = '38;2;255;255;0';
 const FG_RESET = '39';
 
-
 const BG_P16_RED = '41';
 const BG_P16_GREEN = '42';
 const BG_P16_YELLOW = '43';
@@ -601,6 +611,7 @@ const BLINK = '5';
 const INVERSE = '7';
 const INVISIBLE = '8';
 const STRIKETHROUGH = '9';
+const OVERLINED = '53';
 
 const NO_BOLD = '22';
 const NO_DIM = '22';
@@ -610,3 +621,4 @@ const NO_BLINK = '25';
 const NO_INVERSE = '27';
 const NO_INVISIBLE = '28';
 const NO_STRIKETHROUGH = '29';
+const NO_OVERLINED = '55';