Document Alt+- keyboard issue investigation with comprehensive tests

Co-authored-by: Tyriar <2193314+Tyriar@users.noreply.github.com>
Add comprehensive tests for Alt+- keyboard handling
2025-08-24 13:08:56 +00:00 · 2025-08-24 13:04:42 +00:00 · 2025-08-24 12:47:20 +00:00
704 changed files with 33805 additions and 44935 deletions
@@ -1,28 +0,0 @@
---
-name: benchmark
-description: Run and author benchmark tests in xterm.js. Use when editing benchmark files, working in `*.benchmark.ts`, or when asked how to run the full benchmark suite, a single benchmark file, or a single benchmark case.
---
-
-# Benchmark Run Instructions
-
-## Running Benchmarks
-
- Full suite: `npm run benchmark`
- Single benchmark file:
-  - Tree: `npm run benchmark -- -t out-test/benchmark/Event.benchmark.js`
-  - Run file: `npm run benchmark -- -s "out-test/benchmark/Event.benchmark.js" out-test/benchmark/Event.benchmark.js`
- Single context/case:
-  - Use `-t` to get the path, then:
-  - `npm run benchmark -- -s "<path>" out-test/benchmark/Event.benchmark.js`
-
-## Benchmark Case Selection
-
-When writing benchmark instructions:
-
- Use `RuntimeCase` to measure pure runtime in ms.
- Use `ThroughputRuntimeCase` when measuring throughput in MB/s.
-
-## Notes
-
- Benchmarks run from built JS in `out-test/benchmark/*.benchmark.js`.
- Keep `NODE_PATH=./out` (handled by the npm script).
@@ -1,12 +0,0 @@
---
-name: unit-test
-description: Write and review xterm.js unit tests with project conventions. Use when editing `*.test.ts` files or when asked for test authoring guidelines.
---
-
-# Unit Test Instructions
-
-When writing unit tests, follow these rules:
-
- When writing unit tests for addons, always create a real xterm.js instance instead of mocking it.
- Prefer `assert.ok` over `assert.notStrictEqual` when checking something is undefined or not.
- Avoid comments as most tests should be self-documenting.
@@ -1,15 +1,15 @@
 {
  "name": "xterm.js",
-  "image": "mcr.microsoft.com/devcontainers/typescript-node:22-bookworm",
+  "image": "mcr.microsoft.com/devcontainers/typescript-node:18-bookworm",
  "features": {
    "ghcr.io/devcontainers/features/node:1": {
-      "version": 22
+      "version": 18
    } // yarn
  },
  "forwardPorts": [
    3000
  ],
-  "postCreateCommand": "npm install && npm run setup",
+  "postCreateCommand": "yarn install && yarn setup",
  "customizations": {
    "vscode": {
      "extensions": [
@@ -5,6 +5,7 @@ indent_style = space
 indent_size = 2
 insert_final_newline = true
 trim_trailing_whitespace = true
+end_of_line = lf

 [*.{j,t}s]
 max_line_length = 100
@@ -0,0 +1,273 @@
+{
+  "env": {
+    "browser": true,
+    "es2021": true,
+    "node": true
+  },
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "project": [
+      "demo/tsconfig.json",
+      "src/browser/tsconfig.json",
+      "src/common/tsconfig.json",
+      "src/headless/tsconfig.json",
+      "src/vs/tsconfig.json",
+      "test/benchmark/tsconfig.json",
+      "test/playwright/tsconfig.json",
+      "addons/addon-attach/src/tsconfig.json",
+      "addons/addon-attach/test/tsconfig.json",
+      "addons/addon-clipboard/src/tsconfig.json",
+      "addons/addon-clipboard/test/tsconfig.json",
+      "addons/addon-fit/src/tsconfig.json",
+      "addons/addon-fit/test/tsconfig.json",
+      "addons/addon-image/src/tsconfig.json",
+      "addons/addon-image/test/tsconfig.json",
+      "addons/addon-ligatures/src/tsconfig.json",
+      "addons/addon-progress/src/tsconfig.json",
+      "addons/addon-progress/test/tsconfig.json",
+      "addons/addon-search/src/tsconfig.json",
+      "addons/addon-search/test/tsconfig.json",
+      "addons/addon-serialize/src/tsconfig.json",
+      "addons/addon-serialize/test/tsconfig.json",
+      "addons/addon-serialize/benchmark/tsconfig.json",
+      "addons/addon-unicode11/src/tsconfig.json",
+      "addons/addon-unicode11/test/tsconfig.json",
+      "addons/addon-unicode-graphemes/src/tsconfig.json",
+      "addons/addon-unicode-graphemes/test/tsconfig.json",
+      "addons/addon-unicode-graphemes/benchmark/tsconfig.json",
+      "addons/addon-web-links/src/tsconfig.json",
+      "addons/addon-web-links/test/tsconfig.json",
+      "addons/addon-webgl/src/tsconfig.json",
+      "addons/addon-webgl/test/tsconfig.json"
+    ],
+    "sourceType": "module"
+  },
+  "ignorePatterns": [
+    "addons/*/src/third-party/*.ts",
+    "src/vs/*",
+    "out/*",
+    "out-test/*",
+    "out-esbuild/*",
+    "out-esbuild-test/*",
+    "**/inwasm-sdks/*",
+    "**/typings/*.d.ts",
+    "**/node_modules",
+    "**/*.js",
+    "**/*.mjs"
+  ],
+  "plugins": [
+    "@stylistic/ts",
+    "@typescript-eslint",
+    "jsdoc"
+  ],
+  "rules": {
+    "@stylistic/ts/indent": [
+      "warn",
+      2
+    ],
+    "@stylistic/ts/semi": [
+      "warn",
+      "always"
+    ],
+    "@stylistic/ts/quotes": [
+      "warn",
+      "single",
+      { "allowTemplateLiterals": true }
+    ],
+
+    "@typescript-eslint/array-type": [
+      "warn",
+      {
+        "default": "array",
+        "readonly": "generic"
+      }
+    ],
+    "@typescript-eslint/consistent-type-assertions": "warn",
+    "@typescript-eslint/consistent-type-definitions": "warn",
+    "@typescript-eslint/explicit-function-return-type": [
+      "warn",
+      {
+        "allowExpressions": true
+      }
+    ],
+    "@typescript-eslint/explicit-member-accessibility": [
+      "warn",
+      {
+        "accessibility": "explicit",
+        "overrides": {
+          "constructors": "off"
+        }
+      }
+    ],
+    "@typescript-eslint/member-delimiter-style": [
+      "warn",
+      {
+        "multiline": {
+          "delimiter": "semi",
+          "requireLast": true
+        },
+        "singleline": {
+          "delimiter": "comma",
+          "requireLast": false
+        }
+      }
+    ],
+    "@typescript-eslint/naming-convention": [
+      "warn",
+      { "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"] },
+      // memberLike
+      { "selector": "memberLike", "modifiers": ["private"], "format": ["camelCase"], "leadingUnderscore": "require" },
+      { "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"],
+        "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",
+
+    "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,
+    "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": [
+      "warn",
+      {
+        "allowElseIf": false
+      }
+    ],
+    "no-eval": "warn",
+    "no-extra-semi": "error",
+    "no-irregular-whitespace": "warn",
+    "no-restricted-imports": [
+      "warn",
+      {
+        "patterns": [
+          ".*\\/out\\/.*"
+        ]
+      }
+    ],
+    "no-restricted-syntax": [
+      "warn",
+      {
+        "selector": "CallExpression[callee.name='requestAnimationFrame']",
+        "message": "The global requestAnimationFrame() should be avoided, call it on the parent window from ICoreBrowserService."
+      },
+      {
+        "selector": "CallExpression[callee.name='cancelAnimationFrame']",
+        "message": "The global cancelAnimationFrame() should be avoided, call it on the parent window from ICoreBrowserService."
+      },
+      {
+        "selector": "CallExpression > MemberExpression[object.name='window'][property.name='requestAnimationFrame']",
+        "message": "window.requestAnimationFrame() should be avoided, call it on the parent window from ICoreBrowserService."
+      },
+      {
+        "selector": "CallExpression > MemberExpression[object.name='window'][property.name='cancelAnimationFrame']",
+        "message": "window.cancelAnimationFrame() should be avoided, call it on the parent window from ICoreBrowserService."
+      },
+      {
+        "selector": "MemberExpression[object.name='window'][property.name='devicePixelRatio']",
+        "message": "window.devicePixelRatio should be avoided, get it from ICoreBrowserService."
+      }
+    ],
+    "no-trailing-spaces": "warn",
+    "no-unsafe-finally": "warn",
+    "no-unused-vars": ["warn", {
+      "vars": "all",
+      "args": "none"
+    }],
+    "no-var": "warn",
+    "one-var": [
+      "warn",
+      "never"
+    ],
+    "object-curly-spacing": [
+      "warn",
+      "always"
+    ],
+    "prefer-const": "warn",
+    "spaced-comment": [
+      "warn",
+      "always",
+      {
+        "markers": ["/"],
+        "exceptions": ["-"]
+      }
+    ]
+  },
+  "overrides": [
+    {
+      "files": [
+        "**/*.api.ts",
+        "**/*.test.ts"
+      ],
+      "rules": {
+        "object-curly-spacing": "off",
+        "max-len": "off",
+        "no-unused-vars": "off"
+      }
+    }
+  ]
+}
@@ -0,0 +1,107 @@
+{
+  "env": {
+    "browser": true,
+    "es2021": true,
+    "node": true
+  },
+  "parser": "@typescript-eslint/parser",
+  "plugins": [
+    "@stylistic/ts",
+    "@typescript-eslint",
+    "jsdoc"
+  ],
+  "rules": {
+    "@stylistic/ts/indent": [
+      "warn",
+      2
+    ],
+    "@stylistic/ts/semi": [
+      "warn",
+      "always"
+    ],
+    "@stylistic/ts/quotes": [
+      "warn",
+      "single",
+      { "allowTemplateLiterals": true }
+    ],
+
+    "@typescript-eslint/array-type": [
+      "warn",
+      {
+        "default": "array",
+        "readonly": "generic"
+      }
+    ],
+    "@typescript-eslint/explicit-function-return-type": [
+      "warn",
+      {
+        "allowExpressions": true
+      }
+    ],
+    "@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",
+
+    "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-extra-semi": "error",
+    "no-irregular-whitespace": "warn",
+    "no-trailing-spaces": "warn",
+    "object-curly-spacing": [
+      "warn",
+      "always"
+    ],
+    "spaced-comment": [
+      "warn",
+      "always",
+      {
+        "markers": ["/"],
+        "exceptions": ["-"]
+      }
+    ]
+  }
+}
@@ -0,0 +1,10 @@
+This is a TypeScript-based repository with a Ruby client for certain API endpoints. It includes several sub projects called addons which are built separately. It contains a demo application which showcases the functionality of the project.
+
+Please follow these guidelines when contributing:
+
+## Development Flow
+
+- Install dependencies: `npm install && npm run setup`
+- Build and bundle demo: `npm run build && npm run esbuild`
+- Run unit tests: `npm run test-unit`
+- Run playwright-based integration tests: `npm run test-integration`
@@ -12,17 +12,17 @@ jobs:
    timeout-minutes: 10
    steps:
    - uses: actions/checkout@v3
-    - name: Use Node.js 22.x
+    - name: Use Node.js 18.x
      uses: actions/setup-node@v3
      with:
-        node-version: 22.x
-        cache: 'npm'
+        node-version: 18.x
+        cache: 'yarn'
    - name: Install dependencies
-      run: npm ci
+      run: yarn --frozen-lockfile
    - name: Setup and run tsc
-      run: npm run setup
+      run: yarn setup
    - name: Esbuild
-      run: npm run esbuild
+      run: yarn esbuild
    - name: Zip artifacts
      run: |
        zip -r compressed-build \
@@ -62,9 +62,6 @@ jobs:
          ./addons/addon-web-links/lib/* \
          ./addons/addon-web-links/out/* \
          ./addons/addon-web-links/out-*/* \
-          ./addons/addon-web-fonts/lib/* \
-          ./addons/addon-web-fonts/out/* \
-          ./addons/addon-web-fonts/out-*/* \
          ./addons/addon-webgl/lib/* \
          ./addons/addon-webgl/out/* \
          ./addons/addon-webgl/out-*st/*
@@ -80,20 +77,21 @@ jobs:
    timeout-minutes: 10
    steps:
    - uses: actions/checkout@v3
-    - name: Use Node.js 22.x
+    - name: Use Node.js 18.x
      uses: actions/setup-node@v3
      with:
-        node-version: 22.x
-        cache: 'npm'
+        node-version: 18.x
+        cache: 'yarn'
    - name: Install dependencies
      run: |
-        npm ci
+        yarn --frozen-lockfile
+        yarn install-addons
    - name: Lint code
      env:
        NODE_OPTIONS: --max_old_space_size=4096
-      run: npm run lint
+      run: yarn lint
    - name: Lint API
-      run: npm run lint-api
+      run: yarn lint-api

  test-unit-coverage:
    needs: build
@@ -101,14 +99,15 @@ jobs:
    timeout-minutes: 10
    steps:
    - uses: actions/checkout@v3
-    - name: Use Node.js 22.x
+    - name: Use Node.js 18.x
      uses: actions/setup-node@v3
      with:
-        node-version: 22.x
-        cache: 'npm'
+        node-version: 18.x
+        cache: 'yarn'
    - name: Install dependencies
      run: |
-        npm ci
+        yarn --frozen-lockfile
+        yarn install-addons
    - uses: actions/download-artifact@v4
      with:
        name: build-artifacts
@@ -123,7 +122,7 @@ jobs:
        ls -R
    - name: Unit test coverage
      run: |
-        npm run test-unit-coverage --forbid-only
+        yarn test-unit-coverage --forbid-only
        EXIT_CODE=$?
        ./node_modules/.bin/nyc report --reporter=cobertura
        exit $EXIT_CODE
@@ -132,7 +131,7 @@ jobs:
    timeout-minutes: 20
    strategy:
      matrix:
-        node-version: [22]
+        node-version: [18]
        runs-on: [ubuntu, macos, windows]
    runs-on: ${{ matrix.runs-on }}-latest
    steps:
@@ -141,10 +140,11 @@ jobs:
      uses: actions/setup-node@v3
      with:
        node-version: ${{ matrix.node-version }}.x
-        cache: 'npm'
+        cache: 'yarn'
    - name: Install dependencies
      run: |
-        npm ci
+        yarn --frozen-lockfile
+        yarn install-addons
    - name: Wait for build job
      uses: NathanFirmo/wait-for-other-job@v1.1.1
      with:
@@ -163,13 +163,13 @@ jobs:
        fi
        ls -R
    - name: Unit tests
-      run: npm run test-unit --forbid-only
+      run: yarn test-unit --forbid-only

  test-integration:
    timeout-minutes: 20
    strategy:
      matrix:
-        node-version: [22] # just one as integration tests are about testing in browser
+        node-version: [18] # just one as integration tests are about testing in browser
        runs-on: [ubuntu-22.04] # macos is flaky
        browser: [chromium, firefox, webkit]
    runs-on: ${{ matrix.runs-on }}
@@ -179,10 +179,11 @@ jobs:
      uses: actions/setup-node@v3
      with:
        node-version: ${{ matrix.node-version }}.x
-        cache: 'npm'
+        cache: 'yarn'
    - name: Install dependencies
      run: |
-        npm ci
+        yarn --frozen-lockfile
+        yarn install-addons
    - name: Install playwright
      run: npx playwright install --with-deps ${{ matrix.browser }}
    - name: Wait for build job
@@ -202,53 +203,50 @@ jobs:
          unzip -o compressed-build.zip
        fi
        ls -R
-    - name: Build demo client
-      run: npm run esbuild-demo-client
-    - name: Build demo server
-      run: npm run esbuild-demo-server
+    - name: Build demo
+      run: yarn esbuild-demo
    - name: Integration tests (core) # Tests use 50% workers to reduce flakiness
-      run: npm run test-integration-${{ matrix.browser }} -- --workers=50% --forbid-only --suite=core
+      run: yarn test-integration-${{ matrix.browser }} --workers=50% --forbid-only --suite=core
    - name: Integration tests (addon-attach)
-      run: npm run test-integration-${{ matrix.browser }} -- --workers=50% --forbid-only --suite=addon-attach
+      run: yarn test-integration-${{ matrix.browser }} --workers=50% --forbid-only --suite=addon-attach
    - name: Integration tests (addon-clipboard)
-      run: npm run test-integration-${{ matrix.browser }} -- --workers=50% --forbid-only --suite=addon-clipboard
+      run: yarn test-integration-${{ matrix.browser }} --workers=50% --forbid-only --suite=addon-clipboard
    - name: Integration tests (addon-fit)
-      run: npm run test-integration-${{ matrix.browser }} -- --workers=50% --forbid-only --suite=addon-fit
+      run: yarn test-integration-${{ matrix.browser }} --workers=50% --forbid-only --suite=addon-fit
    - name: Integration tests (addon-image)
-      run: npm run test-integration-${{ matrix.browser }} -- --workers=50% --forbid-only --suite=addon-image
+      run: yarn test-integration-${{ matrix.browser }} --workers=50% --forbid-only --suite=addon-image
    - name: Integration tests (addon-progress)
-      run: npm run test-integration-${{ matrix.browser }} -- --workers=50% --forbid-only --suite=addon-progress
+      run: yarn test-integration-${{ matrix.browser }} --workers=50% --forbid-only --suite=addon-progress
    - name: Integration tests (addon-search)
-      run: npm run test-integration-${{ matrix.browser }} -- --workers=50% --forbid-only --suite=addon-search
+      run: yarn test-integration-${{ matrix.browser }} --workers=50% --forbid-only --suite=addon-search
    - name: Integration tests (addon-serialize)
-      run: npm run test-integration-${{ matrix.browser }} -- --workers=50% --forbid-only --suite=addon-serialize
+      run: yarn test-integration-${{ matrix.browser }} --workers=50% --forbid-only --suite=addon-serialize
    - name: Integration tests (addon-unicode-graphemes)
-      run: npm run test-integration-${{ matrix.browser }} -- --workers=50% --forbid-only --suite=addon-unicode-graphemes
+      run: yarn test-integration-${{ matrix.browser }} --workers=50% --forbid-only --suite=addon-unicode-graphemes
    - name: Integration tests (addon-unicode11)
-      run: npm run test-integration-${{ matrix.browser }} -- --workers=50% --forbid-only --suite=addon-unicode11
-    - name: Integration tests (addon-web-fonts)
-      run: npm run test-integration-${{ matrix.browser }} -- --workers=50% --forbid-only --suite=addon-web-fonts
+      run: yarn test-integration-${{ matrix.browser }} --workers=50% --forbid-only --suite=addon-unicode11
    - name: Integration tests (addon-web-links)
-      run: npm run test-integration-${{ matrix.browser }} -- --workers=50% --forbid-only --suite=addon-web-links
+      run: yarn test-integration-${{ matrix.browser }} --workers=50% --forbid-only --suite=addon-web-links
    - name: Integration tests (addon-webgl)
-      run: npm run test-integration-${{ matrix.browser }} -- --workers=50% --forbid-only --suite=addon-webgl
+      run: yarn test-integration-${{ matrix.browser }} --workers=50% --forbid-only --suite=addon-webgl

  release-dry-run:
    needs: build
    runs-on: ubuntu-latest
    strategy:
      matrix:
-        node-version: [22]
+        node-version: [18]
    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: 'npm'
+        cache: 'yarn'
    - name: Install dependencies
      run: |
-        npm ci
+        yarn --frozen-lockfile
+        yarn install-addons
    - name: Install playwright
      run: npx playwright install
    - uses: actions/download-artifact@v4
@@ -265,7 +263,7 @@ jobs:
        ls -R
    - name: Package headless
      run: |
-        npm run package-headless
+        yarn package-headless
        node ./bin/package_headless.js
    - name: Publish to npm (dry run)
      run: node ./bin/publish.js --dry
@@ -19,14 +19,18 @@ jobs:
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
-      - name: Use Node.js 22.x
+
+      - name: Use Node.js 20.x
        uses: actions/setup-node@v3
        with:
-          node-version: 22.x
-          cache: 'npm'
+          node-version: 20.x
+          cache: 'yarn'
+
      - name: Install dependencies
-        run: npm ci
+        run: yarn --frozen-lockfile
+
      - name: Setup and run tsc
-        run: npm run setup
+        run: yarn setup
+
      - name: Esbuild
-        run: npm run esbuild
+        run: yarn esbuild
@@ -11,18 +11,18 @@ jobs:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
-    - name: Use Node.js 22.x
+    - name: Use Node.js 18.x
      uses: actions/setup-node@v3
      with:
-        node-version: 22.x
-        cache: 'npm'
+        node-version: 18.x
+        cache: 'yarn'
    - name: Install dependencies
-      run: npm ci
+      run: yarn --frozen-lockfile
    - name: Build
-      run: npm run setup
+      run: yarn setup
    - name: Package headless
      run: |
-        npm run package-headless
+        yarn package-headless
        node ./bin/package_headless.js
    - name: Publish to npm
      env:
@@ -3,7 +3,6 @@ node_modules/
 .lock-wscript
 lib/
 out/
-out-demo/
 out-test/
 out-esbuild/
 out-esbuild-test/
@@ -19,12 +18,7 @@ npm-debug.log
 .env
 build/
 .DS_Store
-yarn.lock
-test-results/
-
-# Tracing/debug files
-.cursor/nal-trace/
-.cursor/*.log
+package-lock.json

 # Keep bundled code out of Git
 dist/
@@ -0,0 +1,7 @@
+Antonis Kalipetis <akalipetis@sourcelair.com>
+Antonis Kalipetis <akalipetis@sourcelair.com> <akalipetis@gmail.com>
+Daniel Imms <daimms@microsoft.com> <tyriar@tyriar.com>
+Paris Kasidiaris <paris@sourcelair.com>
+Paris Kasidiaris <pariskasidiaris@gmail.com>
+Thanasis Daglis <thanasis@sourcelair.com>
+Thanasis Daglis <thanasis@sourcelair.com> <ath.daglis@gmail.com>
@@ -0,0 +1 @@
+NODE_PATH=./out
@@ -0,0 +1,5 @@
+require:
+  - source-map-support/register
+reporter: spec
+color: true
+check-leaks: true
@@ -0,0 +1 @@
+package-lock=false
@@ -1 +1 @@
-22
+18
@@ -1,5 +0,0 @@
-{
-    "recommendations": [
-        "dbaeumer.vscode-eslint"
-    ]
-}
@@ -61,7 +61,7 @@
      "runtimeExecutable": "npm",
      "runtimeArgs": ["start"],
      "stopOnEntry": true,
-      "runtimeVersion": "22",
+      "runtimeVersion": "18",
      "serverReadyAction": {
        "action": "openExternally",
        "pattern": "App listening to (http://.*?:[0-9]+)"
@@ -1,4 +1,23 @@
 {
+  "files.associations": {
+    ".eslintrc.json.typings": "jsonc"
+  },
+  "files.exclude": {
+    "**/.nyc_output": true
+  },
  "typescript.preferences.importModuleSpecifier": "non-relative",
-  "typescript.preferences.quoteStyle": "single"
+  "typescript.preferences.quoteStyle": "single",
+  "mochaExplorer.envPath": ".mocha.env",
+  "mochaExplorer.files": [
+    "out/**/*.test.js",
+    "addons/**/out/*.test.js",
+    "out-*/**/*.test.js",
+    "addons/**/out-*/*.test.js"
+  ],
+  "mochaExplorer.watch": [
+    "out/**/*.js",
+    "addons/**/out/*.js",
+    "out-*/**/*.js",
+    "addons/**/out-*/*.js"
+  ]
 }
@@ -10,22 +10,13 @@
  "tasks": [
    // Compound tasks
    {
-      "label": "dev",
-      "detail": "Runs all tasks required to run the demo in a single terminal using concurrently. This does not support problem matching.",
-      "type": "npm",
-      "script": "dev",
-      "isBackground": true,
+      "label": "Development",
+      "dependsOn": ["demo-server", "tsc", "esbuild", "esbuild-demo"],
      "group": {
        "kind": "build",
        "isDefault": true
      }
    },
-    {
-      "label": "dev (separate terminals)",
-      "detail": "Runs all tasks required to run the demo in separate terminals. This does support problem matching.",
-      "dependsOn": ["demo-server", "tsc", "esbuild", "esbuild-demo-client", "esbuild-demo-server"],
-      "group": "build"
-    },

    // Demo
    {
@@ -64,21 +55,9 @@
      }
    },
    {
-      "label": "esbuild-demo-client",
+      "label": "esbuild-demo",
      "type": "npm",
-      "script": "esbuild-demo-client-watch",
-      "dependsOn": ["esbuild", "tsc"],
-      "group": "build",
-      "isBackground": true,
-      "problemMatcher": "$esbuild-watch",
-      "presentation": {
-        "group": "xterm-demo"
-      }
-    },
-    {
-      "label": "esbuild-demo-server",
-      "type": "npm",
-      "script": "esbuild-demo-server-watch",
+      "script": "esbuild-demo-watch",
      "dependsOn": ["esbuild", "tsc"],
      "group": "build",
      "isBackground": true,
@@ -1,115 +0,0 @@
-# xterm.js Copilot Instructions
-
-## Architecture Overview
-
-**Core Structure**: xterm.js is a multi-target terminal emulator with these main source areas:
- `src/primitives/`: Building blocks (buffer, parser, input, data, utilities); TypeScript project `src/primitives/tsconfig.json`
- `src/runtime/`: Services, `CoreTerminal`, `InputHandler`, public API adapters; TypeScript project `src/runtime/tsconfig.json`
- `src/target-browser/`: Browser terminal with DOM rendering
- `src/target-headless/`: Node terminal without DOM
-
-See `src/ARCHITECTURE.md` for the dependency graph and import-path conventions (`common/*`, `target-browser/*`, `target-headless/*`).
-
-**Key Classes**:
- `Terminal` (browser/headless): Public API wrapper
- `CoreTerminal` (common): Core terminal logic and state
- `CoreBrowserTerminal` (browser): Browser-specific terminal implementation
-
-## Development Workflow
-
-**Build System**:
-```bash
-npm run build && npm run esbuild # Build all TypeScript and bundle
-```
-
-**Testing**:
- Unit tests: `npm run test-unit` (Mocha)
- Unit tests filtering to file: `npm run test-unit -- **/fileName.ts
- Per-addon unit tests: `npm run test-unit -- addons/addon-image/out-esbuild/*.test.js`
- Integration tests: `npm run test-integration` (Playwright across Chrome/Firefox/WebKit)
- Integration tests by file: `npm run test-integration -- test/playwright/InputHandler.test.ts`. Never use grep to filter tests, it doesn't work
- Integration tests by addon: `npm run test-integration -- --suite=addon-search`. Suites always follow the format `addon-<something>`
- Lint changes: `npm run lint-changes` to lint only changed files, `npm run lint-changes-fix` to fix them
-
-## Addon Development Pattern
-
-All addons follow this structure:
-```typescript
-export class MyAddon implements ITerminalAddon {
-  activate(terminal: Terminal): void {
-    // Called when loaded via terminal.loadAddon()
-    // Register handlers, access terminal APIs
-  }
-  dispose(): void {
-    // Cleanup when addon is disposed
-  }
-}
-```
-
-**Key Examples**:
- `addons/addon-fit/`: Terminal sizing
- `addons/addon-webgl/`: GPU-accelerated rendering
- `addons/addon-search/`: Text search functionality
-
-## Project-Specific Conventions
-
-**TypeScript Project Structure**: Uses TypeScript project references (`tsconfig.all.json`) for incremental builds across browser/headless/addons.
-
-**API Design**: 
- Browser and headless terminals share the same public API
- Proposed APIs require `allowProposedApi: true` option
- Constructor-only options (cols, rows) cannot be changed after instantiation
-
-**Disposable Management**:
- When a disposable object can be replaced over time, prefer a registered `MutableDisposable` over manual dispose/reassign logic.
- Register it on the owning class (for example, `this._register(new MutableDisposable())`) and assign through `.value`; this automatically disposes the previous value and avoids accidentally leaking resources.
-
-**TypeScript Constants**:
- Prefer `const enum` over top-level `const` declarations for primitive constants when appropriate, since values are inlined and avoid runtime property lookups.
-
-**Testing Utilities**: Use `TestUtils.ts` helpers:
- `openTerminal(ctx, options)` for setup
- `pollFor(page, fn, expectedValue)` for async assertions
- `writeSync(page, data)` for terminal input
-
-## Common Patterns
-
-**Parser Integration**: Register custom escape sequence handlers:
-```typescript
-terminal.parser.registerCsiHandler('m', params => {
-  // Handle SGR sequences
-  return true; // Handled
-});
-```
-
-**Buffer Access**: Read terminal content via buffer API:
-```typescript
-const line = terminal.buffer.active.getLine(0);
-const cell = line?.getCell(0);
-```
-
-**Events**: All terminals emit standard events (onData, onResize, onRender) plus platform-specific ones.
-
-## Critical Implementation Details
-
- Terminal rendering uses either DOM or WebGL renderers
- Buffer lines are immutable; create new instances for modifications
- Character width handling supports Unicode 11+ and grapheme clustering
- Mouse events translate web events to terminal protocols (X10, VT200, etc.)
- Color theming supports both palette and true color modes
-
-## Writing unit tests
-
- Unit tests live alongside the source code file of the thing it's testing with a .test.ts suffix.
-
-## Cursor Cloud specific instructions
-
-**Demo server**: Start with `npm start` (port 3000). The demo server uses node-pty to spawn real shell sessions over WebSocket. Integration tests auto-start it via Playwright's `webServer` config, so you don't need to start it manually for `npm run test-integration`.
-
-**Build before testing**: Always run `npm run build && npm run esbuild` before `npm run test-unit`. Integration tests also need `npm run esbuild-demo-client` and `npm run esbuild-demo-server`. The update script handles this automatically on session start.
-
-**No external services**: This project has zero external dependencies (no databases, Docker, or APIs). Everything runs locally with Node.js.
-
-**TypeScript compiler**: The project uses `tsgo` (native TypeScript compiler preview) rather than standard `tsc`. It's installed via the `@typescript/native-preview` package.
-
-**Lint only changed files**: Prefer `npm run lint-changes` over `npm run lint` when iterating on code changes — it's significantly faster.
@@ -1,50 +1,104 @@
 # How to contribute to xterm.js

+- [Opening issues for bug reports or feature requests](#opening-issues)
 - [Contributing code](#contributing-code)
- [Opening issues](#opening-issues)
- [Answering discussion questions](#answering-discussion-questions)
-
-## Contributing code
-
-You can find issues to work on by looking at issues labeled with [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). It's a good idea to comment on the issue saying that you're looking into it, just in case someone else comes along and you duplicate work. Once you have your issue, here are the steps to contribute:
-
- Fork [xterm.js](https://github.com/xtermjs/xterm.js/) ([how to fork a repo](https://help.github.com/articles/fork-a-repo)).
- Get the [xterm.js demo](https://github.com/xtermjs/xterm.js/wiki/Contributing#running-the-demo) running.
- Make the fix and verify it works in the demo. Be sure to follow thew general code style of the rest of the project.
- If your changes are easy to test or likely to regress in the future, add tests. These could be unit or integration (playwright) tests.
- Submit a pull request ([how to create a pull request](https://help.github.com/articles/fork-a-repo)).
-
-> ![TIP]
-> Don't put more than one feature or fix in a single pull request. The smaller pull requests are the easier they are to review and merge.
-
-By contributing code to xterm.js you:
-
- - Agree to license the contributed code under xterm.js' [MIT license](LICENSE).
- - Confirm that you have the right to contribute and license the code in question. This means that either you hold all rights on the code, or the rights holder has explicitly granted the right to use it like this, through a compatible open source license or through a direct agreement with you.

 ## Opening issues

 The preferred way to report bugs or request features is to use
-[GitHub issues](http://github.com/xtermjs/xterm.js/issues).
+[GitHub issues](http://github.com/sourcelair/xterm.js/issues). Before
+opening an issue, read these pointers.

-### Creating great issues
+### Opening issues effectively

- Include information about **the browser in which the problem occurred** or the terminal being used. If you tested several browsers and the problem occurred in all of them, mention this fact in the bug report. Also include browser version numbers and the operating system that you're on.
- Include the version of xterm.js being used, preferably either with the latest `beta` tagged release on npm or reproducing in the demo on the `master` branch.
- Mention precisely what went wrong. What did you expect to happen? What happened instead? Describe the exact steps a maintainer has to take to make the problem occur.
- If the problem can not be reproduced in the [demo of xterm.js](https://github.com/xtermjs/xterm.js/wiki/Contributing#running-the-demo), provide an HTML document that demonstrates the problem.
- Be polite and follow [the code of conduct](https://github.com/xtermjs/xterm.js?tab=coc-ov-file#readme).
+- Include information about **the browser in which the problem occurred**. Even
+  if you tested several browsers, and the problem occurred in all of them,
+  mention this fact in the bug report. Also include browser version numbers and
+  the operating system that you're on.

-### Issue triaging philosophy
+- Mention which release of xterm.js you're using. Preferably, try also with
+  the current HEAD of the master branch, to ensure the problem has not already been
+  fixed.

-It's pretty common for maintainers of large open source projects to suffer from burnout, especially when needing to triage a large number of incoming issues instead of actually building things. Here are some of the steps we take to try mitigate this:
+- Mention precisely what went wrong. What did you expect to happen? What happened instead? Describe the
+  exact steps a maintainer has to take to make the problem occur.

- Support questions live in [GH discussions](https://github.com/xtermjs/xterm.js/discussions), issues may be transfered there without further comment and core maintainers may or may not participate in discussions.
- Issues are strictly for well defined features or bugs that are _actionable_.
- Sometimes features are out of scope. A common example of this is a niche feature that the pricipal implementation ([VS Code](https://code.visualstudio.com/)) won't leverage and therefore would be difficult to maintain and likely suffer from bitrot. The reporter may not agree with this, but you could always create an addon if that works or maintain your own fork if it comes to that.
- If a feature does not have a clear way forward or needs more discussion it may be closed ro moved to a discussion.
- If a bug is not easily reproducible it may be closed or moved to a discussion. Generally issues that are labeled are something we want to do or has actionable steps to look into further.
+- If the problem can not be reproduced in the [demo of xterm.js](https://github.com/xtermjs/xterm.js/wiki/Contributing#running-the-demo), please provide an HTML document that demonstrates the problem.
+
+- 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.
+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:
+
+- Fork [xterm.js](https://github.com/sourcelair/xterm.js/)
+  ([how to fork a repo](https://help.github.com/articles/fork-a-repo)).
+- Get the [xterm.js demo](https://github.com/xtermjs/xterm.js/wiki/Contributing#running-the-demo) running.
+- Make your changes.
+- If your changes are easy to test or likely to regress, add tests. Tests go into `test`, directory.
+- Follow the general code style of the rest of the project (see below).
+- Submit a pull request
+([how to create a pull request](https://help.github.com/articles/fork-a-repo)).
+  Don't put more than one feature/fix in a single pull request.
+
+By contributing code to xterm.js you:
+
+ - Agree to license the contributed code under xterm.js' [MIT
+   license](LICENSE).
+
+ - Confirm that you have the right to contribute and license the code
+   in question. (Either you hold all rights on the code, or the rights
+   holder has explicitly granted the right to use it like this,
+   through a compatible open source license or through a direct
+   agreement with you.)
+
+### Test coverage
+
+One area that always needs attention is improving out unit test coverage, you can view the code coverage report on [Azure Pipelines](https://dev.azure.com/xtermjs/xterm.js/_build/latest?definitionId=3) by clicking the Code Coverage tab.
+
+## Testing
+
+### Unit tests
+
+Unit tests are run with `yarn test-unit`:
+
+```sh
+# All unit tests
+yarn test-unit
+
+# Absolute file path
+yarn test-unit out-esbuild/browser/Terminal.test.js
+
+# Filter by wildcard
+yarn test-unit out-esbuild/**/Terminal.test.js
+
+# Specific addon unit tests tests
+yarn test-unit addons/addon-image/out-esbuild/*.test.js
+
+# Multiple files
+yarn test-unit out-esbuild/**/Terminal.test.js out-esbuild/**/InputHandler.test.js
+```
+
+These use mocha to run all `.test.js` files within the esbuild output (`out-esbuild/`).
+
+### Integration tests
+
+Integration tests are run with `yarn test-integration`:
+
+```sh
+# All integration tests
+yarn test-integration
+
+# Core integration tests
+yarn test-integration --suite=core
+
+# Specific addon integration tests
+yarn test-integration --suite=addon-search
+```
+
+These use `@playwright/test` to run all tests within the esbuild test output (`out-esbuild-test/`).
@@ -1,59 +1,30 @@
-# [![xterm.js](images/logo-full.png)](https://xtermjs.org)
+# [![xterm.js logo](images/logo-full.png)](https://xtermjs.org)

-Xterm.js is a frontend component that enables applications to bring fully-featured terminals to their users in the browser. It's used by popular projects such as [VS Code](https://code.visualstudio.com/) (and its forks), [Tabby](https://tabby.sh/) and [Hyper](https://hyper.is/).
+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

 - **Terminal apps just work**: Xterm.js works with most terminal apps such as `bash`, `vim`, and `tmux`, including support for curses-based apps and mouse events.
- **Performant**: Xterm.js is *really* fast and includes an optional GPU-accelerated renderer.
+- **Performant**: Xterm.js is *really* fast, it even includes a GPU-accelerated renderer.
 - **Rich Unicode support**: Supports CJK, emojis, and IMEs.
- **Self-contained**: The core library has zero dependencies.
- **Accessible**: Screen reader mode and minimum contrast ratio support can be turned on.
- **And much more**: Links, theming, custom glyphs, addons, well documented API, etc.
+- **Self-contained**: Requires zero dependencies to work.
+- **Accessible**: Screen reader and minimum contrast ratio support can be turned on.
+- **And much more**: Links, theming, addons, well documented API, etc.

 ## What xterm.js is not

 - Xterm.js is not a terminal application that you can download and use on your computer.
- Xterm.js is not `bash`. Xterm.js can be connected to processes like `bash` and let you interact with them (provide input, receive output) through a library like [node-pty](https://github.com/microsoft/node-pty).
+- Xterm.js is not `bash`. Xterm.js can be connected to processes like `bash` and let you interact with them (provide input, receive output).

 ## Getting Started

-First, you need to install the module. We ship exclusively through [npm](https://www.npmjs.com), so you need that installed and then add [@xterm/xterm](https://www.npmjs.com/package/@xterm/xterm) as a dependency by running:
+First, you need to install the module, we ship exclusively through [npm](https://www.npmjs.com/), so you need that installed and then add xterm.js as a dependency by running:

 ```bash
-npm install --save @xterm/xterm
+npm install @xterm/xterm
 ```

-The recommended way to load xterm.js with the ES module syntax, either using TypeScript or a modern JS tooling. Note that both CommonJS and ES module files are shipped with the npm package.
-
-```javascript
-import { Terminal } from '@xterm/xterm';
-```
-
-Then instantiate a `Terminal` object, open it on an element and write to it:
-
-```javascript
-const term = new Terminal();
-term.open(document.getElementById('terminal'));
-term.write('Hello from \x1B[1;3;31mxterm.js\x1B[0m $ ')
-```
-
-Most use cases will hook up input and output to a pseudoterminal API such as [node-pty](https://www.npmjs.com/package/node-pty) which will drive the terminal.
-
-```javascript
-pty.onData(data => term.write(data));
-term.onData(data => pty.write(data));
-```
-
-Then make sure to also include the `css/xterm.css` file, for example in HTML:
-
-```html
-<link rel="stylesheet" href="node_modules/@xterm/xterm/css/xterm.css" />
-```
-
-### Standalone example
-
-Here is a complete standalone example in a HTML file:
+To start using xterm.js on your browser, add the `xterm.js` and `xterm.css` to the head of your HTML page. Then create a `<div id="terminal"></div>` onto which xterm can attach itself. Finally, instantiate the `Terminal` object and then call the `open` function with the DOM object of the `div`.

 ```html
 <!doctype html>
@@ -65,7 +36,7 @@ Here is a complete standalone example in a HTML file:
    <body>
      <div id="terminal"></div>
      <script>
-        const term = new Terminal();
+        var term = new Terminal();
        term.open(document.getElementById('terminal'));
        term.write('Hello from \x1B[1;3;31mxterm.js\x1B[0m $ ')
      </script>
@@ -73,12 +44,22 @@ Here is a complete standalone example in a HTML file:
  </html>
 ```

+### Importing
+
+The recommended way to load xterm.js is via the ES6 module syntax:
+
+```javascript
+import { Terminal } from '@xterm/xterm';
+```
+
 ### Addons

+⚠️ *This section describes the new addon format introduced in v3.14.0, see [here](https://github.com/xtermjs/xterm.js/blob/3.14.2/README.md#addons) for the instructions on the old format*
+
 Addons are separate modules that extend the `Terminal` by building on the [xterm.js API](https://github.com/xtermjs/xterm.js/blob/master/typings/xterm.d.ts). To use an addon, you first need to install it in your project:

 ```bash
-npm install --save @xterm/addon-web-links
+npm i -S @xterm/addon-web-links
 ```

 Then import the addon, instantiate it and call `Terminal.loadAddon`:
@@ -99,51 +80,50 @@ The xterm.js team maintains the following addons, but anyone can build them:
 - [`@xterm/addon-clipboard`](https://github.com/xtermjs/xterm.js/tree/master/addons/addon-clipboard): Access the browser's clipboard
 - [`@xterm/addon-fit`](https://github.com/xtermjs/xterm.js/tree/master/addons/addon-fit): Fits the terminal to the containing element
 - [`@xterm/addon-image`](https://github.com/xtermjs/xterm.js/tree/master/addons/addon-image): Adds image support
- [`@xterm/addon-ligatures`](https://github.com/xtermjs/xterm.js/tree/master/addons/addon-ligatures): Enables rendering of ligatures
- [`@xterm/addon-progress`](https://github.com/xtermjs/xterm.js/tree/master/addons/addon-progress): Adds support for the progress API (`OSC 9;4`)
 - [`@xterm/addon-search`](https://github.com/xtermjs/xterm.js/tree/master/addons/addon-search): Adds search functionality
- [`@xterm/addon-serialize`](https://github.com/xtermjs/xterm.js/tree/master/addons/addon-serialize): Serializes the terminal's buffer to VT sequences or HTML
- [`@xterm/addon-unicode-graphemes`](https://github.com/xtermjs/xterm.js/tree/master/addons/addon-unicode-graphemes): Enhanced unicode support including grapheme clustering (experimental)
+- [`@xterm/addon-serialize`](https://github.com/xtermjs/xterm.js/tree/master/addons/addon-serialize): Serializes the terminal's buffer to a VT sequences or HTML
 - [`@xterm/addon-unicode11`](https://github.com/xtermjs/xterm.js/tree/master/addons/addon-unicode11): Updates character widths to their unicode11 values
- [`@xterm/addon-web-fonts`](https://github.com/xtermjs/xterm.js/tree/master/addons/addon-web-fonts): Easily integrate web fonts
 - [`@xterm/addon-web-links`](https://github.com/xtermjs/xterm.js/tree/master/addons/addon-web-links): Adds web link detection and interaction
 - [`@xterm/addon-webgl`](https://github.com/xtermjs/xterm.js/tree/master/addons/addon-webgl): Renders xterm.js using a `canvas` element's webgl2 context

 ## Browser Support

-Since xterm.js is typically implemented as a developer tool, generally only modern evergreen browsers are supported officially. Specifically the latest versions of *Chrome*, *Edge*, *Firefox*, and *Safari*. Xterm.js also works seamlessly in [Electron](https://electronjs.org/) apps and may even work on earlier versions of the browsers. These are the versions we strive to keep working.
+Since xterm.js is typically implemented as a developer tool, only modern browsers are supported officially. Specifically the latest versions of *Chrome*, *Edge*, *Firefox*, and *Safari*.
+
+Xterm.js works seamlessly in [Electron](https://electronjs.org/) apps and may even work on earlier versions of the browsers. These are the versions we strive to keep working.

 ### Node.js Support

-We also publish [`@xterm/headless`](https://www.npmjs.com/package/@xterm/headless) which is a stripped down version of xterm.js that runs headless in Node.js. An example use case for this is to keep track of a terminal's state where the process is running and using the [serialize addon](https://www.npmjs.com/package/@xterm/addon-serialize) so it can get all state restored upon reconnection.
+We also publish [`xterm-headless`](https://www.npmjs.com/package/xterm-headless) which is a stripped down version of xterm.js that runs in Node.js. An example use case for this is to keep track of a terminal's state where the process is running and using the serialize addon so it can get all state restored upon reconnection.

 ## API

 The full API for xterm.js is contained within the [TypeScript declaration file](https://github.com/xtermjs/xterm.js/blob/master/typings/xterm.d.ts), use the branch/tag picker in GitHub (`w`) to navigate to the correct version of the API.

-Some APIs may be marked with *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.
+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

-Stable releases are done on an as needed basis. All current and past releases are available on this repo's [releases page](https://github.com/sourcelair/xterm.js/releases), you can see what's planned for upcoming releases looking through the repository [milestones](https://github.com/sourcelair/xterm.js/milestones).
+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

-Beta releases are continuously published off the `master` branch. Install the latest beta build with:
+Our CI releases beta builds to npm for every change that goes into master. Install the latest beta build with:

 ```bash
-npm install --save @xterm/xterm@beta
+npm install -S @xterm/xterm@beta
 ```

-The principal implementation (VS Code) typically uses the latest or near the latest beta build. Generally they are quite stable but can potentially contain bugs or breaking changes. If stability is very important we recommend using the beta build primarily to test out new features and to verify bug fixes, unless you're tracking what's landing and are comfortable taking that risk.
+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

-Read [CONTRIBUTING.md](https://github.com/xtermjs/xterm.js/blob/master/CONTRIBUTING.md) to learn how to contribute to the project.
+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 many world-class applications to provide great terminal experiences.
+Xterm.js is used in several world-class applications to provide great terminal experiences.

 - [**SourceLair**](https://www.sourcelair.com/): In-browser IDE that provides its users with fully-featured Linux terminals based on xterm.js.
 - [**Microsoft Visual Studio Code**](http://code.visualstudio.com/): Modern, versatile, and powerful open source code editor that provides an integrated terminal based on xterm.js.
@@ -249,19 +229,14 @@ Xterm.js is used in many world-class applications to provide great terminal expe
 - [**pyTermTk**](https://github.com/ceccopierangiolieugenio/pyTermTk): Python Terminal Toolkit - a Spiced Up Cross Compatible TUI Library 🌶️, use xterm.js for the [HTML5 exporter](https://ceccopierangiolieugenio.github.io/pyTermTk/sandbox/sandbox.html).
 - [**ecmaOS**](https://ecmaos.sh): A kernel and suite of applications tying modern web technologies into a browser-based operating system.
 - [**LabEx**](https://labex.io): Interactive learning platform with hands-on labs and xterm.js-based online terminals, focused on learn-by-doing approach.
- [**EmuDevz**](https://afska.github.io/emudevz): A free coding game where players learn how to build an emulator from scratch.
- [**SSH Connection Manager**](https://github.com/Amtrend/ssh-manager): Modern web-based SSH terminal and SFTP manager with AES-256 encryption, PWA support, and session management.
- [**WooTTY**](https://github.com/icoretech/wootty): Flawless browser terminal for real operators.
- [**Orca**](https://github.com/stablyai/orca): Agentic development environment for 100x builders.
- [**4bit**](https://ciembor.github.io/4bit): Terminal Color Scheme Designer.
 - [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. Please add any new contributions to the end of the list.
+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.

 ## 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-2026, [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)
@@ -1,6 +1,6 @@
 {
  "name": "@xterm/addon-attach",
-  "version": "0.12.0",
+  "version": "0.11.0",
  "author": {
    "name": "The xterm.js authors",
    "url": "https://xtermjs.org/"
@@ -16,10 +16,13 @@
    "xterm.js"
  ],
  "scripts": {
-    "build": "../../node_modules/.bin/tsgo -p .",
+    "build": "../../node_modules/.bin/tsc -p .",
    "prepackage": "npm run build",
    "package": "../../node_modules/.bin/webpack",
    "prepublishOnly": "npm run package",
    "start": "node ../../demo/start"
+  },
+  "peerDependencies": {
+    "@xterm/xterm": "^5.0.0"
  }
 }
@@ -12,7 +12,7 @@ interface IAttachOptions {
  bidirectional?: boolean;
 }

-export class AttachAddon implements ITerminalAddon, IAttachApi {
+export class AttachAddon implements ITerminalAddon , IAttachApi {
  private _socket: WebSocket;
  private _bidirectional: boolean;
  private _disposables: IDisposable[] = [];
@@ -5,9 +5,10 @@ const config: PlaywrightTestConfig = {
  timeout: 10000,
  projects: [
    {
-      name: 'Chromium',
+      name: 'ChromeStable',
      use: {
-        browserName: 'chromium'
+        browserName: 'chromium',
+        channel: 'chrome'
      }
    },
    {
@@ -9,16 +9,13 @@
    "outDir": "../out-test",
    "sourceMap": true,
    "removeComments": true,
+    "baseUrl": ".",
    "paths": {
      "common/*": [
-        "../../../src/primitives/*",
-        "../../../src/runtime/*",
+        "../../../src/common/*"
      ],
-      "target-browser/*": [
-        "../../../src/target-browser/*"
-      ],
-      "*": [
-        "./*"
+      "browser/*": [
+        "../../../src/browser/*"
      ]
    },
    "strict": true,
@@ -32,10 +29,10 @@
  ],
  "references": [
    {
-      "path": "../../../src"
+      "path": "../../../src/common"
    },
    {
-      "path": "../../../src/target-browser"
+      "path": "../../../src/browser"
    },
    {
      "path": "../../../test/playwright"
@@ -1,6 +1,6 @@
 {
  "name": "@xterm/addon-clipboard",
-  "version": "0.2.0",
+  "version": "0.1.0",
  "author": {
    "name": "The xterm.js authors",
    "url": "https://xtermjs.org/"
@@ -16,10 +16,16 @@
    "xterm.js"
  ],
  "scripts": {
-    "build": "../../node_modules/.bin/tsgo -p .",
+    "build": "../../node_modules/.bin/tsc -p .",
    "prepackage": "npm run build",
    "package": "../../node_modules/.bin/webpack",
    "prepublishOnly": "npm run package",
    "start": "node ../../demo/start"
+  },
+  "peerDependencies": {
+    "@xterm/xterm": "^5.4.0"
+  },
+  "dependencies": {
+    "js-base64": "^3.7.5"
  }
 }
@@ -4,7 +4,8 @@
 */

 import type { IDisposable, ITerminalAddon, Terminal } from '@xterm/xterm';
-import { type IClipboardProvider, type IBase64 } from '@xterm/addon-clipboard';
+import { type IClipboardProvider, ClipboardSelectionType, type IBase64 } from '@xterm/addon-clipboard';
+import { Base64 as JSBase64 } from 'js-base64';

 export class ClipboardAddon implements ITerminalAddon {
  private _terminal?: Terminal;
@@ -24,7 +25,7 @@ export class ClipboardAddon implements ITerminalAddon {
    return this._disposable?.dispose();
  }

-  private _readText(sel: string, data: string): void {
+  private _readText(sel: ClipboardSelectionType, data: string): void {
    const b64 = this._base64.encodeText(data);
    this._terminal?.input(`\x1b]52;${sel};${b64}\x07`, false);
  }
@@ -35,7 +36,7 @@ export class ClipboardAddon implements ITerminalAddon {
      return true;
    }

-    const pc = args[0];
+    const pc = args[0] as ClipboardSelectionType;
    const pd = args[1];
    if (pd === '?') {
      const text = this._provider.readText(pc);
@@ -69,23 +70,30 @@ export class ClipboardAddon implements ITerminalAddon {
 }

 export class BrowserClipboardProvider implements IClipboardProvider {
-  public readText(selection: string): Promise<string> {
+  public async readText(selection: ClipboardSelectionType): Promise<string> {
+    if (selection !== 'c') {
+      return Promise.resolve('');
+    }
    return navigator.clipboard.readText();
  }

-  public writeText(selection: string, text: string): Promise<void> {
+  public async writeText(selection: ClipboardSelectionType, text: string): Promise<void> {
+    if (selection !== 'c') {
+      return Promise.resolve();
+    }
    return navigator.clipboard.writeText(text);
  }
 }

 export class Base64 implements IBase64 {
  public encodeText(data: string): string {
-    return btoa(data);
+    return JSBase64.encode(data);
  }
  public decodeText(data: string): string {
-    try {
-      return atob(data);
-    } catch {}
-    return '';
+    const text = JSBase64.decode(data);
+    if (!JSBase64.isValid(data) || JSBase64.encode(text) !== data) {
+      return '';
+    }
+    return text;
  }
 }
@@ -15,8 +15,8 @@
      "../../../node_modules/@types/mocha"
    ],
    "paths": {
-      "target-browser/*": [
-        "../../../src/target-browser/*"
+      "browser/*": [
+        "../../../src/browser/*"
      ],
      "@xterm/addon-clipboard": [
        "../typings/addon-clipboard.d.ts"
@@ -29,7 +29,7 @@
  ],
  "references": [
    {
-      "path": "../../../src/target-browser"
+      "path": "../../../src/browser"
    }
  ]
 }
@@ -20,7 +20,7 @@ test.describe('ClipboardAddon', () => {

  test.beforeEach(async ({}, testInfo) => {
    // DEBT: This test doesn't work since the migration to @playwright/test
-    if (ctx.browser.browserType().name() === 'webkit') {
+    if (ctx.browser.browserType().name() !== 'chromium') {
      testInfo.skip();
      return;
    }
@@ -48,14 +48,6 @@ test.describe('ClipboardAddon', () => {
      await ctx.proxy.write(`\x1b]52;c;${testDataEncoded}\x07`);
      deepEqual(await ctx.page.evaluate(() => window.navigator.clipboard.readText()), testDataDecoded);
    });
-    test('primary selection', async () => {
-      await ctx.proxy.write(`\x1b]52;p;${testDataEncoded}\x07`);
-      deepEqual(await ctx.page.evaluate(() => window.navigator.clipboard.readText()), testDataDecoded);
-    });
-    test('empty selection (default)', async () => {
-      await ctx.proxy.write(`\x1b]52;;${testDataEncoded}\x07`);
-      deepEqual(await ctx.page.evaluate(() => window.navigator.clipboard.readText()), testDataDecoded);
-    });
    test('invalid base64 string', async () => {
      await ctx.proxy.write(`\x1b]52;c;${testDataEncoded}invalid\x07`);
      deepEqual(await ctx.page.evaluate(() => window.navigator.clipboard.readText()), '');
@@ -68,24 +60,15 @@ test.describe('ClipboardAddon', () => {
  });

  test.describe('read data', async function (): Promise<any> {
-    test.beforeAll(async () => {
+    test('simple string', async () => {
      await ctx.page.evaluate(`
        window.data = [];
        window.term.onData(e => data.push(e));
      `);
-    });
-    test('simple string', async () => {
-      await ctx.page.evaluate('window.data.length = 0;');
      await ctx.page.evaluate(() => window.navigator.clipboard.writeText('hello world'));
      await ctx.proxy.write(`\x1b]52;c;?\x07`);
      deepEqual(await ctx.page.evaluate('window.data'), [`\x1b]52;c;${testDataEncoded}\x07`]);
    });
-    test('primary selection', async () => {
-      await ctx.page.evaluate('window.data.length = 0;');
-      await ctx.page.evaluate(() => window.navigator.clipboard.writeText('hello world'));
-      await ctx.proxy.write(`\x1b]52;p;?\x07`);
-      deepEqual(await ctx.page.evaluate('window.data'), [`\x1b]52;p;${testDataEncoded}\x07`]);
-    });
    test('clear clipboard', async () => {
      await ctx.proxy.write(`\x1b]52;c;!\x07`);
      await ctx.proxy.write(`\x1b]52;c;?\x07`);
@@ -5,9 +5,10 @@ const config: PlaywrightTestConfig = {
  timeout: 10000,
  projects: [
    {
-      name: 'Chromium',
+      name: 'ChromeStable',
      use: {
-        browserName: 'chromium'
+        browserName: 'chromium',
+        channel: 'chrome'
      }
    },
    {
@@ -9,16 +9,13 @@
    "outDir": "../out-test",
    "sourceMap": true,
    "removeComments": true,
+    "baseUrl": ".",
    "paths": {
      "common/*": [
-        "../../../src/primitives/*",
-        "../../../src/runtime/*",
+        "../../../src/common/*"
      ],
-      "target-browser/*": [
-        "../../../src/target-browser/*"
-      ],
-      "*": [
-        "./*"
+      "browser/*": [
+        "../../../src/browser/*"
      ]
    },
    "strict": true,
@@ -32,10 +29,10 @@
  ],
  "references": [
    {
-      "path": "../../../src"
+      "path": "../../../src/common"
    },
    {
-      "path": "../../../src/target-browser"
+      "path": "../../../src/browser"
    },
    {
      "path": "../../../test/playwright"
@@ -30,6 +30,18 @@ declare module '@xterm/addon-clipboard' {
    public dispose(): void
  }

+  /**
+   * Clipboard selection type. This is used to specify which selection buffer to
+   * read or write to.
+   * - SYSTEM `c`: The system clipboard.
+   * - PRIMARY `p`: The primary clipboard. This is provided for compatibility
+   *  with Linux X11.
+   */
+  export const enum ClipboardSelectionType {
+    SYSTEM = 'c',
+    PRIMARY = 'p',
+  }
+
  export interface IBase64 {
    /**
    * Converts a utf-8 string to a base64 string.
@@ -66,39 +78,36 @@ declare module '@xterm/addon-clipboard' {
  export interface IClipboardProvider {
    /**
     * Gets the clipboard content.
-     * @param selection The clipboard selection to read (see OSC 52 spec of xterm).
+     * @param selection The clipboard selection to read.
     * @returns A promise that resolves with clipboard selection data.
     */
-    readText(selection: string): string | Promise<string>;
+    readText(selection: ClipboardSelectionType): string | Promise<string>;

    /**
     * Sets the clipboard content.
-     * @param selection The clipboard selection to set (see OSC 52 spec of xterm).
+     * @param selection The clipboard selection to set.
     * @param data The clipboard text to write.
     */
-    writeText(selection: string, text: string): void | Promise<void>;
+    writeText(selection: ClipboardSelectionType, text: string): void | Promise<void>;
  }

  /**
-   * The clipboard provider interface that enables xterm.js to access the browser clipboard.
-   *
-   * Note this this clipboard provider does not implement own cut buffers as xterm does,
-   * but redirect the selection parameter always to navigator.clipboard.
+   * The clipboard provider interface that enables xterm.js to access the system clipboard.
   */
  export class BrowserClipboardProvider implements IClipboardProvider{
    /**
     * Reads text from the clipboard.
-     * @param selection The selection type to read from (always refers to navigator.clipboard).
+     * @param selection The selection type to read from.
     * @returns A promise that resolves with the text from the clipboard.
     */
-    public readText(selection: string): Promise<string>;
+    public readText(selection: ClipboardSelectionType): Promise<string>;

    /**
     * Writes text to the clipboard.
-     * @param selection The selection type to write to (always refers to navigator.clipboard).
+     * @param selection The selection type to write to.
     * @param data The text to write to the clipboard.
     * @returns A promise that resolves when the text has been written to the clipboard.
     */
-    public writeText(selection: string, data: string): Promise<void>;
+    public writeText(selection: ClipboardSelectionType, data: string): Promise<void>;
  }
 }
@@ -0,0 +1,8 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+js-base64@^3.7.5:
+  version "3.7.7"
+  resolved "https://registry.yarnpkg.com/js-base64/-/js-base64-3.7.7.tgz#e51b84bf78fbf5702b9541e2cb7bfcb893b43e79"
+  integrity sha512-7rCnleh0z2CkXhH67J8K1Ytz0b2Y+yxTPL+/KOJoa20hfnVQ/3/T6W/KflYI4bRHRagNeXeU2bkNGI3v1oS/lw==
@@ -1,6 +1,6 @@
 {
  "name": "@xterm/addon-fit",
-  "version": "0.11.0",
+  "version": "0.10.0",
  "author": {
    "name": "The xterm.js authors",
    "url": "https://xtermjs.org/"
@@ -16,10 +16,13 @@
    "xterm.js"
  ],
  "scripts": {
-    "build": "../../node_modules/.bin/tsgo -p .",
+    "build": "../../node_modules/.bin/tsc -p .",
    "prepackage": "npm run build",
    "package": "../../node_modules/.bin/webpack",
    "prepublishOnly": "npm run package",
    "start": "node ../../demo/start"
+  },
+  "peerDependencies": {
+    "@xterm/xterm": "^5.0.0"
  }
 }
@@ -3,9 +3,10 @@
 * @license MIT
 */

-import type { Terminal, ITerminalAddon, IRenderDimensions } from '@xterm/xterm';
+import type { Terminal, ITerminalAddon } from '@xterm/xterm';
 import type { FitAddon as IFitApi } from '@xterm/addon-fit';
-import { ViewportConstants } from 'target-browser/shared/Constants';
+import { IRenderDimensions } from 'browser/renderer/shared/Types';
+import { ViewportConstants } from 'browser/shared/Constants';

 interface ITerminalDimensions {
  /**
@@ -19,23 +20,10 @@ interface ITerminalDimensions {
  cols: number;
 }

-const enum Constants {
-  MINIMUM_COLS = 2,
-  MINIMUM_ROWS = 1
-}
+const MINIMUM_COLS = 2;
+const MINIMUM_ROWS = 1;

-function getWindow(e: Node): Window {
-  if (e?.ownerDocument?.defaultView) {
-    return e.ownerDocument.defaultView;
-  }
-
-  return window;
-}
-function _getComputedStyle(el: HTMLElement): CSSStyleDeclaration {
-  return getWindow(el).getComputedStyle(el, null);
-}
-
-export class FitAddon implements ITerminalAddon, IFitApi {
+export class FitAddon implements ITerminalAddon , IFitApi {
  private _terminal: Terminal | undefined;

  public activate(terminal: Terminal): void {
@@ -50,7 +38,14 @@ export class FitAddon implements ITerminalAddon, IFitApi {
      return;
    }

-    this._terminal.resize(dims.cols, dims.rows);
+    // TODO: Remove reliance on private API
+    const core = (this._terminal as any)._core;
+
+    // Force a full render
+    if (this._terminal.rows !== dims.rows || this._terminal.cols !== dims.cols) {
+      core._renderService.clear();
+      this._terminal.resize(dims.cols, dims.rows);
+    }
  }

  public proposeDimensions(): ITerminalDimensions | undefined {
@@ -62,21 +57,22 @@ export class FitAddon implements ITerminalAddon, IFitApi {
      return undefined;
    }

-    const dims: IRenderDimensions | undefined = this._terminal.dimensions;
+    // TODO: Remove reliance on private API
+    const core = (this._terminal as any)._core;
+    const dims: IRenderDimensions = core._renderService.dimensions;

-    if (!dims || dims.css.cell.width === 0 || dims.css.cell.height === 0) {
+    if (dims.css.cell.width === 0 || dims.css.cell.height === 0) {
      return undefined;
    }

-    const showScrollbar = this._terminal.options.scrollbar?.showScrollbar ?? true;
-    const scrollbarWidth = (this._terminal.options.scrollback === 0 || !showScrollbar
+    const scrollbarWidth = (this._terminal.options.scrollback === 0
      ? 0
-      : (this._terminal.options.scrollbar?.width ?? ViewportConstants.DEFAULT_SCROLL_BAR_WIDTH));
+      : (this._terminal.options.overviewRuler?.width || ViewportConstants.DEFAULT_SCROLL_BAR_WIDTH));

-    const parentElementStyle = _getComputedStyle(this._terminal.element.parentElement);
+    const parentElementStyle = window.getComputedStyle(this._terminal.element.parentElement);
    const parentElementHeight = parseInt(parentElementStyle.getPropertyValue('height'));
    const parentElementWidth = Math.max(0, parseInt(parentElementStyle.getPropertyValue('width')));
-    const elementStyle = _getComputedStyle(this._terminal.element);
+    const elementStyle = window.getComputedStyle(this._terminal.element);
    const elementPadding = {
      top: parseInt(elementStyle.getPropertyValue('padding-top')),
      bottom: parseInt(elementStyle.getPropertyValue('padding-bottom')),
@@ -88,8 +84,8 @@ export class FitAddon implements ITerminalAddon, IFitApi {
    const availableHeight = parentElementHeight - elementPaddingVer;
    const availableWidth = parentElementWidth - elementPaddingHor - scrollbarWidth;
    const geometry = {
-      cols: Math.max(Constants.MINIMUM_COLS, Math.floor(availableWidth / dims.css.cell.width)),
-      rows: Math.max(Constants.MINIMUM_ROWS, Math.floor(availableHeight / dims.css.cell.height))
+      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;
  }
@@ -15,8 +15,8 @@
      "../../../node_modules/@types/mocha"
    ],
    "paths": {
-      "target-browser/*": [
-        "../../../src/target-browser/*"
+      "browser/*": [
+        "../../../src/browser/*"
      ],
      "@xterm/addon-fit": [
        "../typings/addon-fit.d.ts"
@@ -29,7 +29,7 @@
  ],
  "references": [
    {
-      "path": "../../../src/target-browser"
+      "path": "../../../src/browser"
    }
  ]
 }
@@ -119,17 +119,6 @@ test.describe('FitAddon', () => {
      strictEqual(await ctx.proxy.cols, 2);
      strictEqual(await ctx.proxy.rows, 1);
    });
-
-    test('same dimensions', async function(): Promise<any> {
-      await setDimensions();
-      await ctx.page.evaluate(`window.fit.fit()`);
-      const cols: number = await ctx.proxy.cols;
-      const rows: number = await ctx.proxy.rows;
-      // Calling fit() again at the same container size should not throw
-      await ctx.page.evaluate(`window.fit.fit()`);
-      strictEqual(await ctx.proxy.cols, cols);
-      strictEqual(await ctx.proxy.rows, rows);
-    });
  });
 });

@@ -5,9 +5,10 @@ const config: PlaywrightTestConfig = {
  timeout: 10000,
  projects: [
    {
-      name: 'Chromium',
+      name: 'ChromeStable',
      use: {
-        browserName: 'chromium'
+        browserName: 'chromium',
+        channel: 'chrome'
      }
    },
    {
@@ -9,16 +9,13 @@
    "outDir": "../out-test",
    "sourceMap": true,
    "removeComments": true,
+    "baseUrl": ".",
    "paths": {
      "common/*": [
-        "../../../src/primitives/*",
-        "../../../src/runtime/*",
+        "../../../src/common/*"
      ],
-      "target-browser/*": [
-        "../../../src/target-browser/*"
-      ],
-      "*": [
-        "./*"
+      "browser/*": [
+        "../../../src/browser/*"
      ]
    },
    "strict": true,
@@ -32,10 +29,10 @@
  ],
  "references": [
    {
-      "path": "../../../src"
+      "path": "../../../src/common"
    },
    {
-      "path": "../../../src/target-browser"
+      "path": "../../../src/browser"
    },
    {
      "path": "../../../test/playwright"
@@ -17,6 +17,7 @@ npm-debug.log
 .env
 build/
 .DS_Store
+package-lock.json
 yarn.lock

 # Keep bundled code out of Git
@@ -1,7 +1,6 @@
 ## @xterm/addon-image

-Inline image output in xterm.js. Supports SIXEL, iTerm's inline image protocol (IIP)
-and partially Kitty's terminal graphics prtocol (TGP).
+Inline image output in xterm.js. Supports SIXEL and iTerm's inline image protocol (IIP).


 ![](fixture/example.png)
@@ -26,14 +25,12 @@ const customSettings: IImageAddonOptions = {
  pixelLimit: 16777216,       // max. pixel size of a single image
  sixelSupport: true,         // enable sixel support
  sixelScrolling: true,       // whether to scroll on image output
-  sixelPaletteLimit: 4096,    // initial sixel palette size
-  sixelSizeLimit: 33554432,   // size limit of a single sixel sequence
+  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: 33554432,     // size limit of a single IIP sequence
-  kittySupport: true,         // enable Kitty graphics support
-  kittySizeLimit: 33554432    // size limit of a single Kitty sequence
+  iipSizeLimit: 20000000      // size limit of a single IIP sequence
 }

 // initialization
@@ -44,6 +41,9 @@ 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)
@@ -71,7 +71,7 @@ terminal.loadAddon(imageAddon);

 - **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 for sixel.
+  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).
@@ -98,24 +98,17 @@ terminal.loadAddon(imageAddon);
  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, GIF and QOI
+  - 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).
-  - Playload size is restricted by `iipSizeLimit`.
-  - size parameter is not mandatory anymore.
-  - Cursor gets positioned at the next cell of the last image line.
-  - ReportCellSize sequence is supported.
-  - Hi-res display support is currently limited (image gets blurred).
-
- **Kitty Graphics Support (TGP)**  
-  Set by default, change it with `{kittySupport: true}`.
-
-  Note that the kitty graphics support is still WIP.
+  - Size parameter is restricted by `iipSizeLimit`.
+  - Cursor positioning behaves the same as for sixel (see above).


 ### Storage and Drawing Settings
@@ -132,7 +125,6 @@ The addon exposes two properties to interact with the storage limits at runtime:
 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:
@@ -146,7 +138,6 @@ The addon provides the following API endpoints to retrieve raw image data as can
  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:
@@ -187,8 +178,8 @@ _How can I adjust the memory usage?_
  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 | iipSizeLimit | kittySizeLimit`  
-  Constructor settings. This has only a small impact on peaking memory during decoding. It is meant to avoid processing of overly big or broken image sequences at an earlier phase, thus may stop the invoked decoders from entering memory intensive tasks for potentially invalid data.
+- `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
@@ -218,5 +209,23 @@ _How can I adjust the memory usage?_

 ### Status

- Sixel and IIP support and image handling in xterm.js is considered beta quality.
- Kitty support is in alpha stage. Please file a bug for any awkwardities or missing features.
+- 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 folder from bootstrap.sh
+  - fix peer dependency in package.json
@@ -1,6 +1,6 @@
 {
  "name": "@xterm/addon-image",
-  "version": "0.9.0",
+  "version": "0.8.0",
  "author": {
    "name": "The xterm.js authors",
    "url": "https://xtermjs.org/"
@@ -18,13 +18,16 @@
    "xterm.js"
  ],
  "scripts": {
-    "prepackage": "../../node_modules/.bin/tsgo -p .",
+    "prepackage": "../../node_modules/.bin/tsc -p .",
    "package": "../../node_modules/.bin/webpack",
    "prepublishOnly": "npm run package",
    "start": "node ../../demo/start"
  },
+  "peerDependencies": {
+    "@xterm/xterm": "^5.2.0"
+  },
  "devDependencies": {
    "sixel": "^0.16.0",
-    "xterm-wasm-parts": "^0.4.1"
+    "xterm-wasm-parts": "^0.1.0"
  }
 }
@@ -4,26 +4,20 @@
 */
 import { IImageAddonOptions, IOscHandler, IResetHandler, ITerminalExt } from './Types';
 import { ImageRenderer } from './ImageRenderer';
-import { IIPImageStorage } from './IIPImageStorage';
-import { CELL_SIZE_DEFAULT } from './ImageStorage';
+import { ImageStorage, CELL_SIZE_DEFAULT } from './ImageStorage';
 import Base64Decoder from 'xterm-wasm-parts/lib/base64/Base64Decoder.wasm';
-import QoiDecoder from 'xterm-wasm-parts/lib/qoi/QoiDecoder.wasm';
-import { HeaderParser, IHeaderFields, HeaderState, SequenceType } from './IIPHeaderParser';
+import { HeaderParser, IHeaderFields, HeaderState } from './IIPHeaderParser';
 import { imageType, UNSUPPORTED_TYPE } from './IIPMetrics';

-// Local const enum mirror - esbuild can't inline const enums from external packages
-const enum DecoderConst {
-  // Limit held memory in base64 decoder (encoded bytes).
-  KEEP_DATA = 4194304,
-  // Initial buffer allocation for the decoder.
-  INITIAL_DATA = 1048576,
-  // Local mirror of const enum (esbuild can't inline const enums from external packages)
-  OK = 0
-}
+
+// 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 = {
-  type: SequenceType.INVALID,
  name: 'Unnamed file',
  size: 0,
  width: 'auto',
@@ -37,32 +31,21 @@ export class IIPHandler implements IOscHandler, IResetHandler {
  private _aborted = false;
  private _hp = new HeaderParser();
  private _header: IHeaderFields = DEFAULT_HEADER;
-  private _dec: Base64Decoder;
-  private _qoiDec: QoiDecoder;
+  private _dec = new Base64Decoder(KEEP_DATA);
  private _metrics = UNSUPPORTED_TYPE;
-  private _isMultipart = false;
-  private _abortMulti = false;

  constructor(
    private readonly _opts: IImageAddonOptions,
    private readonly _renderer: ImageRenderer,
-    private readonly _storage: IIPImageStorage,
+    private readonly _storage: ImageStorage,
    private readonly _coreTerminal: ITerminalExt
-  ) {
-    const maxEncodedBytes = Math.ceil(this._opts.iipSizeLimit * 4 / 3);
-    const initialBytes = Math.min(DecoderConst.INITIAL_DATA, maxEncodedBytes);
-    this._dec = new Base64Decoder(DecoderConst.KEEP_DATA, maxEncodedBytes, initialBytes);
-    this._qoiDec = new QoiDecoder(DecoderConst.KEEP_DATA);
-  }
+  ) {}

-  public reset(): void {
-    this._hp.reset();
-    this._dec.release();
-    this._qoiDec.release();
-  }
+  public reset(): void {}

  public start(): void {
    this._aborted = false;
+    this._header = DEFAULT_HEADER;
    this._metrics  = UNSUPPORTED_TYPE;
    this._hp.reset();
  }
@@ -71,7 +54,7 @@ export class IIPHandler implements IOscHandler, IResetHandler {
    if (this._aborted) return;

    if (this._hp.state === HeaderState.END) {
-      if ((this._dec.put(data.subarray(start, end)) as number) !== DecoderConst.OK) {
+      if (this._dec.put(data, start, end)) {
        this._dec.release();
        this._aborted = true;
      }
@@ -82,27 +65,15 @@ export class IIPHandler implements IOscHandler, IResetHandler {
        return;
      }
      if (dataPos > 0) {
-        const seqType = this._hp.fields.type;
-        if (seqType === SequenceType.FILE) {
-          if (this._isMultipart) {
-            this._isMultipart = false;
-            this._abortMulti = false;
-            this._dec.release();
-          }
-          this._header = Object.assign({}, DEFAULT_HEADER, this._hp.fields);
-          if (!this._header.inline) {
-            this._aborted = true;
-            return;
-          }
-          this._dec.init();
-        } else if (this._abortMulti) {
+        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;
        }
-        if ((this._dec.put(data.subarray(dataPos, end)) as number) !== DecoderConst.OK) {
+        this._dec.init(this._header.size);
+        if (this._dec.put(data, dataPos, end)) {
          this._dec.release();
          this._aborted = true;
-          if (this._isMultipart) this._abortMulti = true;
        }
      }
    }
@@ -111,49 +82,11 @@ export class IIPHandler implements IOscHandler, IResetHandler {
  public end(success: boolean): boolean | Promise<boolean> {
    if (this._aborted) return true;

-    if (this._hp.state !== HeaderState.END) {
-      if (this._hp.end()) return true;
-    }
-    const seqType = this._hp.fields.type;
-
-    if (seqType === SequenceType.FILEPART) return true;
-
-    if (seqType === SequenceType.REPORTCELLSIZE) {
-      // OSC 1337 ; ReportCellSize=[height];[width];[scale] ST
-      let width = CELL_SIZE_DEFAULT.width;
-      let height = CELL_SIZE_DEFAULT.height;
-      if (this._renderer.dimensions) {
-        width = this._renderer.dimensions.css.canvas.width / this._coreTerminal.cols;
-        height = this._renderer.dimensions.css.canvas.height / this._coreTerminal.rows;
-      }
-      const scale = this._coreTerminal._core._coreBrowserService?.dpr ?? 1;
-      const report = `\x1b]1337;ReportCellSize=${height.toFixed(3)};${width.toFixed(3)};${scale.toFixed(3)}\x1b\\`;
-      this._coreTerminal.input(report, false);
-      return true;
-    }
-
-    if (seqType === SequenceType.MULTIPARTFILE) {
-      this._header = Object.assign({}, DEFAULT_HEADER, this._hp.fields);
-      this._isMultipart = true;
-      this._abortMulti = false;
-      this._dec.release();
-      this._dec.init();
-      return true;
-    }
-
-    if (seqType === SequenceType.FILEEND) {
-      if (!this._isMultipart) return true;
-      this._isMultipart = false;
-      if (this._abortMulti || this._header.type !== SequenceType.MULTIPARTFILE) return true;
-    }
-
-    // fallthrough for SequenceType.FILE & SequenceType.FILEEND
-
    let w = 0;
    let h = 0;

    // early exit condition chain
-    let cond: number | boolean;
+    let cond: number | boolean = true;
    if (cond = success) {
      if (cond = !this._dec.end()) {
        this._metrics = imageType(this._dec.data8);
@@ -172,27 +105,26 @@ export class IIPHandler implements IOscHandler, IResetHandler {
      return true;
    }

-    let blob: Blob | ImageData;
-    if (this._metrics.mime === 'image/qoi') {
-      const data = this._qoiDec.decode(this._dec.data8);
-      blob = new ImageData(
-        new Uint8ClampedArray(data.buffer, data.byteOffset, data.byteLength),
-        this._qoiDec.width,
-        this._qoiDec.height
-      );
-      this._qoiDec.release();
-      if (w === this._qoiDec.width && h === this._qoiDec.height) {
-        // use fast-path if we don't need to rescale
-        this._dec.release();
-        const canvas = ImageRenderer.createCanvas(undefined, this._qoiDec.width, this._qoiDec.height);
-        canvas.getContext('2d')?.putImageData(blob, 0, 0);
-        this._storage.addImage(canvas);
-        return true;
-      }
-    } else {
-      blob = new Blob([this._dec.data8], { type: this._metrics.mime });
-    }
+    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);
@@ -4,20 +4,19 @@
 */

 import { assert } from 'chai';
-import { HeaderParser, HeaderState, IHeaderFields, SequenceType } from './IIPHeaderParser';
+import { HeaderParser, HeaderState, IHeaderFields } from './IIPHeaderParser';


 const CASES: [string, IHeaderFields][] = [
-  ['File=size=123456;name=dGVzdA==:', {type: SequenceType.FILE, name: 'test', size: 123456}],
-  ['File=size=123456;name=dGVzdA:', {type: SequenceType.FILE, name: 'test', size: 123456}],
+  ['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==:', {type: SequenceType.FILE, name: 'ümläutß', size: 123456}],
-  ['File=size=123456;name=w7xtbMOkdXTDnw:', {type: SequenceType.FILE, name: 'ümläutß', size: 123456}],
+  ['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:',
    {
-      type: SequenceType.FILE,
      inline: 1,
      width: '10px',
      height: '20%',
@@ -29,7 +28,6 @@ const CASES: [string, IHeaderFields][] = [
  [
    'File=inline=1;width=auto;height=20;preserveAspectRatio=1;size=123456;name=w7xtbMOkdXTDnw:',
    {
-      type: SequenceType.FILE,
      inline: 1,
      width: 'auto',
      height: '20',
@@ -103,7 +101,7 @@ describe('IIPHeaderParser', () => {
    let res = hp.parse(inp, 0, inp.length);
    assert.strictEqual(res, inp.length);
    assert.strictEqual(hp.state, HeaderState.END);
-    assert.deepEqual(hp.fields, {type: SequenceType.FILE, name: 'test', size: 0});
+    assert.deepEqual(hp.fields, {name: 'test', size: 0});
    hp.reset();
    inp = fromBs(CASES[0][0]);
    res = hp.parse(inp, 0, inp.length);
@@ -117,7 +115,7 @@ describe('IIPHeaderParser', () => {
    let res = hp.parse(inp, 0, inp.length);
    assert.strictEqual(res, inp.length);
    assert.strictEqual(hp.state, HeaderState.END);
-    assert.deepEqual(hp.fields, {type: SequenceType.FILE, name: '', size: 123456});
+    assert.deepEqual(hp.fields, {name: '', size: 123456});
    hp.reset();
    inp = fromBs(CASES[0][0]);
    res = hp.parse(inp, 0, inp.length);
@@ -137,124 +135,4 @@ describe('IIPHeaderParser', () => {
    assert.strictEqual(hp.state, HeaderState.END);
    assert.deepEqual(hp.fields, CASES[0][1]);
  });
-  it('FilePart sequence', () => {
-    const hp = new HeaderParser();
-    const inp = fromBs('FilePart=w7xtbMOkdXTDnw');
-    const res = hp.parse(inp, 0, inp.length);
-    assert.strictEqual(res, 9);
-    assert.strictEqual(hp.state, HeaderState.END);
-    assert.deepEqual(hp.fields.type, SequenceType.FILEPART);
-  });
-  it('FilePart sequence - bytewise', () => {
-    const hp = new HeaderParser();
-    const inp = fromBs('FilePart=w7xtbMOkdXTDnw');
-    let res = -2;
-    let pos = 0;
-    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.type, SequenceType.FILEPART);
-  });
-  it('MultipartFile sequence', () => {
-    const hp = new HeaderParser();
-    const inp = fromBs('MultipartFile=inline=1;width=10px;height=20%;preserveAspectRatio=1;size=123456;name=w7xtbMOkdXTDnw');
-    let res = hp.parse(inp, 0, inp.length);
-    assert.strictEqual(res, -2);
-    assert.strictEqual(hp.state, HeaderState.VALUE);
-    res = hp.end();
-    assert.strictEqual(res, 0);
-    assert.strictEqual(hp.state, HeaderState.END);
-    assert.deepEqual(
-      hp.fields,
-      {
-        type: SequenceType.MULTIPARTFILE,
-        inline: 1,
-        width: '10px',
-        height: '20%',
-        preserveAspectRatio: 1,
-        size: 123456,
-        name: 'ümläutß'
-      }
-    );
-  });
-  it('MultipartFile sequence - bytewise', () => {
-    const hp = new HeaderParser();
-    const inp = fromBs('MultipartFile=inline=1;width=10px;height=20%;preserveAspectRatio=1;size=123456;name=w7xtbMOkdXTDnw');
-    let res = -2;
-    let pos = 0;
-    while (res === -2 && pos < inp.length) {
-      res = hp.parse(new Uint32Array([inp[pos++]]), 0, 1);
-    }
-    assert.strictEqual(res, -2);
-    assert.strictEqual(hp.state, HeaderState.VALUE);
-    res = hp.end();
-    assert.strictEqual(res, 0);
-    assert.strictEqual(hp.state, HeaderState.END);
-    assert.deepEqual(
-      hp.fields,
-      {
-        type: SequenceType.MULTIPARTFILE,
-        inline: 1,
-        width: '10px',
-        height: '20%',
-        preserveAspectRatio: 1,
-        size: 123456,
-        name: 'ümläutß'
-      }
-    );
-  });
-  it('FileEnd sequence', () => {
-    const hp = new HeaderParser();
-    const inp = fromBs('FileEnd');
-    let res = hp.parse(inp, 0, inp.length);
-    assert.strictEqual(res, -2);
-    assert.strictEqual(hp.state, HeaderState.START);
-    res = hp.end();
-    assert.strictEqual(res, 0);
-    assert.strictEqual(hp.state, HeaderState.END);
-    assert.deepEqual(hp.fields.type, SequenceType.FILEEND);
-  });
-  it('FileEnd sequence - bytewise', () => {
-    const hp = new HeaderParser();
-    const inp = fromBs('FileEnd');
-    let res = -2;
-    let pos = 0;
-    while (res === -2 && pos < inp.length) {
-      res = hp.parse(new Uint32Array([inp[pos++]]), 0, 1);
-    }
-    assert.strictEqual(res, -2);
-    assert.strictEqual(hp.state, HeaderState.START);
-    res = hp.end();
-    assert.strictEqual(res, 0);
-    assert.strictEqual(hp.state, HeaderState.END);
-    assert.deepEqual(hp.fields.type, SequenceType.FILEEND);
-  });
-  it('ReportCellSize sequence', () => {
-    const hp = new HeaderParser();
-    const inp = fromBs('ReportCellSize');
-    let res = hp.parse(inp, 0, inp.length);
-    assert.strictEqual(res, -2);
-    assert.strictEqual(hp.state, HeaderState.START);
-    res = hp.end();
-    assert.strictEqual(res, 0);
-    assert.strictEqual(hp.state, HeaderState.END);
-    assert.deepEqual(hp.fields, { type: SequenceType.REPORTCELLSIZE });
-  });
-  it('ReportCellSize sequence - bytewise', () => {
-    const hp = new HeaderParser();
-    const inp = fromBs('ReportCellSize');
-    let res = -2;
-    let pos = 0;
-    while (res === -2 && pos < inp.length) {
-      res = hp.parse(new Uint32Array([inp[pos++]]), 0, 1);
-    }
-    assert.strictEqual(res, -2);
-    assert.strictEqual(hp.state, HeaderState.START);
-    res = hp.end();
-    assert.strictEqual(res, 0);
-    assert.strictEqual(hp.state, HeaderState.END);
-    assert.deepEqual(hp.fields, { type: SequenceType.REPORTCELLSIZE });
-  });
 });
@@ -6,27 +6,8 @@
 // eslint-disable-next-line
 declare const Buffer: any;

-export const enum HeaderState {
-  START = 0,
-  ABORT = 1,
-  KEY = 2,
-  VALUE = 3,
-  END = 4
-}
-
-export const enum SequenceType {
-  INVALID = 0,
-  FILE = 1,
-  MULTIPARTFILE = 2,
-  FILEPART = 3,
-  FILEEND = 4,
-  REPORTCELLSIZE = 5
-}

 export interface IHeaderFields {
-  [key: string]: number | string | Uint32Array | null | undefined;
-  // sequence type
-  type: SequenceType;
  // 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.
@@ -47,6 +28,14 @@ export interface IHeaderFields {
  inline?: number;
 }

+export const enum HeaderState {
+  START = 0,
+  ABORT = 1,
+  KEY = 2,
+  VALUE = 3,
+  END = 4
+}
+
 // field value decoders

 // ASCII bytes to string
@@ -92,7 +81,7 @@ function toName(data: Uint32Array): string {
  return new TextDecoder().decode(b);
 }

-const DECODERS: {[key: string]: (v: Uint32Array) => number | string} = {
+const DECODERS: {[key: string]: (v: Uint32Array) => any} = {
  inline: toInt,
  size: toInt,
  name: toName,
@@ -102,19 +91,7 @@ const DECODERS: {[key: string]: (v: Uint32Array) => number | string} = {
 };


-// sequence type markers
-// File
 const FILE_MARKER = [70, 105, 108, 101];
-// MultipartFile
-const MULTIPARTFILE_MARKER = [77, 117, 108, 116, 105, 112, 97, 114, 116, 70, 105, 108, 101];
-// FilePart
-const FILEPART_MARKER = [70, 105, 108, 101, 80, 97, 114, 116];
-// FileEnd
-const FILEEND_MARKER = [70, 105, 108, 101, 69, 110, 100];
-// ReportCellSize
-const REPORTCELLSIZE_MARKER = [82, 101, 112, 111, 114, 116, 67, 101, 108, 108, 83, 105, 122, 101];
-
-// max allowed chars for sequence header
 const MAX_FIELDCHARS = 1024;


@@ -123,7 +100,7 @@ export class HeaderParser {
  private _buffer = new Uint32Array(MAX_FIELDCHARS);
  private _position = 0;
  private _key = '';
-  public fields: {[key: string]: number | string | Uint32Array | null | undefined} = {};
+  public fields: {[key: string]: any} = {};

  public reset(): void {
    this._buffer.fill(0);
@@ -133,43 +110,12 @@ export class HeaderParser {
    this._key = '';
  }

-  public end(): number {
-    if (this.state === HeaderState.START) {
-      if (this._position === FILEEND_MARKER.length) {
-        for (let k = 0; k < FILEEND_MARKER.length; ++k) {
-          if (this._buffer[k] !== FILEEND_MARKER[k]) return this._a();
-        }
-        this.fields['type'] = SequenceType.FILEEND;
-        this.state = HeaderState.END;
-        return 0;
-      }
-      if (this._position === REPORTCELLSIZE_MARKER.length) {
-        for (let k = 0; k < REPORTCELLSIZE_MARKER.length; ++k) {
-          if (this._buffer[k] !== REPORTCELLSIZE_MARKER[k]) return this._a();
-        }
-        this.fields['type'] = SequenceType.REPORTCELLSIZE;
-        this.state = HeaderState.END;
-        return 0;
-      }
-      return this._a();
-    }
-    if (this.state === HeaderState.END) return 0;
-    if (this.state === HeaderState.VALUE
-      && this.fields.type === SequenceType.MULTIPARTFILE
-    ) {
-      if (!this._storeValue(this._position)) return this._a();
-      this.state = HeaderState.END;
-      return 0;
-    }
-    return this._a();
-  }
-
  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 > 14) return -1;
+    if (state === HeaderState.START && pos > 6) return -1;
    for (let i = start; i < end; ++i) {
      const c = data[i];
      switch (c) {
@@ -180,29 +126,8 @@ export class HeaderParser {
          break;
        case 61: // =
          if (state === HeaderState.START) {
-            if (buffer[0] === 70) {
-              // 'File' or 'FilePart'
-              let k = 0;
-              for (; k < FILE_MARKER.length; ++k) {
-                if (buffer[k] !== FILE_MARKER[k]) return this._a();
-              }
-              this.fields['type'] = SequenceType.FILE;
-              if (pos === FILEPART_MARKER.length) {
-                for (; k < FILEPART_MARKER.length; ++k) {
-                  if (buffer[k] !== FILEPART_MARKER[k]) return this._a();
-                }
-                this.fields['type'] = SequenceType.FILEPART;
-                this.state = HeaderState.END;
-                return i + 1;
-              }
-            } else if (buffer[0] === 77) {
-              // 'MultipartFile'
-              for (let k = 0; k < MULTIPARTFILE_MARKER.length; ++k) {
-                if (buffer[k] !== MULTIPARTFILE_MARKER[k]) return this._a();
-              }
-              this.fields['type'] = SequenceType.MULTIPARTFILE;
-            } else {
-              return this._a();
+            for (let k = 0; k < FILE_MARKER.length; ++k) {
+              if (buffer[k] !== FILE_MARKER[k]) return this._a();
            }
            state = HeaderState.KEY;
            pos = 0;
@@ -232,7 +157,6 @@ export class HeaderParser {
  }

  private _a(): number {
-    this.fields.type = SequenceType.INVALID;
    this.state = HeaderState.ABORT;
    return -1;
  }
@@ -252,7 +176,7 @@ export class HeaderParser {
      try {
        const v = this._buffer.slice(0, pos);
        this.fields[this._key] = DECODERS[this._key] ? DECODERS[this._key](v) : v;
-      } catch {
+      } catch (e) {
        return false;
      }
      return true;
@@ -1,28 +0,0 @@
-/**
- * Copyright (c) 2023 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { IAddImageOpts } from 'Types';
-import { ImageStorage } from './ImageStorage';
-
-/**
- * IIP (iTerm Image Protocol) specific image storage controller.
- *
- * Wraps the shared ImageStorage with IIP protocol semantics:
- * - Always uses scrolling mode (cursor advances with image)
- */
-export class IIPImageStorage {
-  private _addImageOpts: IAddImageOpts = { scrolling: true, layer: 'top', zIndex: 0, cursorPos: 'iip' };
-  constructor(
-    private readonly _storage: ImageStorage
-  ) {}
-
-  /**
-   * Add an IIP image to storage.
-   * Always uses scrolling mode — cursor advances past the image.
-   */
-  public addImage(img: HTMLCanvasElement | ImageBitmap): void {
-    this._storage.addImage(img, this._addImageOpts);
-  }
-}
@@ -30,8 +30,7 @@ const TEST_IMAGES: [string, IMetrics][] = [
  ['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 }],
-  ['dice.qoi', { mime: 'image/qoi', width: 800, height: 600 }],
+  ['sony-alpha-6000.jpg', { mime: 'image/jpeg', width: 6000, height: 4000 }]
 ];


@@ -4,7 +4,7 @@
 */


-export type ImageType = 'image/png' | 'image/jpeg' | 'image/gif' | 'image/qoi' | 'unsupported' | '';
+export type ImageType = 'image/png' | 'image/jpeg' | 'image/gif' | 'unsupported' | '';

 export interface IMetrics {
  mime: ImageType;
@@ -45,14 +45,6 @@ export function imageType(d: Uint8Array): IMetrics {
      height: d[9] << 8 | d[8]
    };
  }
-  // QOI: qoif
-  if (d32[0] === 0x66696F71) {
-    return {
-      mime: 'image/qoi',
-      width: d[4] << 24 | d[5] << 16 | d[6] << 8 | d[7],
-      height: d[8] << 24 | d[9] << 16 | d[10] << 8 | d[11]
-    };
-  }
  return UNSUPPORTED_TYPE;
 }

@@ -5,72 +5,24 @@

 import type { ITerminalAddon, IDisposable } from '@xterm/xterm';
 import type { ImageAddon as IImageApi } from '@xterm/addon-image';
-import { Emitter, type IEvent } from 'common/Event';
 import { IIPHandler } from './IIPHandler';
 import { ImageRenderer } from './ImageRenderer';
 import { ImageStorage, CELL_SIZE_DEFAULT } from './ImageStorage';
-import { KittyGraphicsHandler } from './kitty/KittyGraphicsHandler';
-import { KittyImageStorage } from './kitty/KittyImageStorage';
 import { SixelHandler } from './SixelHandler';
-import { SixelImageStorage } from './SixelImageStorage';
-import { IIPImageStorage } from './IIPImageStorage';
 import { ITerminalExt, IImageAddonOptions, IResetHandler } from './Types';

-
-/**
- * Document VT features provided by this addon.
- *
- * @vt: #E[Supported via @xterm/addon-image.] DCS SIXEL "SIXEL Graphics"  "DCS Ps ; Ps ; Ps ; q Pt ST"  "Draw SIXEL image."
- *
- * Sixel support is provided by the addon @xterm/addon-image with these limitations:
- * - immediate coloring (no shared palette, allows high color settings of `img2sixel`)
- * - max. palette size of 4096 colors
- * - max. pixel width of 16K
- * - max. 25 MB per sixel sequence
- * - VT340 cursor positioning (begin of last sixel data row)
- *
- * See [addon readme](https://github.com/xtermjs/xterm.js/tree/master/addons/addon-image) for more details.
- *
- *
- * @vt: #E[Supported via @xterm/addon-image.] OSC 1337  "iTerm2 Commands"   "OSC 1337 ; Pt BEL"  "Custom iTerm2 commands."
- *
- * Only the inline image protocol (IIP) is supported by the addon @xterm/addon-image with
- * the following limitations:
- * - sequence:
- *   - format: `OSC 1337 ; File=inline=1 ; size=<unencoded size> ; ... : <base64 payload> BEL`
- *   - size param must be set and payload may not exceed CEIL(size * 4 / 3)
- *   - strict base64 handling as of RFC4648 §4 (standard alphabet, optional padding,
- *     no separator bytes allowed)
- *   - supported params: size, name, width, height, preserveAspectRatio
- * - image formats: PNG, JPEG and GIF
- * - no animation support (renders first image of a GIF)
- * - no multipart support
- * - VT340 cursor positioning (begin of last sixel data row)
- *
- * See [addon readme](https://github.com/xtermjs/xterm.js/tree/master/addons/addon-image)
- * and [iTerm2 IIP docs](https://iterm2.com/documentation-images.html) for more details.
- *
- *
- * @vt: #E[Supported via @xterm/addon-image.] APC KITTY_GRAPHICS "Kitty Graphics"  "APC G Pt ST"  "Kitty Graphics Protocol."
- *
- * Kitty graphics support is provided by the addon @xterm/addon-image.
- * Note that while basic image output already works, this is still work in progress.
- */
-
 // default values of addon ctor options
 const DEFAULT_OPTIONS: IImageAddonOptions = {
  enableSizeReports: true,
  pixelLimit: 16777216, // limit to 4096 * 4096 pixels
  sixelSupport: true,
  sixelScrolling: true,
-  sixelPaletteLimit: 4096,
-  sixelSizeLimit: 33554432,
+  sixelPaletteLimit: 256,
+  sixelSizeLimit: 25000000,
  storageLimit: 128,
  showPlaceholder: true,
  iipSupport: true,
-  iipSizeLimit: 33554432,
-  kittySupport: true,
-  kittySizeLimit: 33554432
+  iipSizeLimit: 20000000
 };

 // max palette size supported by the sixel lib (compile time setting)
@@ -96,7 +48,7 @@ const enum GaStatus {
 }


-export class ImageAddon implements ITerminalAddon, IImageApi {
+export class ImageAddon implements ITerminalAddon , IImageApi {
  private _opts: IImageAddonOptions;
  private _defaultOpts: IImageAddonOptions;
  private _storage: ImageStorage | undefined;
@@ -104,8 +56,6 @@ export class ImageAddon implements ITerminalAddon, IImageApi {
  private _disposables: IDisposable[] = [];
  private _terminal: ITerminalExt | undefined;
  private _handlers: Map<String, IResetHandler> = new Map();
-  private readonly _onImageAdded = new Emitter<void>();
-  public readonly onImageAdded: IEvent<void> = this._onImageAdded.event;

  constructor(opts?: Partial<IImageAddonOptions>) {
    this._opts = Object.assign({}, DEFAULT_OPTIONS, opts);
@@ -118,7 +68,6 @@ export class ImageAddon implements ITerminalAddon, IImageApi {
    }
    this._disposables.length = 0;
    this._handlers.clear();
-    this._onImageAdded.dispose();
  }

  private _disposeLater(...args: IDisposable[]): void {
@@ -133,11 +82,15 @@ export class ImageAddon implements ITerminalAddon, IImageApi {
    // internal data structures
    this._renderer = new ImageRenderer(terminal);
    this._storage = new ImageStorage(terminal, this._renderer, this._opts);
-    this._storage.onImageAdded = () => this._onImageAdded.fire();

    // enable size reports
    if (this._opts.enableSizeReports) {
-      const windowOps = terminal.options.windowOptions ?? {};
+      // 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;
@@ -176,8 +129,7 @@ export class ImageAddon implements ITerminalAddon, IImageApi {

    // SIXEL handler
    if (this._opts.sixelSupport) {
-      const sixelStorage = new SixelImageStorage(this._storage!, this._opts, this._renderer!, terminal);
-      const sixelHandler = new SixelHandler(this._opts, sixelStorage, terminal);
+      const sixelHandler = new SixelHandler(this._opts, this._storage!, terminal);
      this._handlers.set('sixel', sixelHandler);
      this._disposeLater(
        terminal._core._inputHandler._parser.registerDcsHandler({ final: 'q' }, sixelHandler)
@@ -186,25 +138,12 @@ export class ImageAddon implements ITerminalAddon, IImageApi {

    // iTerm IIP handler
    if (this._opts.iipSupport) {
-      const iipStorage = new IIPImageStorage(this._storage!);
-      const iipHandler = new IIPHandler(this._opts, this._renderer!, iipStorage, terminal);
+      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)
      );
    }
-
-    // Kitty graphics handler
-    if (this._opts.kittySupport) {
-      const kittyStorage = new KittyImageStorage(this._storage!);
-      const kittyHandler = new KittyGraphicsHandler(this._opts, this._renderer!, kittyStorage, terminal);
-      this._handlers.set('kitty', kittyHandler);
-      this._disposeLater(
-        kittyStorage,
-        kittyHandler,
-        terminal._core._inputHandler._parser.registerApcHandler({ final: 'G' }, kittyHandler)
-      );
-    }
  }

  // Note: storageLimit is skipped here to not intoduce a surprising side effect.
@@ -255,7 +194,7 @@ export class ImageAddon implements ITerminalAddon, IImageApi {
  }

  private _report(s: string): void {
-    this._terminal?._core.input(s, false);
+    this._terminal?._core.coreService.triggerDataEvent(s);
  }

  private _decset(params: (number | number[])[]): boolean {
@@ -5,13 +5,11 @@

 import { toRGBA8888 } from 'sixel/lib/Colors';
 import { IDisposable } from '@xterm/xterm';
-import { ICellSize, ImageLayer, ITerminalExt, IImageSpec, IRenderDimensions, IRenderService } from './Types';
-import { Disposable, MutableDisposable, toDisposable } from 'common/Lifecycle';
+import { ICellSize, ITerminalExt, IImageSpec, IRenderDimensions, IRenderService } from './Types';
+import { Disposable, MutableDisposable, toDisposable } from 'vs/base/common/lifecycle';

-const enum Constants {
-  PLACEHOLDER_LENGTH = 4096,
-  PLACEHOLDER_HEIGHT = 24
-}
+const PLACEHOLDER_LENGTH = 4096;
+const PLACEHOLDER_HEIGHT = 24;

 /**
 * ImageRenderer - terminal frontend extension:
@@ -20,9 +18,8 @@ const enum Constants {
 * - draw image tiles onRender
 */
 export class ImageRenderer extends Disposable implements IDisposable {
-  /** @deprecated Kept for backward compat — points to top layer canvas. */
-  public get canvas(): HTMLCanvasElement | undefined { return this._layers.get('top')?.canvas; }
-  private _layers = new Map<ImageLayer, CanvasRenderingContext2D>();
+  public canvas: HTMLCanvasElement | undefined;
+  private _ctx: CanvasRenderingContext2D | null | undefined;
  private _placeholder: HTMLCanvasElement | undefined;
  private _placeholderBitmap: ImageBitmap | undefined;
  private _optionsRefresh = this._register(new MutableDisposable());
@@ -41,7 +38,7 @@ export class ImageRenderer extends Disposable implements IDisposable {
     * Only the DOM output canvas should be on the terminal's document,
     * which gets explicitly checked in `insertLayerToDom`.
     */
-    const canvas = (localDocument ?? document).createElement('canvas');
+    const canvas = (localDocument || document).createElement('canvas');
    canvas.width = width | 0;
    canvas.height = height | 0;
    return canvas;
@@ -89,7 +86,6 @@ export class ImageRenderer extends Disposable implements IDisposable {
    });
    this._register(toDisposable(() => {
      this.removeLayerFromDom();
-      this.removeLayerFromDom('bottom');
      if (this._terminal._core && this._oldOpen) {
        this._terminal._core.open = this._oldOpen;
        this._oldOpen = undefined;
@@ -99,7 +95,8 @@ export class ImageRenderer extends Disposable implements IDisposable {
        this._oldSetRenderer = undefined;
      }
      this._renderService = undefined;
-      this._layers.clear();
+      this.canvas = undefined;
+      this._ctx = undefined;
      this._placeholderBitmap?.close();
      this._placeholderBitmap = undefined;
      this._placeholder = undefined;
@@ -112,7 +109,7 @@ export class ImageRenderer extends Disposable implements IDisposable {
  public showPlaceholder(value: boolean): void {
    if (value) {
      if (!this._placeholder && this.cellSize.height !== -1) {
-        this._createPlaceHolder(Math.max(this.cellSize.height + 1, Constants.PLACEHOLDER_HEIGHT));
+        this._createPlaceHolder(Math.max(this.cellSize.height + 1, PLACEHOLDER_HEIGHT));
      }
    } else {
      this._placeholderBitmap?.close();
@@ -127,7 +124,7 @@ export class ImageRenderer extends Disposable implements IDisposable {
   * Forwarded from internal render service.
   */
  public get dimensions(): IRenderDimensions | undefined {
-    return this._terminal.dimensions;
+    return this._renderService?.dimensions;
  }

  /**
@@ -143,38 +140,27 @@ export class ImageRenderer extends Disposable implements IDisposable {
  /**
   * Clear a region of the image layer canvas.
   */
-  public clearLines(start: number, end: number, layer?: ImageLayer): void {
-    const y = start * (this.dimensions?.css.cell.height || 0);
-    const w = this.dimensions?.css.canvas.width || 0;
-    const h = (end + 1 - start) * (this.dimensions?.css.cell.height || 0);
-    if (!layer || layer === 'top') {
-      this._layers.get('top')?.clearRect(0, y, w, h);
-    }
-    if (!layer || layer === 'bottom') {
-      this._layers.get('bottom')?.clearRect(0, y, w, h);
-    }
+  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(layer?: ImageLayer): void {
-    if (!layer || layer === 'top') {
-      const ctx = this._layers.get('top');
-      ctx?.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
-    }
-    if (!layer || layer === 'bottom') {
-      const ctx = this._layers.get('bottom');
-      ctx?.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
-    }
+  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 {
-    const ctx = this._layers.get(imgSpec.layer);
-    if (!ctx) {
+    if (!this._ctx) {
      return;
    }
    const { width, height } = this.cellSize;
@@ -201,7 +187,7 @@ export class ImageRenderer extends Disposable implements IDisposable {
    // 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
-    ctx.drawImage(
+    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)
@@ -241,8 +227,7 @@ export class ImageRenderer extends Disposable implements IDisposable {
   * Draw a line with placeholder on the image layer canvas.
   */
  public drawPlaceholder(col: number, row: number, count: number = 1): void {
-    const ctx = this._layers.get('top');
-    if (ctx) {
+    if (this._ctx) {
      const { width, height } = this.cellSize;

      // Don't try to draw anything, if we cannot get valid renderer metrics.
@@ -251,13 +236,13 @@ export class ImageRenderer extends Disposable implements IDisposable {
      }

      if (!this._placeholder) {
-        this._createPlaceHolder(Math.max(height + 1, Constants.PLACEHOLDER_HEIGHT));
+        this._createPlaceHolder(Math.max(height + 1, PLACEHOLDER_HEIGHT));
      } else if (height >= this._placeholder!.height) {
        this._createPlaceHolder(height + 1);
      }
      if (!this._placeholder) return;
-      ctx.drawImage(
-        this._placeholderBitmap ?? this._placeholder!,
+      this._ctx.drawImage(
+        this._placeholderBitmap || this._placeholder!,
        col * width,
        (row * height) % 2 ? 0 : 1,  // needs %2 offset correction
        width * count,
@@ -275,13 +260,12 @@ export class ImageRenderer extends Disposable implements IDisposable {
   * Checked once from `ImageStorage.render`.
   */
  public rescaleCanvas(): void {
-    const w = this.dimensions?.css.canvas.width || 0;
-    const h = this.dimensions?.css.canvas.height || 0;
-    for (const ctx of this._layers.values()) {
-      if (ctx.canvas.width !== w || ctx.canvas.height !== h) {
-        ctx.canvas.width = w;
-        ctx.canvas.height = h;
-      }
+    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;
    }
  }

@@ -320,68 +304,38 @@ export class ImageRenderer extends Disposable implements IDisposable {
    this._renderService = this._terminal._core._renderService;
    this._oldSetRenderer = this._renderService.setRenderer.bind(this._renderService);
    this._renderService.setRenderer = (renderer: any) => {
-      for (const key of [...this._layers.keys()]) {
-        this.removeLayerFromDom(key);
-      }
+      this.removeLayerFromDom();
      this._oldSetRenderer?.call(this._renderService, renderer);
    };
  }

-  public insertLayerToDom(layer: ImageLayer = 'top'): void {
+  public insertLayerToDom(): void {
    // make sure that the terminal is attached to a document and to DOM
-    if (!this.document || !this._terminal._core.screenElement) {
-      console.warn('image addon: cannot insert output canvas to DOM, missing document or screenElement');
-      return;
-    }
-    if (this._layers.has(layer)) {
-      return;
-    }
-    const canvas = ImageRenderer.createCanvas(
-      this.document, this.dimensions?.css.canvas.width || 0,
-      this.dimensions?.css.canvas.height || 0
-    );
-    canvas.classList.add(`xterm-image-layer-${layer}`);
-    const screenElement = this._terminal._core.screenElement;
-    // Use isolation to create a stacking context without overriding z-index,
-    // which would conflict with integrators (e.g. VS Code) that set their
-    // own z-index on the screen element.
-    screenElement.style.isolation = 'isolate';
-    if (layer === 'bottom') {
-      // Use z-index:-1 so it paints behind non-positioned text elements.
-      // The screen element needs to be a stacking context (via isolation)
-      // to contain the negative z-index, otherwise it would go behind the
-      // entire terminal.
-      canvas.style.zIndex = '-1';
-      screenElement.insertBefore(canvas, screenElement.firstChild);
+    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 {
-      // Explicit z-index ensures the image canvas reliably stacks above
-      // the text layer (DOM renderer rows). z-index: 0 is below the
-      // selection overlay (z-index: 1).
-      canvas.style.zIndex = '0';
-      screenElement.appendChild(canvas);
-    }
-    const ctx = canvas.getContext('2d', { alpha: true });
-    if (!ctx) {
-      canvas.remove();
-      return;
-    }
-    this._layers.set(layer, ctx);
-    this.clearAll(layer);
-  }
-
-  public removeLayerFromDom(layer: ImageLayer = 'top'): void {
-    const ctx = this._layers.get(layer);
-    if (ctx) {
-      ctx.canvas.remove();
-      this._layers.delete(layer);
+      console.warn('image addon: cannot insert output canvas to DOM, missing document or screenElement');
    }
  }

-  public hasLayer(layer: ImageLayer): boolean {
-    return this._layers.has(layer);
+  public removeLayerFromDom(): void {
+    if (this.canvas) {
+      this._ctx = undefined;
+      this.canvas.remove();
+      this.canvas = undefined;
+    }
  }

-  private _createPlaceHolder(height: number = Constants.PLACEHOLDER_HEIGHT): void {
+  private _createPlaceHolder(height: number = PLACEHOLDER_HEIGHT): void {
    this._placeholderBitmap?.close();
    this._placeholderBitmap = undefined;

@@ -405,7 +359,7 @@ export class ImageRenderer extends Disposable implements IDisposable {
    ctx.putImageData(imgData, 0, 0);

    // create placeholder line, width aligned to blueprint width
-    const width = (screen.width + bWidth - 1) & ~(bWidth - 1) || Constants.PLACEHOLDER_LENGTH;
+    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) {
@@ -5,11 +5,7 @@

 import { IDisposable } from '@xterm/xterm';
 import { ImageRenderer } from './ImageRenderer';
-import {
-  ITerminalExt, IExtendedAttrsImage, IImageAddonOptions, IImageSpec,
-  IBufferLineExt, BgFlags, Cell, Content, ICellSize, ExtFlags, Attributes,
-  UnderlineStyle, IAddImageOpts
-} from './Types';
+import { ITerminalExt, IExtendedAttrsImage, IImageAddonOptions, IImageSpec, IBufferLineExt, BgFlags, Cell, Content, ICellSize, ExtFlags, Attributes, UnderlineStyle } from './Types';


 // fallback default cell size
@@ -128,8 +124,6 @@ export class ImageStorage implements IDisposable {
  private _pixelLimit: number = 2500000;

  private _viewportMetrics: { cols: number, rows: number };
-  public onImageAdded: (() => void) | undefined;
-  public onImageDeleted: ((storageId: number) => void) | undefined;

  constructor(
    private _terminal: ITerminalExt,
@@ -138,10 +132,8 @@ export class ImageStorage implements IDisposable {
  ) {
    try {
      this.setLimit(this._opts.storageLimit);
-    } catch (e: unknown) {
-      if (e instanceof Error) {
-        console.error(e.message);
-      }
+    } catch (e: any) {
+      console.error(e.message);
      console.warn(`storageLimit is set to ${this.getLimit()} MB`);
    }
    this._viewportMetrics = {
@@ -195,13 +187,11 @@ export class ImageStorage implements IDisposable {

  private _delImg(id: number): void {
    const spec = this._images.get(id);
-    if (!spec) return;
    this._images.delete(id);
    // FIXME: really ugly workaround to get bitmaps deallocated :(
-    if (window.ImageBitmap && spec.orig instanceof ImageBitmap) {
+    if (spec && window.ImageBitmap && spec.orig instanceof ImageBitmap) {
      spec.orig.close();
    }
-    this.onImageDeleted?.(id);
  }

  /**
@@ -225,29 +215,27 @@ export class ImageStorage implements IDisposable {
  }

  /**
-   * Delete an image by its internal storage ID.
-   * Used by protocols that support explicit deletion (e.g. Kitty a=d).
+   * 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 deleteImage(id: number): void {
-    const spec = this._images.get(id);
-    if (spec) {
-      spec.marker?.dispose();
-      this._delImg(id);
+  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.
-   * @param img - The image to add (canvas or bitmap).
-   * @param opts - Options for addImage:
-   *   - scrolling:  When true, cursor advances with the image.
-   *                 When false, image is placed at ORIGIN and cursor does not move.
-   *   - layer:      Which canvas layer to render on ('top' or 'bottom').
-   *   - zIndex:     Z-index for image layering within the same layer.
-   *   - cursorPos:  'vt340' for bottom-left, 'iip' for bottom.right.
-   * @returns The internal image ID assigned to the stored image.
   */
-  public addImage(img: HTMLCanvasElement | ImageBitmap, opts: IAddImageOpts): number {
+  public addImage(img: HTMLCanvasElement | ImageBitmap): void {
    // never allow storage to exceed memory limit
    this._evictOldest(img.width * img.height);

@@ -269,7 +257,7 @@ export class ImageStorage implements IDisposable {
    let offset = originX;
    let tileCount = 0;

-    if (!opts.scrolling) {
+    if (!this._opts.sixelScrolling) {
      buffer.x = 0;
      buffer.y = 0;
      offset = 0;
@@ -283,7 +271,7 @@ export class ImageStorage implements IDisposable {
        this._writeToCell(line as IBufferLineExt, offset + col, imageId, row * cols + col);
        tileCount++;
      }
-      if (opts.scrolling) {
+      if (this._opts.sixelScrolling) {
        if (row < rows - 1) this._terminal._core._inputHandler.lineFeed();
      } else {
        if (++buffer.y >= termRows) break;
@@ -293,12 +281,8 @@ export class ImageStorage implements IDisposable {
    this._terminal._core._inputHandler._dirtyRowTracker.markDirty(buffer.y);

    // cursor positioning modes
-    if (opts.scrolling) {
-      if (opts.cursorPos === 'iip') {
-        buffer.x = Math.min(offset + cols, termCols);
-      } else {
-        buffer.x = offset;
-      }
+    if (this._opts.sixelScrolling) {
+      buffer.x = offset;
    } else {
      buffer.x = originX;
      buffer.y = originY;
@@ -340,15 +324,11 @@ export class ImageStorage implements IDisposable {
      actualCellSize: { ...cellSize },  // clone needed, since later modified
      marker: endMarker || undefined,
      tileCount,
-      bufferType: this._terminal.buffer.active.type,
-      layer: opts.layer,
-      zIndex: opts.zIndex
+      bufferType: this._terminal.buffer.active.type
    };

    // finally add the image
    this._images.set(imageId, imgSpec);
-    this.onImageAdded?.();
-    return imageId;
  }


@@ -358,30 +338,16 @@ export class ImageStorage implements IDisposable {
   */
  // TODO: Should we move this to the ImageRenderer?
  public render(range: { start: number, end: number }): void {
-    // Determine which layers have images
-    let hasTopImages = false;
-    let hasBottomImages = false;
-    for (const spec of this._images.values()) {
-      if (spec.layer === 'bottom') {
-        hasBottomImages = true;
-      } else {
-        hasTopImages = true;
+    // 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;
      }
-      if (hasTopImages && hasBottomImages) break;
    }
-
-    // Lazily insert layers that are needed
-    if (hasTopImages && !this._renderer.hasLayer('top')) {
-      this._renderer.insertLayerToDom('top');
-      if (!this._renderer.hasLayer('top')) return;
-    }
-    if (hasBottomImages && !this._renderer.hasLayer('bottom')) {
-      this._renderer.insertLayerToDom('bottom');
-    }
-
    // rescale if needed
    this._renderer.rescaleCanvas();
-
    // exit early if we dont have any images to test for
    if (!this._images.size) {
      if (!this._fullyCleared) {
@@ -389,25 +355,12 @@ export class ImageStorage implements IDisposable {
        this._fullyCleared = true;
        this._needsFullClear = false;
      }
-      if (this._renderer.hasLayer('top')) {
-        this._renderer.removeLayerFromDom('top');
-      }
-      if (this._renderer.hasLayer('bottom')) {
-        this._renderer.removeLayerFromDom('bottom');
+      if (this._renderer.canvas) {
+        this._renderer.removeLayerFromDom();
      }
      return;
    }

-    // Remove layers no longer needed
-    if (!hasTopImages && this._renderer.hasLayer('top')) {
-      this._renderer.clearAll('top');
-      this._renderer.removeLayerFromDom('top');
-    }
-    if (!hasBottomImages && this._renderer.hasLayer('bottom')) {
-      this._renderer.clearAll('bottom');
-      this._renderer.removeLayerFromDom('bottom');
-    }
-
    // buffer switches force a full clear
    if (this._needsFullClear) {
      this._renderer.clearAll();
@@ -422,76 +375,50 @@ export class ImageStorage implements IDisposable {
    // clear drawing area
    this._renderer.clearLines(start, end);

-    // Collect draw calls so we can sort by z-index (lower z drawn first).
-    const drawCalls: { imgSpec: IImageSpec, tileId: number, col: number, row: number, count: number }[] = [];
-    const placeholderCalls: { col: number, row: number, count: number }[] = [];
-
-    // walk all cells in viewport and collect tiles found
-    // Note: We check _extendedAttrs directly (not just HAS_EXTENDED flag)
-    // because text writes clear the BG flag but leave image tile data intact.
-    // This lets top-layer images survive text overwrites (kitty C=1 behavior).
+    // 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) {
-        let e: IExtendedAttrsImage;
        if (line.getBg(col) & BgFlags.HAS_EXTENDED) {
-          e = line._extendedAttrs[col] ?? EMPTY_ATTRS;
-        } else {
-          const maybeImg = line._extendedAttrs[col] as IExtendedAttrsImage | undefined;
-          if (!maybeImg || maybeImg.imageId === undefined || maybeImg.imageId === -1) {
+          let e: IExtendedAttrsImage = line._extendedAttrs[col] || EMPTY_ATTRS;
+          const imageId = e.imageId;
+          if (imageId === undefined || imageId === -1) {
            continue;
          }
-          e = maybeImg;
-        }
-        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
-           * Also check _extendedAttrs directly for cells where text cleared HAS_EXTENDED.
-           */
-          while (++col < cols) {
-            const nextE = line._extendedAttrs[col] as IExtendedAttrsImage | undefined;
-            if (!nextE || nextE.imageId !== imageId || nextE.tileId !== startTile + count) {
-              break;
+          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++;
            }
-            count++;
-          }
-          col--;
-          if (imgSpec) {
-            if (imgSpec.actual) {
-              drawCalls.push({ imgSpec, tileId: startTile, col: startCol, row, 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);
            }
-          } else if (this._opts.showPlaceholder) {
-            placeholderCalls.push({ col: startCol, row, count });
+            this._fullyCleared = false;
          }
-          this._fullyCleared = false;
        }
      }
    }
-
-    // Sort by z-index so lower z draws first (higher z renders on top)
-    drawCalls.sort((a, b) => a.imgSpec.zIndex - b.imgSpec.zIndex);
-
-    // Draw placeholders first (lowest priority)
-    for (const call of placeholderCalls) {
-      this._renderer.drawPlaceholder(call.col, call.row, call.count);
-    }
-
-    // Draw images in z-index order
-    for (const call of drawCalls) {
-      this._renderer.draw(call.imgSpec, call.tileId, call.col, call.row, call.count);
-    }
  }

  public viewportResize(metrics: { cols: number, rows: number }): void {
@@ -515,7 +442,7 @@ export class ImageStorage implements IDisposable {
    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 e: IExtendedAttrsImage = line._extendedAttrs[oldCol] || EMPTY_ATTRS;
        const imageId = e.imageId;
        if (imageId === undefined || imageId === -1) {
          continue;
@@ -560,7 +487,7 @@ export class ImageStorage implements IDisposable {
    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;
+      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) {
@@ -580,7 +507,7 @@ export class ImageStorage implements IDisposable {
    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;
+      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) {
@@ -3,7 +3,7 @@
 * @license MIT
 */

-import { SixelImageStorage } from './SixelImageStorage';
+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';
@@ -26,7 +26,7 @@ export class SixelHandler implements IDcsHandler, IResetHandler {

  constructor(
    private readonly _opts: IImageAddonOptions,
-    private readonly _storage: SixelImageStorage,
+    private readonly _storage: ImageStorage,
    private readonly _coreTerminal: ITerminalExt
  ) {
    DecoderAsync({
@@ -91,7 +91,7 @@ export class SixelHandler implements IDcsHandler, IResetHandler {
    const height = this._dec.height;

    // partial fix for https://github.com/jerch/xterm-addon-image/issues/37
-    if (!width || !height) {
+    if (!width || ! height) {
      if (height) {
        this._storage.advanceCursor(height);
      }
@@ -99,7 +99,7 @@ export class SixelHandler implements IDcsHandler, IResetHandler {
    }

    const canvas = ImageRenderer.createCanvas(undefined, width, height);
-    canvas.getContext('2d')?.putImageData(new ImageData(this._dec.data8 as Uint8ClampedArray<ArrayBuffer>, width, height), 0, 0);
+    canvas.getContext('2d')?.putImageData(new ImageData(this._dec.data8, width, height), 0, 0);
    if (this._dec.memoryUsage > MEM_PERMA_LIMIT) {
      this._dec.release();
    }
@@ -1,52 +0,0 @@
-/**
- * Copyright (c) 2020 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { ImageStorage, CELL_SIZE_DEFAULT } from './ImageStorage';
-import { IImageAddonOptions, ITerminalExt, IAddImageOpts } from './Types';
-import { ImageRenderer } from './ImageRenderer';
-
-/**
- * Sixel-specific image storage controller.
- *
- * Wraps the shared ImageStorage with sixel protocol semantics:
- * - Cursor behavior governed by DECSET 80 (sixelScrolling option)
- * - advanceCursor for empty sixels carrying only height
- */
-export class SixelImageStorage {
-  private _addImageOpts: IAddImageOpts = { scrolling: true, layer: 'top', zIndex: 0, cursorPos: 'vt340' };
-  constructor(
-    private readonly _storage: ImageStorage,
-    private readonly _opts: IImageAddonOptions,
-    private readonly _renderer: ImageRenderer,
-    private readonly _terminal: ITerminalExt
-  ) {}
-
-  /**
-   * Add a sixel image to storage.
-   * Cursor behavior depends on the sixelScrolling option (DECSET 80).
-   */
-  public addImage(img: HTMLCanvasElement | ImageBitmap): void {
-    this._addImageOpts.scrolling = this._opts.sixelScrolling;
-    this._storage.addImage(img, this._addImageOpts);
-  }
-
-  /**
-   * 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();
-      }
-    }
-  }
-}
@@ -8,11 +8,11 @@ import { IDisposable, IMarker, Terminal } from '@xterm/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, IApcHandler, IEscapeSequenceParser } from 'common/parser/Types';
+import type { IParams, IDcsHandler, IOscHandler, IEscapeSequenceParser } from 'common/parser/Types';
 import type { IBufferLine, IExtendedAttrs, IInputHandler } from 'common/Types';
-import type { ITerminal, ReadonlyColorSet } from 'target-browser/Types';
-import type { IRenderDimensions } from 'target-browser/renderer/shared/Types';
-import type { ICoreBrowserService, IRenderService, IThemeService } from 'target-browser/services/Services';
+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)
@@ -22,7 +22,7 @@ export const enum Cell {
 }

 // export some privates for local usage
-export { AttributeData, IParams, IDcsHandler, IOscHandler, IApcHandler, BgFlags, IRenderDimensions, IRenderService, Content, ExtFlags, Attributes, UnderlineStyle, ReadonlyColorSet };
+export { AttributeData, IParams, IDcsHandler, IOscHandler, BgFlags, IRenderDimensions, IRenderService, Content, ExtFlags, Attributes, UnderlineStyle, ReadonlyColorSet };

 /**
 * Plugin ctor options.
@@ -38,8 +38,6 @@ export interface IImageAddonOptions {
  sixelSizeLimit: number;
  iipSupport: boolean;
  iipSizeLimit: number;
-  kittySupport: boolean;
-  kittySizeLimit: number;
 }

 export interface IResetHandler {
@@ -99,16 +97,6 @@ export interface ICellSize {
  height: number;
 }

-export type ImageLayer = 'top' | 'bottom';
-export type CursorPos = 'vt340' | 'iip';
-
-export interface IAddImageOpts {
-  scrolling: boolean;
-  layer: ImageLayer;
-  zIndex: number;
-  cursorPos: CursorPos;
-}
-
 export interface IImageSpec {
  orig: HTMLCanvasElement | ImageBitmap | undefined;
  origCellSize: ICellSize;
@@ -117,6 +105,4 @@ export interface IImageSpec {
  marker: IMarker | undefined;
  tileCount: number;
  bufferType: 'alternate' | 'normal';
-  layer: ImageLayer;
-  zIndex: number;
 }
@@ -1,819 +0,0 @@
-/**
- * Copyright (c) 2026 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { IDisposable } from '@xterm/xterm';
-import { IApcHandler, IImageAddonOptions, IResetHandler, ITerminalExt, ImageLayer } from '../Types';
-import { ImageRenderer } from '../ImageRenderer';
-import { CELL_SIZE_DEFAULT } from '../ImageStorage';
-import { KittyImageStorage } from './KittyImageStorage';
-import Base64Decoder, { type DecodeStatus } from 'xterm-wasm-parts/lib/base64/Base64Decoder.wasm';
-import {
-  KittyAction,
-  KittyFormat,
-  KittyCompression,
-  IKittyCommand,
-  IPendingTransmission,
-  IKittyImageData,
-  KittyPixelConstants,
-  parseKittyCommand
-} from './KittyGraphicsTypes';
-
-const enum Constants {
-  // Memory limit for base64 decoder (4MB, same as IIPHandler)
-  DECODER_KEEP_DATA = 4194304,
-  DECODER_INITIAL_DATA = 4194304, // 4MB
-  // Local mirror of const enum (esbuild can't inline const enums from external packages)
-  DECODER_OK = 0,
-  // Maximum control data size
-  MAX_CONTROL_DATA_SIZE = 512,
-  // Semicolon codepoint
-  SEMICOLON = 0x3B
-}
-
-const DECODER_OK = Constants.DECODER_OK as unknown as DecodeStatus.OK;
-
-// Kitty graphics protocol handler with streaming base64 decoding.
-export class KittyGraphicsHandler implements IApcHandler, IResetHandler, IDisposable {
-  private _aborted = false;
-  private _decodeError = false;
-
-  private _activeDecoder: Base64Decoder | null = null;
-  private readonly _maxEncodedBytes: number;
-  private readonly _initialEncodedBytes: number;
-
-  // Streaming related states
-
-  // True while receiving control data (before semicolon).
-  private _inControlData = true;
-
-  // Buffer for control data.
-  private _controlData = new Uint32Array(Constants.MAX_CONTROL_DATA_SIZE);
-  private _controlLength = 0;
-
-  // Pre-calculated encoded size limit
-  private _encodedSizeLimit = 0;
-  private _totalEncodedSize = 0;
-
-  // Parsed command. These are the control data before semicolon.
-  private _parsedCommand: IKittyCommand | null = null;
-
-  // Storage related states
-
-  private _pendingTransmissions: Map<number, IPendingTransmission> = new Map();
-  // Tracks the pending key of the most recently started chunked upload.
-  // Per spec, subsequent chunks only need m= (and optionally q=), without i=.
-  // When a chunk arrives with no i=, this key is used to find the pending upload.
-  private _lastPendingKey: number | undefined;
-
-  constructor(
-    private readonly _opts: IImageAddonOptions,
-    private readonly _renderer: ImageRenderer,
-    private readonly _kittyStorage: KittyImageStorage,
-    private readonly _coreTerminal: ITerminalExt
-  ) {
-    // Convert decoded size limit -> max encoded bytes.
-    this._maxEncodedBytes = Math.ceil(this._opts.kittySizeLimit * 4 / 3);
-    // ensure we preallocate more than configured limit while using 4mb initial size.
-    this._initialEncodedBytes = Math.min(Constants.DECODER_INITIAL_DATA, this._maxEncodedBytes);
-  }
-
-  public reset(): void {
-    this._cleanupAllPending();
-    if (this._activeDecoder) {
-      this._activeDecoder.release();
-      this._activeDecoder = null;
-    }
-    this._kittyStorage.reset();
-  }
-
-  public dispose(): void {
-    this.reset();
-  }
-
-  private _removePendingEntry(key: number): void {
-    this._pendingTransmissions.delete(key);
-    if (this._lastPendingKey === key) {
-      this._lastPendingKey = undefined;
-    }
-  }
-
-  private _cleanupAllPending(): void {
-    for (const pending of this._pendingTransmissions.values()) {
-      pending.decoder.release();
-    }
-    this._pendingTransmissions.clear();
-    this._lastPendingKey = undefined;
-  }
-
-  public start(): void {
-    this._aborted = false;
-    this._decodeError = false;
-    this._inControlData = true;
-    this._controlLength = 0;
-    this._parsedCommand = null;
-    // Pre-calculate encoded limit once: base64 is 4 bytes encoded → 3 bytes decoded
-    this._encodedSizeLimit = this._maxEncodedBytes;
-    this._totalEncodedSize = 0;
-    this._activeDecoder = null;
-  }
-
-  public put(data: Uint32Array, start: number, end: number): void {
-    if (this._aborted) return;
-
-    if (!this._inControlData) {
-      this._streamPayload(data, start, end);
-    } else {
-      // Scan for semicolon
-      let controlEnd = end;
-      for (let i = start; i < end; i++) {
-        if (data[i] === Constants.SEMICOLON) {
-          this._inControlData = false;
-          controlEnd = i;
-          break;
-        }
-      }
-
-      // Copy control data
-      const copyLength = controlEnd - start;
-      if (this._controlLength + copyLength > Constants.MAX_CONTROL_DATA_SIZE) {
-        this._aborted = true;
-        return;
-      }
-      this._controlData.set(data.subarray(start, controlEnd), this._controlLength);
-      this._controlLength += copyLength;
-
-      if (!this._inControlData) {
-        // Found semicolon - parse control data early for validation
-        this._parsedCommand = parseKittyCommand(this._parseControlDataString());
-
-        // Early validation: i+I conflict
-        if (this._parsedCommand.id !== undefined && this._parsedCommand.imageNumber !== undefined) {
-          this._sendResponse(this._parsedCommand.id, 'EINVAL:cannot specify both i and I keys', this._parsedCommand.quiet ?? 0);
-          this._aborted = true;
-          return;
-        }
-
-        // Delete action doesn't need payload - skip streaming
-        if (this._parsedCommand.action === KittyAction.DELETE) {
-          return;
-        }
-
-        // Stream remaining as payload
-        const payloadStart = controlEnd + 1;
-        if (payloadStart < end) {
-          this._streamPayload(data, payloadStart, end);
-        }
-      }
-    }
-  }
-
-  // Stream payload bytes into the base64 decoder.
-  private _streamPayload(data: Uint32Array, start: number, end: number): void {
-    if (this._aborted) return;
-
-    // Check size limit (compare encoded bytes against pre-calculated limit)
-    // Include cumulative size from pending transmission for multi-chunk images.
-    // Per spec, subsequent chunks may omit i=, so fall back to _lastPendingKey.
-    const pendingKey = this._parsedCommand?.id ?? this._lastPendingKey ?? 0;
-    const pending = this._pendingTransmissions.get(pendingKey);
-    const previousEncodedSize = pending?.totalEncodedSize ?? 0;
-    this._totalEncodedSize += end - start;
-    const cumulativeEncodedSize = previousEncodedSize + this._totalEncodedSize;
-    if (cumulativeEncodedSize > this._encodedSizeLimit) {
-      const decoderToRelease = this._activeDecoder ?? pending?.decoder;
-      if (decoderToRelease) {
-        decoderToRelease.release();
-      }
-      this._activeDecoder = null;
-      if (pending) {
-        this._removePendingEntry(pendingKey);
-      }
-      this._aborted = true;
-      return;
-    }
-
-    if (this._decodeError) return;
-
-    if (pending?.decoder && !this._activeDecoder) {
-      this._activeDecoder = pending.decoder;
-    }
-    if (!this._activeDecoder) {
-      this._activeDecoder = new Base64Decoder(Constants.DECODER_KEEP_DATA, this._maxEncodedBytes, this._initialEncodedBytes);
-      this._activeDecoder.init();
-    }
-
-    if (this._activeDecoder.put(data.subarray(start, end)) !== DECODER_OK) {
-      this._activeDecoder.release();
-      this._activeDecoder = null;
-      this._decodeError = true;
-      if (pending) {
-        this._removePendingEntry(pendingKey);
-      }
-    }
-  }
-
-  public end(success: boolean): boolean | Promise<boolean> {
-    if (this._aborted || !success) {
-      if (this._activeDecoder) {
-        this._activeDecoder.release();
-        this._activeDecoder = null;
-      }
-      return true;
-    }
-
-    // No semicolon = no payload (delete, capability query)
-    if (this._inControlData) {
-      return this._handleNoPayloadCommand();
-    }
-
-    // Use command parsed early in put() - i+I already validated there
-    const cmd = this._parsedCommand!;
-
-    // Delete action was handled by skipping payload - just execute
-    if (cmd.action === KittyAction.DELETE) {
-      return this._handleDelete(cmd);
-    }
-
-    // Per spec, subsequent chunks may omit i=, so fall back to _lastPendingKey.
-    const pendingKey = cmd.id ?? this._lastPendingKey ?? 0;
-    const isMoreComing = cmd.more === 1;
-    const pending = this._pendingTransmissions.get(pendingKey);
-
-    if (isMoreComing) {
-      if (this._activeDecoder) {
-        if (pending) {
-          pending.totalEncodedSize += this._totalEncodedSize;
-          pending.decodeError = pending.decodeError || this._decodeError;
-        } else {
-          this._pendingTransmissions.set(pendingKey, {
-            cmd: { ...cmd },
-            decoder: this._activeDecoder,
-            totalEncodedSize: this._totalEncodedSize,
-            decodeError: this._decodeError
-          });
-        }
-        this._lastPendingKey = pendingKey;
-        this._activeDecoder = null;
-      }
-      return true;
-    }
-
-    // Final chunk received — clear the last pending key
-    if (pending) {
-      this._lastPendingKey = undefined;
-    }
-
-    let decodeError = this._decodeError;
-    let finalCmd = cmd;
-    let decoder = this._activeDecoder;
-
-    if (pending) {
-      finalCmd = pending.cmd;
-      decoder = pending.decoder;
-      decodeError = decodeError || pending.decodeError;
-      this._pendingTransmissions.delete(pendingKey);
-    }
-
-    let imageBytes = new Uint8Array(0);
-    if (decoder) {
-      if (decoder.end() !== DECODER_OK) {
-        decodeError = true;
-      }
-      imageBytes = decoder.data8;
-    }
-    this._activeDecoder = null;
-
-    // Handle command first — handlers create Blob/ImageData from imageBytes,
-    // which copies the data. Only then is it safe to release the decoder's
-    // wasm memory that imageBytes points into.
-    const result = this._handleCommandWithBytesAndCmd(finalCmd, imageBytes, decodeError);
-    if (decoder) {
-      decoder.release();
-    }
-    return result;
-  }
-
-  // Command handling
-
-  private _parseControlDataString(): string {
-    let str = '';
-    for (let i = 0; i < this._controlLength; i++) {
-      str += String.fromCodePoint(this._controlData[i]);
-    }
-    return str;
-  }
-
-  private _handleNoPayloadCommand(): boolean | Promise<boolean> {
-    const cmd = parseKittyCommand(this._parseControlDataString());
-
-    // Per spec: specifying both i and I is an error
-    if (cmd.id !== undefined && cmd.imageNumber !== undefined) {
-      this._sendResponse(cmd.id, 'EINVAL:cannot specify both i and I keys', cmd.quiet ?? 0);
-      return true;
-    }
-
-    const action = cmd.action ?? 't';
-
-    switch (action) {
-      case KittyAction.DELETE:
-        return this._handleDelete(cmd);
-      case KittyAction.QUERY:
-        this._sendResponse(cmd.id ?? 0, 'OK', cmd.quiet ?? 0);
-        return true;
-      case KittyAction.PLACEMENT:
-        return this._handlePlacement(cmd);
-      default:
-        // TODO: Implement remaining actions when needed:
-        // - a=f (frame): animation frame operations
-        // - a=a (animation): animation control
-        // - a=c (compose): compose images
-        if (cmd.id !== undefined) {
-          this._sendResponse(cmd.id, 'EINVAL:unsupported action', cmd.quiet ?? 0);
-        }
-        return true;
-    }
-  }
-
-  private _handleCommandWithBytesAndCmd(cmd: IKittyCommand, bytes: Uint8Array, decodeError: boolean): boolean | Promise<boolean> {
-    const action = cmd.action ?? 't';
-
-    switch (action) {
-      case KittyAction.TRANSMIT: {
-        const result = this._handleTransmit(cmd, bytes, decodeError);
-        // Only send response when _handleTransmit didn't already respond
-        // (it handles unsupported transmission medium responses internally)
-        if ((cmd.transmission ?? 'd') === 'd' && cmd.id !== undefined) {
-          if (decodeError) {
-            this._sendResponse(cmd.id, 'EINVAL:invalid base64 data', cmd.quiet ?? 0);
-          } else if (bytes.length > 0) {
-            this._sendResponse(cmd.id, 'OK', cmd.quiet ?? 0);
-          }
-        }
-        return result;
-      }
-      case KittyAction.TRANSMIT_DISPLAY:
-        return this._handleTransmitDisplay(cmd, bytes, decodeError);
-      case KittyAction.QUERY:
-        return this._handleQuery(cmd, bytes, decodeError);
-      case KittyAction.PLACEMENT:
-        // a=p ignores any payload — image data was already transmitted
-        return this._handlePlacement(cmd);
-      default:
-        // TODO: Implement remaining actions when needed:
-        // - a=f (frame): animation frame operations
-        // - a=a (animation): animation control
-        // - a=c (compose): compose images
-        if (cmd.id !== undefined) {
-          this._sendResponse(cmd.id, 'EINVAL:unsupported action', cmd.quiet ?? 0);
-        }
-        return true;
-    }
-  }
-
-  private _handlePlacement(cmd: IKittyCommand): boolean | Promise<boolean> {
-    if (cmd.id === undefined) {
-      return true;
-    }
-    const id = cmd.id;
-    const image = this._kittyStorage.getImage(id);
-    if (!image) {
-      this._sendResponse(id, 'ENOENT:image not found', cmd.quiet ?? 0, cmd.placementId);
-      return true;
-    }
-    const result = this._displayImage(image, cmd);
-    return result.then(success => {
-      this._sendResponse(id, success ? 'OK' : 'EINVAL:image rendering failed', cmd.quiet ?? 0, cmd.placementId);
-      return true;
-    });
-  }
-
-  private _handleTransmit(cmd: IKittyCommand, bytes: Uint8Array, decodeError: boolean): boolean {
-    // TODO: Support file-based transmission modes (t=f, t=t, t=s)
-    // Currently only supports direct transmission (t=d, the default).
-    // - t=f (file): Payload is base64-encoded file path. Terminal reads image from that path.
-    // - t=t (temp file): Payload is base64-encoded path in temp directory. Terminal reads, deletes.
-    // - t=s: Payload is base64-encoded POSIX shm name. Terminal reads from shared memory.
-    // These modes require filesystem/IPC access not available in browsers. For Node.js/Electron:
-    // 1. Check cmd.transmission (t key) before treating bytes as image data
-    // 2. For t=f/t/s: decode bytes as UTF-8 string (the path/name), then read file contents
-    // 3. For t=d: treat bytes as image data (current behavior)
-    // When implementing, also update _handleQuery to accept these transmission mediums.
-    const transmission = cmd.transmission ?? 'd';
-    if (transmission !== 'd') {
-      if (cmd.id !== undefined) {
-        this._sendResponse(cmd.id, 'EINVAL:unsupported transmission medium', cmd.quiet ?? 0);
-      }
-      return true;
-    }
-
-    if (decodeError || bytes.length === 0) return true;
-
-    this._kittyStorage.storeImage(cmd.id, {
-      data: new Blob([bytes as BlobPart]),
-      width: cmd.width ?? 0,
-      height: cmd.height ?? 0,
-      format: (cmd.format ?? KittyFormat.RGBA) as 24 | 32 | 100,
-      compression: cmd.compression ?? ''
-    });
-    return true;
-  }
-
-  private _handleTransmitDisplay(cmd: IKittyCommand, bytes: Uint8Array, decodeError: boolean): boolean | Promise<boolean> {
-    if (decodeError) {
-      if (cmd.id !== undefined) {
-        this._sendResponse(cmd.id, 'EINVAL:invalid base64 data', cmd.quiet ?? 0);
-      }
-      return true;
-    }
-
-    this._handleTransmit(cmd, bytes, decodeError);
-
-    const id = cmd.id ?? this._kittyStorage.lastImageId;
-    const image = this._kittyStorage.getImage(id);
-    if (image) {
-      const result = this._displayImage(image, cmd);
-      if (cmd.id !== undefined) {
-        return result.then(success => {
-          this._sendResponse(id, success ? 'OK' : 'EINVAL:image rendering failed', cmd.quiet ?? 0);
-          return true;
-        });
-      }
-      return result.then(() => true);
-    }
-    return true;
-  }
-
-  private _handleQuery(cmd: IKittyCommand, bytes: Uint8Array, decodeError: boolean): boolean {
-    const id = cmd.id ?? 0;
-    const quiet = cmd.quiet ?? 0;
-
-    // Per spec: reject unsupported transmission mediums (only t=d is supported atm)
-    // TODO: When filesystem support is added (Node.js/Electron), update this to accept
-    // t=f (file), t=t (temp file), and t=s (shared memory) and respond OK for queries.
-    const transmission = cmd.transmission ?? 'd';
-    if (transmission !== 'd') {
-      this._sendResponse(id, 'EINVAL:unsupported transmission medium', quiet);
-      return true;
-    }
-
-    // Check decode error first (invalid base64)
-    if (decodeError) {
-      this._sendResponse(id, 'EINVAL:invalid base64 data', quiet);
-      return true;
-    }
-
-    // Capability query (no payload) - just respond OK
-    if (bytes.length === 0) {
-      this._sendResponse(id, 'OK', quiet);
-      return true;
-    }
-
-    const format = cmd.format ?? KittyFormat.RGBA;
-
-    if (format === KittyFormat.PNG) {
-      this._sendResponse(id, 'OK', quiet);
-    } else {
-      const width = cmd.width ?? 0;
-      const height = cmd.height ?? 0;
-
-      if (!width || !height) {
-        this._sendResponse(id, 'EINVAL:width and height required for raw pixel data', quiet);
-        return true;
-      }
-
-      const bytesPerPixel = format === KittyFormat.RGBA ? KittyPixelConstants.BYTES_PER_PIXEL_RGBA : KittyPixelConstants.BYTES_PER_PIXEL_RGB;
-      const expectedBytes = width * height * bytesPerPixel;
-
-      if (bytes.length < expectedBytes) {
-        this._sendResponse(id, `EINVAL:insufficient pixel data`, quiet);
-        return true;
-      }
-
-      this._sendResponse(id, 'OK', quiet);
-    }
-    return true;
-  }
-
-  private _handleDelete(cmd: IKittyCommand): boolean {
-    // Per spec: default delete selector is 'a' (delete all visible placements)
-    const selector = cmd.deleteSelector ?? 'a';
-
-    // TODO: Distinguish lowercase (delete placements only) from uppercase
-    // (delete placements + free stored image data). Currently both variants
-    // free everything since we don't separate stored data from placements.
-    switch (selector) {
-      case 'a':
-      case 'A':
-        this._cleanupAllPending();
-        this._kittyStorage.deleteAll();
-        break;
-      case 'i':
-      case 'I':
-        // TODO: When placement id tracking is implemented (see TODO in
-        // KittyImageStorage), d=i with p=<pid> should delete only that
-        // specific placement, while d=i without p should delete all
-        // placements for the image.
-        if (cmd.id !== undefined) {
-          const pending = this._pendingTransmissions.get(cmd.id);
-          if (pending) {
-            pending.decoder.release();
-          }
-          this._removePendingEntry(cmd.id);
-          this._kittyStorage.deleteById(cmd.id);
-        }
-        break;
-      default:
-        // Unsupported selectors (c, n, p, q, r, x, y, z, f) — ignore for now
-        break;
-    }
-    return true;
-  }
-
-  private _sendResponse(id: number, message: string, quiet: number, placementId?: number): void {
-    const isOk = message === 'OK';
-    if (isOk && quiet >= 1) return;
-    if (!isOk && quiet >= 2) return;
-
-    const pPart = placementId ? `,p=${placementId}` : '';
-    const response = `\x1b_Gi=${id}${pPart};${message}\x1b\\`;
-    this._coreTerminal._core.coreService.triggerDataEvent(response);
-  }
-
-  // Image display
-
-  private _displayImage(image: IKittyImageData, cmd: IKittyCommand): Promise<boolean> {
-    return this._decodeAndDisplay(image, cmd)
-      .then(() => true)
-      .catch(() => false);
-  }
-
-  private async _decodeAndDisplay(image: IKittyImageData, cmd: IKittyCommand): Promise<void> {
-    let bitmap: ImageBitmap | undefined = await this._createBitmap(image);
-
-    try {
-      const cropX = Math.max(0, cmd.x ?? 0);
-      const cropY = Math.max(0, cmd.y ?? 0);
-      const cropW = cmd.sourceWidth || (bitmap.width - cropX);
-      const cropH = cmd.sourceHeight || (bitmap.height - cropY);
-
-      const maxCropW = Math.max(0, bitmap.width - cropX);
-      const maxCropH = Math.max(0, bitmap.height - cropY);
-      const finalCropW = Math.max(0, Math.min(cropW, maxCropW));
-      const finalCropH = Math.max(0, Math.min(cropH, maxCropH));
-
-      if (finalCropW === 0 || finalCropH === 0) {
-        throw new Error('invalid source rectangle');
-      }
-
-      if (cropX !== 0 || cropY !== 0 || finalCropW !== bitmap.width || finalCropH !== bitmap.height) {
-        const cropped = await createImageBitmap(bitmap, cropX, cropY, finalCropW, finalCropH);
-        bitmap.close();
-        bitmap = cropped;
-      }
-
-      const cw = this._renderer.dimensions?.css.cell.width || CELL_SIZE_DEFAULT.width;
-      const ch = this._renderer.dimensions?.css.cell.height || CELL_SIZE_DEFAULT.height;
-
-      // Per spec: c/r default to image's natural cell dimensions.
-      // If only one of c/r is specified, compute the other from image aspect ratio.
-      let imgCols: number;
-      let imgRows: number;
-      if (cmd.columns !== undefined && cmd.rows !== undefined) {
-        imgCols = cmd.columns;
-        imgRows = cmd.rows;
-      } else if (cmd.columns !== undefined) {
-        imgCols = cmd.columns;
-        imgRows = Math.max(1, Math.ceil((bitmap.height / bitmap.width) * (imgCols * cw) / ch));
-      } else if (cmd.rows !== undefined) {
-        imgRows = cmd.rows;
-        imgCols = Math.max(1, Math.ceil((bitmap.width / bitmap.height) * (imgRows * ch) / cw));
-      } else {
-        imgCols = Math.ceil(bitmap.width / cw);
-        imgRows = Math.ceil(bitmap.height / ch);
-      }
-
-      let w = bitmap.width;
-      let h = bitmap.height;
-
-      // Scale bitmap to fit placement rectangle when c/r are specified
-      if (cmd.columns !== undefined || cmd.rows !== undefined) {
-        w = Math.round(imgCols * cw);
-        h = Math.round(imgRows * ch);
-      }
-
-      if (w * h > this._opts.pixelLimit) {
-        throw new Error('image exceeds pixel limit');
-      }
-
-      // Save cursor position before addImage modifies it
-      const buffer = this._coreTerminal._core.buffer;
-      const savedX = buffer.x;
-      const savedY = buffer.y;
-      const savedYbase = buffer.ybase;
-
-      // Determine layer based on z-index: negative = behind text, 0+ = on top.
-      // When z<0 we always use the bottom layer even without allowTransparency —
-      // the image will simply be hidden behind the opaque text background, which
-      // is the correct behavior (client asked for "behind text").
-      const wantsBottom = cmd.zIndex !== undefined && cmd.zIndex < 0;
-      const layer: ImageLayer = wantsBottom ? 'bottom' : 'top';
-
-      if (w !== bitmap.width || h !== bitmap.height) {
-        const scaled = await createImageBitmap(bitmap, { resizeWidth: w, resizeHeight: h });
-        bitmap.close();
-        bitmap = scaled;
-      }
-
-      // Per spec: X/Y are pixel offsets within the first cell, so clamp to cell dimensions
-      const xOffset = Math.min(Math.max(0, cmd.xOffset ?? 0), cw - 1);
-      const yOffset = Math.min(Math.max(0, cmd.yOffset ?? 0), ch - 1);
-      if (xOffset !== 0 || yOffset !== 0) {
-        // Per spec: X/Y is not added to c/r area. When c/r are explicit, the
-        // total placement area remains c*cw × r*ch pixels and the offset image
-        // is clipped to fit. When c/r are unset, the padded canvas determines
-        // the natural cell dimensions.
-        const canvasW = (cmd.columns !== undefined) ? Math.round(imgCols * cw) : bitmap.width + xOffset;
-        const canvasH = (cmd.rows !== undefined) ? Math.round(imgRows * ch) : bitmap.height + yOffset;
-        const offsetCanvas = ImageRenderer.createCanvas(window.document, canvasW, canvasH);
-        const offsetCtx = offsetCanvas.getContext('2d');
-        if (!offsetCtx) {
-          throw new Error('Failed to create offset canvas context');
-        }
-        offsetCtx.drawImage(bitmap, xOffset, yOffset);
-
-        const offsetBitmap = await createImageBitmap(offsetCanvas);
-        offsetCanvas.width = offsetCanvas.height = 0;
-        bitmap.close();
-        bitmap = offsetBitmap;
-        w = bitmap.width;
-        h = bitmap.height;
-        if (w * h > this._opts.pixelLimit) {
-          throw new Error('image exceeds pixel limit');
-        }
-        if (cmd.columns === undefined) {
-          imgCols = Math.ceil(bitmap.width / cw);
-        }
-        if (cmd.rows === undefined) {
-          imgRows = Math.ceil(bitmap.height / ch);
-        }
-      }
-
-      const zIndex = cmd.zIndex ?? 0;
-      this._kittyStorage.addImage(image.id, bitmap, true, layer, zIndex);
-      bitmap = undefined;  // ownership transferred to storage
-
-      // Kitty cursor movement
-      // Per spec: cursor placed at first column after last image column,
-      // on the last row of the image. C=1 means don't move cursor.
-      if (cmd.cursorMovement === 1) {
-        // C=1: restore cursor to position before image was placed
-        const scrolled = buffer.ybase - savedYbase;
-        buffer.x = savedX;
-        // Can't restore cursor to scrollback?
-        buffer.y = Math.max(savedY - scrolled, 0);
-      } else {
-        // Default (C=0): advance cursor horizontally past the image
-        // addImage already positioned cursor on the last row via lineFeeds
-        buffer.x = Math.min(savedX + imgCols, this._coreTerminal.cols);
-      }
-    } catch (e) {
-      bitmap?.close();
-      throw e;
-    }
-  }
-
-  // Create ImageBitmap from already-decoded image data.
-  private async _createBitmap(image: IKittyImageData): Promise<ImageBitmap> {
-    let bytes: Uint8Array = new Uint8Array(await image.data.arrayBuffer());
-
-    if (image.compression === KittyCompression.ZLIB) {
-      bytes = await this._decompressZlib(bytes);
-    }
-
-    if (image.format === KittyFormat.PNG) {
-      const blob = new Blob([bytes as BlobPart], { type: 'image/png' });
-      if (!window.createImageBitmap) {
-        const url = URL.createObjectURL(blob);
-        const img = new Image();
-        return new Promise<ImageBitmap>((resolve, reject) => {
-          img.addEventListener('load', () => {
-            URL.revokeObjectURL(url);
-            const canvas = ImageRenderer.createCanvas(window.document, img.width, img.height);
-            canvas.getContext('2d')?.drawImage(img, 0, 0);
-            createImageBitmap(canvas).then(resolve).catch(reject);
-          });
-          img.addEventListener('error', () => {
-            URL.revokeObjectURL(url);
-            reject(new Error('Failed to load image'));
-          });
-          img.src = url;
-        });
-      }
-      return createImageBitmap(blob);
-    }
-
-    // Raw pixel data
-    const width = image.width;
-    const height = image.height;
-
-    if (!width || !height) {
-      throw new Error('Width and height required for raw pixel data');
-    }
-
-    const bytesPerPixel = image.format === KittyFormat.RGBA ? KittyPixelConstants.BYTES_PER_PIXEL_RGBA : KittyPixelConstants.BYTES_PER_PIXEL_RGB;
-    const expectedBytes = width * height * bytesPerPixel;
-
-    if (bytes.length < expectedBytes) {
-      throw new Error('Insufficient pixel data');
-    }
-
-    const pixelCount = width * height;
-
-    if (image.format === KittyFormat.RGBA) {
-      // RGBA: use bytes directly — no copy needed
-      return createImageBitmap(new ImageData(new Uint8ClampedArray(bytes.buffer as ArrayBuffer, bytes.byteOffset, pixelCount * KittyPixelConstants.BYTES_PER_PIXEL_RGBA), width, height));
-    }
-
-    // RGB→RGBA: interleave alpha using uint32 block processing (4 pixels per iteration).
-    // 3 uint32 reads + 4 uint32 writes per 4 pixels vs 28 byte reads/writes — ~6x faster.
-    // Assumes little-endian (all modern browsers/Node.js).
-    const data = new Uint8ClampedArray(pixelCount * KittyPixelConstants.BYTES_PER_PIXEL_RGBA);
-    const src32 = new Uint32Array(bytes.buffer, bytes.byteOffset, Math.floor(bytes.byteLength / 4));
-    const dst32 = new Uint32Array(data.buffer);
-    const alignedPixels = pixelCount & ~3;  // round down to multiple of 4
-
-    let srcOffset = 0;
-    let dstOffset = 0;
-    for (let i = 0; i < alignedPixels; i += 4) {
-      const b0 = src32[srcOffset++];
-      const b1 = src32[srcOffset++];
-      const b2 = src32[srcOffset++];
-      // Little-endian: pixel bytes are [R,G,B] → uint32 ABGR layout
-      dst32[dstOffset++] = 0xFF000000 | b0;
-      dst32[dstOffset++] = 0xFF000000 | (b0 >>> 24) | (b1 << 8);
-      dst32[dstOffset++] = 0xFF000000 | (b1 >>> 16) | (b2 << 16);
-      dst32[dstOffset++] = 0xFF000000 | (b2 >>> 8);
-    }
-
-    // Handle remaining 1–3 pixels
-    let srcByte = alignedPixels * KittyPixelConstants.BYTES_PER_PIXEL_RGB;
-    let dstByte = alignedPixels * KittyPixelConstants.BYTES_PER_PIXEL_RGBA;
-    for (let i = alignedPixels; i < pixelCount; i++) {
-      data[dstByte]     = bytes[srcByte];
-      data[dstByte + 1] = bytes[srcByte + 1];
-      data[dstByte + 2] = bytes[srcByte + 2];
-      data[dstByte + 3] = KittyPixelConstants.ALPHA_OPAQUE;
-      srcByte += KittyPixelConstants.BYTES_PER_PIXEL_RGB;
-      dstByte += KittyPixelConstants.BYTES_PER_PIXEL_RGBA;
-    }
-
-    return createImageBitmap(new ImageData(data, width, height));
-  }
-
-  private async _decompressZlib(compressed: Uint8Array): Promise<Uint8Array> {
-    try {
-      return await this._decompress(compressed, 'deflate');
-    } catch {
-      return await this._decompress(compressed, 'deflate-raw');
-    }
-  }
-
-  private async _decompress(compressed: Uint8Array, format: 'deflate' | 'deflate-raw'): Promise<Uint8Array> {
-    const ds = new DecompressionStream(format);
-    const writer = ds.writable.getWriter();
-    writer.write(compressed as BufferSource);
-    writer.close();
-
-    const chunks: Uint8Array[] = [];
-    const reader = ds.readable.getReader();
-
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      chunks.push(value);
-    }
-
-    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const chunk of chunks) {
-      result.set(chunk, offset);
-      offset += chunk.length;
-    }
-    return result;
-  }
-
-  public get images(): ReadonlyMap<number, IKittyImageData> {
-    return this._kittyStorage.images;
-  }
-
-  public get _kittyIdToStorageId(): ReadonlyMap<number, number> {
-    return this._kittyStorage.kittyIdToStorageId;
-  }
-
-  public get pendingTransmissions(): ReadonlyMap<number, IPendingTransmission> {
-    return this._pendingTransmissions;
-  }
-}
@@ -1,149 +0,0 @@
-/**
- * Copyright (c) 2026 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-import { assert } from 'chai';
-import { parseKittyCommand, KittyAction, KittyFormat } from './KittyGraphicsTypes';
-
-describe('KittyGraphicsTypes', () => {
-  describe('parseKittyCommand', () => {
-    it('should parse control data with action and format', () => {
-      const cmd = parseKittyCommand('a=T,f=100');
-      assert.strictEqual(cmd.action, 'T');
-      assert.strictEqual(cmd.format, 100);
-    });
-
-    it('should parse control data with all options', () => {
-      const cmd = parseKittyCommand('a=t,f=32,i=5,s=10,v=20,c=3,r=2,m=1,q=2');
-      assert.strictEqual(cmd.action, 't');
-      assert.strictEqual(cmd.format, 32);
-      assert.strictEqual(cmd.id, 5);
-      assert.strictEqual(cmd.width, 10);
-      assert.strictEqual(cmd.height, 20);
-      assert.strictEqual(cmd.columns, 3);
-      assert.strictEqual(cmd.rows, 2);
-      assert.strictEqual(cmd.more, 1);
-      assert.strictEqual(cmd.quiet, 2);
-    });
-
-    it('should handle empty control data', () => {
-      const cmd = parseKittyCommand('');
-      assert.strictEqual(cmd.action, undefined);
-      assert.strictEqual(cmd.format, undefined);
-    });
-
-    it('should parse transmit action', () => {
-      const cmd = parseKittyCommand('a=t,f=100');
-      assert.strictEqual(cmd.action, KittyAction.TRANSMIT);
-      assert.strictEqual(cmd.format, KittyFormat.PNG);
-    });
-
-    it('should parse delete action', () => {
-      const cmd = parseKittyCommand('a=d,i=5');
-      assert.strictEqual(cmd.action, KittyAction.DELETE);
-      assert.strictEqual(cmd.id, 5);
-    });
-
-    it('should parse empty action as empty string', () => {
-      const cmd = parseKittyCommand('a=,f=100');
-      assert.strictEqual(cmd.action, '');
-      assert.strictEqual(cmd.format, 100);
-    });
-
-    it('should leave action undefined when key is not present', () => {
-      const cmd = parseKittyCommand('f=100,i=5');
-      assert.strictEqual(cmd.action, undefined);
-      assert.strictEqual(cmd.format, 100);
-      assert.strictEqual(cmd.id, 5);
-    });
-
-    it('should parse compression key', () => {
-      const cmd = parseKittyCommand('a=t,f=32,o=z');
-      assert.strictEqual(cmd.action, 't');
-      assert.strictEqual(cmd.format, 32);
-      assert.strictEqual(cmd.compression, 'z');
-    });
-
-    it('should parse cursor movement key', () => {
-      const cmd = parseKittyCommand('a=T,f=100,C=1');
-      assert.strictEqual(cmd.cursorMovement, 1);
-    });
-
-    it('should parse cursor movement key C=0', () => {
-      const cmd = parseKittyCommand('a=T,f=100,C=0');
-      assert.strictEqual(cmd.cursorMovement, 0);
-    });
-
-    it('should parse x and y offset', () => {
-      const cmd = parseKittyCommand('a=T,x=10,y=20');
-      assert.strictEqual(cmd.x, 10);
-      assert.strictEqual(cmd.y, 20);
-    });
-
-    it('should handle keys without values', () => {
-      const cmd = parseKittyCommand('a=t,f=,i=5');
-      assert.strictEqual(cmd.action, 't');
-      assert.ok(isNaN(cmd.format!));
-      assert.strictEqual(cmd.id, 5);
-    });
-
-    it('should parse z-index key with positive value', () => {
-      const cmd = parseKittyCommand('a=T,f=100,z=10');
-      assert.strictEqual(cmd.zIndex, 10);
-    });
-
-    it('should parse z-index key with zero', () => {
-      const cmd = parseKittyCommand('a=T,f=100,z=0');
-      assert.strictEqual(cmd.zIndex, 0);
-    });
-
-    it('should parse z-index key with negative value', () => {
-      const cmd = parseKittyCommand('a=T,f=100,z=-1');
-      assert.strictEqual(cmd.zIndex, -1);
-    });
-
-    it('should leave zIndex undefined when not specified', () => {
-      const cmd = parseKittyCommand('a=T,f=100');
-      assert.strictEqual(cmd.zIndex, undefined);
-    });
-
-    it('should parse delete selector key', () => {
-      const cmd = parseKittyCommand('a=d,d=i,i=5');
-      assert.strictEqual(cmd.action, 'd');
-      assert.strictEqual(cmd.deleteSelector, 'i');
-      assert.strictEqual(cmd.id, 5);
-    });
-
-    it('should parse uppercase delete selector', () => {
-      const cmd = parseKittyCommand('a=d,d=A');
-      assert.strictEqual(cmd.deleteSelector, 'A');
-    });
-
-    it('should parse delete selector d=a (all)', () => {
-      const cmd = parseKittyCommand('a=d,d=a');
-      assert.strictEqual(cmd.deleteSelector, 'a');
-    });
-
-    it('should leave deleteSelector undefined when not specified', () => {
-      const cmd = parseKittyCommand('a=d,i=5');
-      assert.strictEqual(cmd.deleteSelector, undefined);
-    });
-
-    it('should parse placement id key', () => {
-      const cmd = parseKittyCommand('a=d,d=i,i=5,p=3');
-      assert.strictEqual(cmd.placementId, 3);
-      assert.strictEqual(cmd.deleteSelector, 'i');
-      assert.strictEqual(cmd.id, 5);
-    });
-
-    it('should leave placementId undefined when not specified', () => {
-      const cmd = parseKittyCommand('a=d,d=i,i=5');
-      assert.strictEqual(cmd.placementId, undefined);
-    });
-
-    it('should parse image number key', () => {
-      const cmd = parseKittyCommand('a=t,f=100,I=42');
-      assert.strictEqual(cmd.imageNumber, 42);
-    });
-  });
-});
@@ -1,195 +0,0 @@
-/**
- * Copyright (c) 2026 The xterm.js authors. All rights reserved.
- * @license MIT
- *
- * Kitty graphics protocol types, constants, and parsing utilities.
- */
-
-import type Base64Decoder from 'xterm-wasm-parts/lib/base64/Base64Decoder.wasm';
-
-// Kitty graphics protocol action types.
-// See: https://sw.kovidgoyal.net/kitty/graphics-protocol/#control-data-reference under key 'a'.
-export const enum KittyAction {
-  TRANSMIT = 't',
-  TRANSMIT_DISPLAY = 'T',
-  QUERY = 'q',
-  PLACEMENT = 'p',
-  DELETE = 'd'
-}
-
-// Kitty graphics protocol format types.
-// See: https://sw.kovidgoyal.net/kitty/graphics-protocol/#control-data-reference
-export const enum KittyFormat {
-  RGB = 24,
-  RGBA = 32,
-  PNG = 100
-}
-
-// Kitty graphics protocol compression types.
-// See: https://sw.kovidgoyal.net/kitty/graphics-protocol/#control-data-reference under key 'o'.
-export const enum KittyCompression {
-  NONE = '',
-  ZLIB = 'z'
-}
-
-// Kitty graphics protocol control data keys.
-// See: https://sw.kovidgoyal.net/kitty/graphics-protocol/#control-data-reference
-export const enum KittyKey {
-  // Action to perform (t=transmit, T=transmit+display, q=query, p=placement, d=delete)
-  ACTION = 'a',
-  // Image format (24=RGB, 32=RGBA, 100=PNG)
-  FORMAT = 'f',
-  // Image ID for referencing stored images
-  ID = 'i',
-  // Image number (alternative to ID, terminal assigns ID)
-  IMAGE_NUMBER = 'I',
-  // Source image width in pixels
-  WIDTH = 's',
-  // Source image height in pixels
-  HEIGHT = 'v',
-  // The left edge (in pixels) of the image area to display
-  X_OFFSET = 'x',
-  // The top edge (in pixels) of the image area to display
-  Y_OFFSET = 'y',
-  // Width (in pixels) of the source rectangle to display
-  SOURCE_WIDTH = 'w',
-  // Height (in pixels) of the source rectangle to display
-  SOURCE_HEIGHT = 'h',
-  // Horizontal offset (in pixels) within the first cell
-  X_PLACEMENT_OFFSET = 'X',
-  // Vertical offset (in pixels) within the first cell
-  Y_PLACEMENT_OFFSET = 'Y',
-  // Number of terminal columns to display the image over
-  COLUMNS = 'c',
-  // Number of terminal rows to display the image over
-  ROWS = 'r',
-  // More data flag (1=more chunks coming, 0=final chunk)
-  MORE = 'm',
-  // Compression type (z=zlib). This is essential for chunking larger images.
-  COMPRESSION = 'o',
-  // Quiet mode (1=suppress OK responses, 2=suppress error responses)
-  QUIET = 'q',
-  // Cursor movement policy (0=move cursor after image, 1=don't move cursor)
-  CURSOR_MOVEMENT = 'C',
-  // Z-index for image layering (negative = behind text, 0+ = on top)
-  Z_INDEX = 'z',
-  // Transmission medium (d=direct, f=file, t=temp file, s=shared memory)
-  TRANSMISSION = 't',
-  // Delete selector (a/A=all, i/I=by id, c/C=at cursor, etc.) — only used when a=d
-  DELETE_SELECTOR = 'd',
-  // Placement ID for targeting specific placements
-  PLACEMENT_ID = 'p'
-}
-
-// Pixel format constants
-export const enum KittyPixelConstants {
-  BYTES_PER_PIXEL_RGB = 3,
-  BYTES_PER_PIXEL_RGBA = 4,
-  ALPHA_OPAQUE = 255
-}
-
-// Parsed Kitty graphics command.
-export interface IKittyCommand {
-  action?: string;
-  format?: number;
-  id?: number;
-  imageNumber?: number;
-  width?: number;
-  height?: number;
-  x?: number;
-  y?: number;
-  sourceWidth?: number;
-  sourceHeight?: number;
-  xOffset?: number;
-  yOffset?: number;
-  columns?: number;
-  rows?: number;
-  more?: number;
-  quiet?: number;
-  cursorMovement?: number;
-  zIndex?: number;
-  transmission?: string;
-  deleteSelector?: string;
-  placementId?: number;
-  compression?: string;
-  payload?: string;
-}
-
-// Pending chunked transmission state.
-// Stores metadata from the first chunk while accumulating decoded payload data.
-export interface IPendingTransmission {
-  // The parsed command from the first chunk (contains action, format, dimensions, etc.)
-  cmd: IKittyCommand;
-  // Decoder used across chunked payloads
-  decoder: Base64Decoder;
-  // Total encoded (base64) bytes received across all chunks - for size limit enforcement
-  totalEncodedSize: number;
-  // Whether any chunk has failed to decode
-  decodeError: boolean;
-}
-
-// Stored Kitty image data.
-export interface IKittyImageData {
-  id: number;
-  // Decoded image data stored as Blob (off JS heap) to avoid 2GB heap limit
-  data: Blob;
-  width: number;
-  height: number;
-  format: 24 | 32 | 100;
-  compression?: string;
-}
-
-// Parses Kitty graphics control data into a command object.
-export function parseKittyCommand(data: string): IKittyCommand {
-  const cmd: IKittyCommand = {};
-  const parts = data.split(',');
-
-  for (const part of parts) {
-    const eqIdx = part.indexOf('=');
-    if (eqIdx === -1) continue;
-
-    const key = part.substring(0, eqIdx);
-    const value = part.substring(eqIdx + 1);
-
-    // Handle string keys first
-    if (key === KittyKey.ACTION) {
-      cmd.action = value;
-      continue;
-    }
-    if (key === KittyKey.COMPRESSION) {
-      cmd.compression = value;
-      continue;
-    }
-    if (key === KittyKey.TRANSMISSION) {
-      cmd.transmission = value;
-      continue;
-    }
-    if (key === KittyKey.DELETE_SELECTOR) {
-      cmd.deleteSelector = value;
-      continue;
-    }
-    const numValue = parseInt(value);
-    switch (key) {
-      case KittyKey.FORMAT: cmd.format = numValue; break;
-      case KittyKey.ID: cmd.id = numValue; break;
-      case KittyKey.IMAGE_NUMBER: cmd.imageNumber = numValue; break;
-      case KittyKey.WIDTH: cmd.width = numValue; break;
-      case KittyKey.HEIGHT: cmd.height = numValue; break;
-      case KittyKey.X_OFFSET: cmd.x = numValue; break;
-      case KittyKey.Y_OFFSET: cmd.y = numValue; break;
-      case KittyKey.SOURCE_WIDTH: cmd.sourceWidth = numValue; break;
-      case KittyKey.SOURCE_HEIGHT: cmd.sourceHeight = numValue; break;
-      case KittyKey.X_PLACEMENT_OFFSET: cmd.xOffset = numValue; break;
-      case KittyKey.Y_PLACEMENT_OFFSET: cmd.yOffset = numValue; break;
-      case KittyKey.COLUMNS: cmd.columns = numValue; break;
-      case KittyKey.ROWS: cmd.rows = numValue; break;
-      case KittyKey.MORE: cmd.more = numValue; break;
-      case KittyKey.QUIET: cmd.quiet = numValue; break;
-      case KittyKey.CURSOR_MOVEMENT: cmd.cursorMovement = numValue; break;
-      case KittyKey.Z_INDEX: cmd.zIndex = numValue; break;
-      case KittyKey.PLACEMENT_ID: cmd.placementId = numValue; break;
-    }
-  }
-
-  return cmd;
-}
@@ -1,155 +0,0 @@
-/**
- * Copyright (c) 2026 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { IDisposable } from '@xterm/xterm';
-import { ImageStorage } from '../ImageStorage';
-import { ImageLayer, IAddImageOpts } from '../Types';
-import { IKittyImageData } from './KittyGraphicsTypes';
-
-// Kitty-specific image storage controller.
-//
-// Wraps shared ImageStorage with kitty protocol semantics:
-// - tracks transmitted image payloads by kitty image id
-// - tracks kitty image id -> shared ImageStorage id mapping for displayed images
-// - mirrors shared-storage evictions into kitty maps
-// - applies protocol-level undisplayed-image eviction policy
-export class KittyImageStorage implements IDisposable {
-  private static readonly _maxStoredImages = 256;
-
-  private _nextImageId = 1;
-  private readonly _images: Map<number, IKittyImageData> = new Map();
-  // TODO: Support multiple placements per image. The kitty spec identifies
-  // placements by an (image id, placement id) pair — same i + different p
-  // values should coexist, and same i + same p should replace the prior
-  // placement. Currently we track only one storage entry per kitty image id,
-  // so multiple placements of the same image overwrite each other. Fixing
-  // this requires changing these maps to Map<number, Map<number, number>>
-  // (kittyId → placementId → storageId) and updating addImage/deleteById
-  // accordingly. The underlying shared ImageStorage would also need to
-  // support multiple entries per logical image.
-  private readonly _kittyIdToStorageId: Map<number, number> = new Map();
-  private readonly _storageIdToKittyId: Map<number, number> = new Map();
-
-  private readonly _previousOnImageDeleted: ((storageId: number) => void) | undefined;
-  private readonly _wrappedOnImageDeleted: (storageId: number) => void;
-  private readonly _handleStorageImageDeleted = (storageId: number): void => {
-    const kittyId = this._storageIdToKittyId.get(storageId);
-    if (kittyId !== undefined) {
-      this._kittyIdToStorageId.delete(kittyId);
-      this._storageIdToKittyId.delete(storageId);
-      this._images.delete(kittyId);
-    }
-  };
-  private _addImageOpts: IAddImageOpts = { scrolling: true, layer: 'top', zIndex: 0, cursorPos: 'iip' };
-
-  constructor(
-    private readonly _storage: ImageStorage
-  ) {
-    this._previousOnImageDeleted = this._storage.onImageDeleted;
-    this._wrappedOnImageDeleted = (storageId: number) => {
-      this._previousOnImageDeleted?.(storageId);
-      this._handleStorageImageDeleted(storageId);
-    };
-    this._storage.onImageDeleted = this._wrappedOnImageDeleted;
-  }
-
-  public reset(): void {
-    this._nextImageId = 1;
-    this._images.clear();
-    this._kittyIdToStorageId.clear();
-    this._storageIdToKittyId.clear();
-  }
-
-  public dispose(): void {
-    this.reset();
-    if (this._storage.onImageDeleted === this._wrappedOnImageDeleted) {
-      this._storage.onImageDeleted = this._previousOnImageDeleted;
-    }
-  }
-
-  public storeImage(id: number | undefined, imageData: Omit<IKittyImageData, 'id'>): number {
-    const imageId = id ?? this._nextImageId++;
-
-    const oldStorageId = this._kittyIdToStorageId.get(imageId);
-    if (oldStorageId !== undefined) {
-      this._storage.deleteImage(oldStorageId);
-      this._kittyIdToStorageId.delete(imageId);
-      this._storageIdToKittyId.delete(oldStorageId);
-    }
-
-    if (!this._images.has(imageId) && this._images.size >= KittyImageStorage._maxStoredImages) {
-      this._evictUndisplayedImages();
-    }
-
-    this._images.set(imageId, {
-      ...imageData,
-      id: imageId
-    });
-    return imageId;
-  }
-
-  public addImage(kittyId: number, image: HTMLCanvasElement | ImageBitmap, scrolling: boolean, layer: ImageLayer, zIndex: number): void {
-    // Clean up stale reverse-mapping from a previous placement of the same
-    // kitty image.  The old shared-storage entry is kept (it may still be
-    // visible on screen) but its reverse mapping is removed so that eviction
-    // of the old entry won't incorrectly delete the kitty image data.
-    const oldStorageId = this._kittyIdToStorageId.get(kittyId);
-    if (oldStorageId !== undefined) {
-      this._storageIdToKittyId.delete(oldStorageId);
-    }
-    this._addImageOpts.scrolling = scrolling;
-    this._addImageOpts.layer = layer;
-    this._addImageOpts.zIndex = zIndex;
-    const storageId = this._storage.addImage(image, this._addImageOpts);
-    this._kittyIdToStorageId.set(kittyId, storageId);
-    this._storageIdToKittyId.set(storageId, kittyId);
-  }
-
-  public getImage(kittyId: number): IKittyImageData | undefined {
-    return this._images.get(kittyId);
-  }
-
-  public deleteById(kittyId: number): void {
-    this._images.delete(kittyId);
-    const storageId = this._kittyIdToStorageId.get(kittyId);
-    if (storageId !== undefined) {
-      this._storage.deleteImage(storageId);
-      this._kittyIdToStorageId.delete(kittyId);
-      this._storageIdToKittyId.delete(storageId);
-    }
-  }
-
-  public deleteAll(): void {
-    this._images.clear();
-    for (const storageId of this._kittyIdToStorageId.values()) {
-      this._storage.deleteImage(storageId);
-    }
-    this._kittyIdToStorageId.clear();
-    this._storageIdToKittyId.clear();
-  }
-
-  public get images(): ReadonlyMap<number, IKittyImageData> {
-    return this._images;
-  }
-
-  public get kittyIdToStorageId(): ReadonlyMap<number, number> {
-    return this._kittyIdToStorageId;
-  }
-
-  public get lastImageId(): number {
-    return this._nextImageId - 1;
-  }
-
-  private _evictUndisplayedImages(): void {
-    for (const [kittyId] of this._images) {
-      if (this._images.size <= KittyImageStorage._maxStoredImages / 2) {
-        break;
-      }
-      if (!this._kittyIdToStorageId.has(kittyId)) {
-        this._images.delete(kittyId);
-      }
-    }
-  }
-}
@@ -11,14 +11,12 @@
    "types": [
      "../../../node_modules/@types/mocha"
    ],
+    "baseUrl": ".",
    "paths": {
-      "target-browser/*": [ "../../../src/target-browser/*" ],
-      "common/*": [
-        "../../../src/primitives/*",
-        "../../../src/runtime/*",
-      ],
-      "@xterm/addon-image": [ "../typings/addon-image.d.ts" ],
-      "*": [ "./*" ]
+      "browser/*": [ "../../../src/browser/*" ],
+      "common/*": [ "../../../src/common/*" ],
+      "vs/*": [ "../../../src/vs/*" ],
+      "@xterm/addon-image": [ "../typings/addon-image.d.ts" ]
    }
  },
  "include": [
@@ -26,7 +24,8 @@
    "../../../typings/xterm.d.ts"
  ],
  "references": [
-    { "path": "../../../src/target-browser" },
-    { "path": "../../../src" }
+    { "path": "../../../src/browser" },
+    { "path": "../../../src/common" },
+    { "path": "../../../src/vs" }
  ]
 }
@@ -8,7 +8,6 @@ import { readFileSync } from 'fs';
 import { FINALIZER, introducer, sixelEncode } from 'sixel';
 import { ITestContext, createTestContext, openTerminal, pollFor, timeout } from '../../../test/playwright/TestUtils';
 import { deepStrictEqual, ok, strictEqual } from 'assert';
-import QoiEncoder from 'xterm-wasm-parts/lib/qoi/QoiEncoder.wasm';

 /**
 * Plugin ctor options.
@@ -24,8 +23,6 @@ export interface IImageAddonOptions {
  sixelSizeLimit: number;
  iipSupport: boolean;
  iipSizeLimit: number;
-  kittySupport: boolean;
-  kittySizeLimit: number;
 }

 // eslint-disable-next-line
@@ -75,10 +72,6 @@ const TESTDATA_IIP: [string, [number, number]][] = [
  [readFileSync('./addons/addon-image/fixture/iip/w3c_jpg.iip', { encoding: 'utf-8' }), [72, 48]],
  [readFileSync('./addons/addon-image/fixture/iip/w3c_png.iip', { encoding: 'utf-8' }), [72, 48]]
 ];
-const PALETTE_PNG_BASE64 = readFileSync('./addons/addon-image/fixture/palette.png').toString('base64');
-const qoiEnc = new QoiEncoder(1024*1024);
-const qoiData = qoiEnc.encode(TESTDATA.bytes, 640, 80);
-const PALETTE_QOI_BASE64 = Buffer.from(qoiData).toString('base64');

 let ctx: ITestContext;
 test.beforeAll(async ({ browser }) => {
@@ -90,6 +83,11 @@ test.afterAll(async () => await ctx.page.close());
 test.describe('ImageAddon', () => {

  test.beforeEach(async ({}, testInfo) => {
+    // DEBT: This test never worked on webkit
+    if (ctx.browser.browserType().name() === 'webkit') {
+      testInfo.skip();
+      return;
+    }
    await ctx.page.evaluate(`
      window.term.reset()
      window.imageAddon?.dispose();
@@ -132,13 +130,11 @@ test.describe('ImageAddon', () => {
        sixelSupport: true,
        sixelScrolling: true,
        sixelPaletteLimit: 512,  // set to 512 to get example image working
-        sixelSizeLimit: 33554432,
+        sixelSizeLimit: 25000000,
        storageLimit: 128,
        showPlaceholder: true,
        iipSupport: true,
-        iipSizeLimit: 33554432,
-        kittySupport: true,
-        kittySizeLimit: 33554432
+        iipSizeLimit: 20000000
      };
      deepStrictEqual(await ctx.page.evaluate(`window.imageAddon._opts`), DEFAULT_OPTIONS);
    });
@@ -153,9 +149,7 @@ test.describe('ImageAddon', () => {
        storageLimit: 10,
        showPlaceholder: false,
        iipSupport: false,
-        iipSizeLimit: 1000,
-        kittySupport: false,
-        kittySizeLimit: 1000
+        iipSizeLimit: 1000
      };
      await ctx.page.evaluate(opts => {
        (window as any).imageAddonCustom = new ImageAddon(opts.opts);
@@ -196,18 +190,6 @@ test.describe('ImageAddon', () => {
  });

  test.describe('image lifecycle & eviction', () => {
-    test('onImageAdded fires for each image', async () => {
-      await ctx.page.evaluate(`
-        window._imageAddedCount = 0;
-        window.imageAddon.onImageAdded(() => { window._imageAddedCount++; });
-      `);
-      await ctx.proxy.write(SIXEL_SEQ_0);
-      await pollFor(ctx.page, 'window._imageAddedCount', 1);
-      await ctx.proxy.write(SIXEL_SEQ_0);
-      await pollFor(ctx.page, 'window._imageAddedCount', 2);
-      await ctx.proxy.write(SIXEL_SEQ_0);
-      await pollFor(ctx.page, 'window._imageAddedCount', 3);
-    });
    test('delete image once scrolled off', async () => {
      await ctx.proxy.write(SIXEL_SEQ_0);
      pollFor(ctx.page, 'window.imageAddon._storage._images.size', 1);
@@ -290,67 +272,6 @@ test.describe('ImageAddon', () => {
    });
  });

-  test.describe('IIP support', () => {
-    test('size params is optional/informative', async () => {
-      // too small size param
-      await ctx.proxy.write(`\x1b]1337;File=inline=1;size=5:${PALETTE_PNG_BASE64}\x07`);
-      deepStrictEqual(await getOrigSize(1), [640, 80]);
-      // no size aparm at all
-      await ctx.proxy.write(`\x1b[10H\x1b]1337;File=inline=1:${PALETTE_QOI_BASE64}\x07`);
-      deepStrictEqual(await getOrigSize(2), [640, 80]);
-    });
-    test.skip('FilePart support - bytewise', async () => {
-      // opener
-      await ctx.proxy.write(`\x1b]1337;MultipartFile=inline=1\x07`);
-      // byte-wise
-      for (let i = 0; i < PALETTE_PNG_BASE64.length; ++i) {
-        await ctx.proxy.write(`\x1b]1337;FilePart=${PALETTE_PNG_BASE64[i]}\x07`);
-      }
-      // finalizer
-      await ctx.proxy.write(`\x1b]1337;FileEnd\x07`);
-      deepStrictEqual(await getOrigSize(1), [640, 80]);
-    });
-    test('FilePart support - chunks', async () => {
-      // opener
-      await ctx.proxy.write(`\x1b]1337;MultipartFile=inline=1\x07`);
-      // chunks
-      for (let i = 0; i < PALETTE_PNG_BASE64.length; i += 256) {
-        await ctx.proxy.write(`\x1b]1337;FilePart=${PALETTE_PNG_BASE64.slice(i, i + 256)}\x07`);
-      }
-      // finalizer
-      await ctx.proxy.write(`\x1b]1337;FileEnd\x07`);
-      deepStrictEqual(await getOrigSize(1), [640, 80]);
-    });
-    test('FilePart support - edgecases', async () => {
-      // multiple opener do not harm
-      for (let i = 0; i < 10; ++i) {
-        await ctx.proxy.write(`\x1b]1337;MultipartFile=inline=1\x07`);
-      }
-      // multiple finalizer do not harm
-      for (let i = 0; i < 5; ++i) {
-        await ctx.proxy.write(`\x1b]1337;FileEnd\x07`);
-      }
-      // chunks w'o opener are ignored
-      for (let i = 0; i < PALETTE_PNG_BASE64.length; i += 256) {
-        await ctx.proxy.write(`\x1b]1337;FilePart=${PALETTE_PNG_BASE64.slice(i, i + 256)}\x07`);
-      }
-      await ctx.proxy.write(`\x1b]1337;FileEnd\x07`);
-      pollFor(ctx.page, 'window.imageAddon._storage._images.size', 0);
-    });
-    test('FilePart support - other IIP sequence cancels chunked image', async () => {
-      // opener
-      await ctx.proxy.write(`\x1b]1337;MultipartFile=inline=1\x07`);
-      // chunks
-      for (let i = 0; i < PALETTE_PNG_BASE64.length; i += 256) {
-        await ctx.proxy.write(`\x1b]1337;FilePart=${PALETTE_PNG_BASE64.slice(i, i + 256)}\x07`);
-      }
-      // finalizer skipped
-      // write spinfox.png
-      await ctx.proxy.write(TESTDATA_IIP[1][0]);
-      deepStrictEqual(await getOrigSize(1), TESTDATA_IIP[1][1]);
-    });
-  });
-
  test.describe('IIP support - testimages', () => {
    test('palette.png', async () => {
      await ctx.proxy.write(TESTDATA_IIP[0][0]);
@@ -373,75 +294,13 @@ test.describe('ImageAddon', () => {
      deepStrictEqual(await getOrigSize(1), TESTDATA_IIP[4][1]);
    });
  });
-
-  test.describe('IIP - QOI support', () => {
-    test('palette should yield same bytes from PNG and QOI', async () => {
-      await ctx.proxy.write(`\x1b]1337;File=inline=1;size=525:${PALETTE_PNG_BASE64}\x07`);
-      deepStrictEqual(await getOrigSize(1), [640, 80]);
-      await ctx.proxy.write(`\x1b[10H\x1b]1337;File=inline=1;size=${qoiData.length}:${PALETTE_QOI_BASE64}\x07`);
-      deepStrictEqual(await getOrigSize(2), [640, 80]);
-      const pngScrape = await getImageAtBufferCell(0, 0);
-      const qoiScrape = await getImageAtBufferCell(0, 11);
-      deepStrictEqual(qoiScrape, pngScrape);
-    });
-  });
-
-  test.describe('IIP - resizing', () => {
-    /**
-     * The correct resize behavior is wonky and needs to be tested against iTerm2,
-     * especially for missing params to derive correct default behavior.
-     * We document the current behavior here w'o claiming to be fully in line with iTerm2.
-     * ref: https://iterm2.com/documentation-images.html
-     * imgcat: https://iterm2.com/utilities/imgcat
-     *
-     * NOTE: QOI has a slightly different parse path, thus we test resizing explicitly
-     */
-    const images = [
-      ['palette.png', 525, PALETTE_PNG_BASE64],
-      ['palette.qoi', qoiData.length, PALETTE_QOI_BASE64]
-    ];
-    for (const [name, size, payload] of images) {
-      test(name + ': N --> width=20 height=5 preserveAspectRatio=0', async () => {
-        // cell based resize
-        const header = 'width=20;height=5;preserveAspectRatio=0';
-        await ctx.proxy.write(`\x1b]1337;File=inline=1;size=${size};${header}:${payload}\x07`);
-        const dim = await getDimensions();
-        deepStrictEqual(await getOrigSize(1), [dim.cellWidth * 20, dim.cellHeight * 5]);
-      });
-      test(name + ': Npx --> width=320px height=160px preserveAspectRatio=0', async () => {
-        // pixel based resize
-        const header = 'width=320px;height=160px;preserveAspectRatio=0';
-        await ctx.proxy.write(`\x1b]1337;File=inline=1;size=${size};${header}:${payload}\x07`);
-        deepStrictEqual(await getOrigSize(1), [320, 160]);
-      });
-      test(name + ': N% --> width=50% height=30% preserveAspectRatio=0', async () => {
-        // % of viewport resize
-        const header = 'width=50%;height=30%;preserveAspectRatio=0';
-        await ctx.proxy.write(`\x1b]1337;File=inline=1;size=${size};${header}:${payload}\x07`);
-        const dim = await getDimensions();
-        deepStrictEqual(await getOrigSize(1), [Math.floor(dim.width * 0.5), Math.floor(dim.height * 0.3)]);
-      });
-      test(name + ': ommitted dimension assumes preserveAspectRatio=1', async () => {
-        // width provided in percent
-        const header = 'width=50%';
-        await ctx.proxy.write(`\x1b]1337;File=inline=1;size=${size};${header}:${payload}\x07`);
-        const dim = await getDimensions();
-        const width = Math.floor(dim.width * 0.5);
-        deepStrictEqual(await getOrigSize(1), [width, Math.floor(width * 80 / 640)]);
-        // height provided in pixel
-        const header2 = 'height=200px';
-        await ctx.proxy.write(`\x1b]1337;File=inline=1;size=${size};${header2}:${payload}\x07`);
-        deepStrictEqual(await getOrigSize(2), [Math.floor(200 * 640 / 80), 200]);
-      });
-    }
-  });
 });

 /**
 * terminal access helpers.
 */
 async function getDimensions(): Promise<IDimensions> {
-  const dimensions: any = await ctx.page.evaluate(`term.dimensions`);
+  const dimensions: any = await ctx.page.evaluate(`term._core._renderService.dimensions`);
  return {
    cellWidth: Math.round(dimensions.css.cell.width),
    cellHeight: Math.round(dimensions.css.cell.height),
@@ -468,7 +327,3 @@ async function getOrigSize(id: number): Promise<[number, number]> {
    window.imageAddon._storage._images.get(${id}).orig.height
  ]`);
 }
-
-async function getImageAtBufferCell(x: number, y: number): Promise<string | undefined> {
-  return ctx.page.evaluate<any>(`window.imageAddon.getImageAtBufferCell(${x}, ${y})?.toDataURL('image/png')`);
-}
@@ -5,9 +5,10 @@ const config: PlaywrightTestConfig = {
  timeout: 10000,
  projects: [
    {
-      name: 'Chromium',
+      name: 'ChromeStable',
      use: {
-        browserName: 'chromium'
+        browserName: 'chromium',
+        channel: 'chrome'
      }
    },
    {
@@ -9,16 +9,13 @@
    "outDir": "../out-test",
    "sourceMap": true,
    "removeComments": true,
+    "baseUrl": ".",
    "paths": {
      "common/*": [
-        "../../../src/primitives/*",
-        "../../../src/runtime/*",
+        "../../../src/common/*"
      ],
-      "target-browser/*": [
-        "../../../src/target-browser/*"
-      ],
-      "*": [
-        "./*"
+      "browser/*": [
+        "../../../src/browser/*"
      ]
    },
    "strict": true,
@@ -32,10 +29,10 @@
  ],
  "references": [
    {
-      "path": "../../../src"
+      "path": "../../../src/common"
    },
    {
-      "path": "../../../src/target-browser"
+      "path": "../../../src/browser"
    },
    {
      "path": "../../../test/playwright"
@@ -3,7 +3,7 @@
 * @license MIT
 */

-import { Terminal, ITerminalAddon, IEvent } from '@xterm/xterm';
+import { Terminal, ITerminalAddon } from '@xterm/xterm';

 declare module '@xterm/addon-image' {
  export interface IImageAddonOptions {
@@ -76,15 +76,6 @@ declare module '@xterm/addon-image' {
    iipSupport?: boolean;
    /** IIP sequence size limit (default 20000000 bytes). */
    iipSizeLimit?: number;
-
-    /**
-     * Kitty graphics protocol settings
-     */
-
-    /** Whether Kitty graphics protocol is enabled (default is true). */
-    kittySupport?: boolean;
-    /** Kitty image size limit in bytes (default 20000000 bytes). */
-    kittySizeLimit?: number;
  }

  export class ImageAddon implements ITerminalAddon {
@@ -116,11 +107,6 @@ declare module '@xterm/addon-image' {
     */
    public showPlaceholder: boolean;

-    /**
-     * Event fired whenever a new image is added to storage.
-     */
-    public readonly onImageAdded: IEvent<void>;
-
    /**
     * Get original image canvas at buffer position.
     */
@@ -25,11 +25,8 @@ const addon = {
    modules: ['./node_modules'],
    extensions: [ '.js' ],
    alias: {
-      common: [
-      path.resolve('../../out/runtime'),
-      path.resolve('../../out/primitives'),
-    ],
-      browser: path.resolve('../../out/target-browser'),
+      common: path.resolve('../../out/common'),
+      browser: path.resolve('../../out/browser'),
      vs: path.resolve('../../out/vs')
    }
  },
@@ -3,9 +3,11 @@ node_modules/
 coverage/

 lib/
+fonts/

 .env
 .vscode/
 *.swp
 *.tgz
 npm-debug.log*
+yarn-error.log*
@@ -1,30 +1,6 @@
-Copyright (c) 2019, 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.
-
---
-
-The code that analyzes font ligatures is forked from https://github.com/princjef/font-ligatures with this license:
-
 MIT License

-Copyright (c) 2018 Jeffrey Principe
+Copyright (c) 2018

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -0,0 +1,78 @@
+/**
+ * Copyright (c) 2018 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+const fs = require('fs');
+const path = require('path');
+const util = require('util');
+
+const axios = require('axios').default;
+const mkdirp = require('mkdirp');
+const yauzl = require('yauzl');
+
+const urls = {
+  fira: 'https://github.com/tonsky/FiraCode/raw/d42e7276fa925e5f82748f3ec9ea429736611b48/distr/otf/FiraCode-Regular.otf',
+  iosevka: 'https://github.com/be5invis/Iosevka/releases/download/v1.14.3/01-iosevka-1.14.3.zip'
+};
+
+const writeFile = util.promisify(fs.writeFile);
+const fontsFolder = path.join(__dirname, '../fonts');
+
+async function download() {
+  await mkdirp(fontsFolder);
+
+  try {
+    await downloadFiraCode();
+    await downloadIosevka();
+    console.log('Loaded all fonts for testing')
+  } catch (e) {
+    console.warn('Fonts failed to download, ligature tests will not work', e);
+  }
+}
+
+async function downloadFiraCode() {
+  const file = path.join(fontsFolder, 'firaCode.otf');
+  if (await util.promisify(fs.exists)(file)) {
+    console.log('Fira Code already loaded');
+  } else {
+    console.log('Downloading Fira Code...');
+    await writeFile(
+      file,
+      (await axios.get(urls.fira, { responseType: 'arraybuffer' })).data
+    );
+  }
+}
+
+async function downloadIosevka() {
+  const file = path.join(fontsFolder, 'iosevka.ttf');
+  if (await util.promisify(fs.exists)(file)) {
+    console.log('Iosevka already loaded');
+  } else {
+    console.log('Downloading Iosevka...');
+    const iosevkaContents = (await axios.get(urls.iosevka, { responseType: 'arraybuffer' })).data;
+    const iosevkaZipfile = await util.promisify(yauzl.fromBuffer)(iosevkaContents);
+    await new Promise((resolve, reject) => {
+      iosevkaZipfile.on('entry', entry => {
+        if (entry.fileName === 'ttf/iosevka-regular.ttf') {
+          iosevkaZipfile.openReadStream(entry, (err, stream) => {
+            if (err) {
+              return reject(err);
+            }
+
+            const writeStream = fs.createWriteStream(file);
+            stream.pipe(writeStream);
+            writeStream.on('close', () => resolve());
+          });
+        }
+      });
+    });
+  }
+}
+
+download();
+
+process.on('unhandledRejection', e => {
+  console.error(e);
+  process.exit(1);
+});
@@ -1,6 +1,6 @@
 {
  "name": "@xterm/addon-ligatures",
-  "version": "0.10.0",
+  "version": "0.9.0",
  "description": "Add support for programming ligatures to xterm.js",
  "author": {
    "name": "The xterm.js authors",
@@ -14,13 +14,14 @@
    "node": ">8.0.0"
  },
  "scripts": {
-    "build": "tsgo -p src",
-    "watch": "tsgo -w -p src",
+    "prepare": "node bin/download-fonts.js",
+    "build": "tsc -p src",
+    "watch": "tsc -w -p src",
    "prepackage": "npm run build",
    "package": "webpack",
    "pretest": "npm run build",
    "test": "nyc mocha out/**/*.test.js",
-    "prepublishOnly": "npm run package"
+    "prepublish": "npm run package"
  },
  "keywords": [
    "font",
@@ -31,11 +32,17 @@
  ],
  "license": "MIT",
  "dependencies": {
-    "lru-cache": "^11.3.6",
-    "opentype.js": "^2.0.0"
+    "font-finder": "^1.1.0",
+    "font-ligatures": "^1.4.1"
  },
  "devDependencies": {
-    "@types/opentype.js": "^1.3.9",
-    "font-finder": "^1.1.0"
+    "@types/sinon": "^5.0.1",
+    "axios": "^1.6.0",
+    "mkdirp": "0.5.5",
+    "sinon": "6.3.5",
+    "yauzl": "^2.10.0"
+  },
+  "peerDependencies": {
+    "@xterm/xterm": "^5.0.0"
  }
 }
@@ -13,7 +13,7 @@ export interface ITerminalAddon {
  dispose(): void;
 }

-export class LigaturesAddon implements ITerminalAddon, ILigaturesApi {
+export class LigaturesAddon implements ITerminalAddon , ILigaturesApi {
  private readonly _fallbackLigatures: string[];
  private readonly _fontFeatureSettings?: string;

@@ -22,7 +22,7 @@ export class LigaturesAddon implements ITerminalAddon, ILigaturesApi {

  constructor(options?: Partial<ILigatureOptions>) {
    // Source: calt set from https://github.com/be5invis/Iosevka?tab=readme-ov-file#ligations
-    this._fallbackLigatures = (options?.fallbackLigatures ?? [
+    this._fallbackLigatures = (options?.fallbackLigatures || [
      '<--', '<---', '<<-', '<-', '->', '->>', '-->', '--->',
      '<==', '<===', '<<=', '<=', '=>', '=>>', '==>', '===>', '>=', '>>=',
      '<->', '<-->', '<--->', '<---->', '<=>', '<==>', '<===>', '<====>', '::', ':::',
@@ -3,7 +3,7 @@
 * @license MIT
 */

-import { Font, loadBuffer } from './fontLigatures/index';
+import { Font, loadBuffer } from 'font-ligatures';

 import parse from './parse';

@@ -42,11 +42,11 @@ export default async function load(fontFamily: string, cacheSize: number): Promi
        if (status && status.state !== 'granted') {
          throw new Error('Permission to access local fonts not granted.');
        }
-      } catch (err: unknown) {
+      } catch (err: any) {
        // A `TypeError` indicates the 'local-fonts'
        // permission is not yet implemented, so
        // only `throw` if this is _not_ the problem.
-        if (err instanceof Error && err.name !== 'TypeError') {
+        if (err.name !== 'TypeError') {
          throw err;
        }
      }
@@ -60,10 +60,8 @@ export default async function load(fontFamily: string, cacheSize: number): Promi
          fonts[metadata.family].push(metadata);
        }
        fontsPromise = Promise.resolve(fonts);
-      } catch (err: unknown) {
-        if (err instanceof Error) {
-          console.error(err.name, err.message);
-        }
+      } catch (err: any) {
+        console.error(err.name, err.message);
      }
    }
    // Latest proposal https://bugs.chromium.org/p/chromium/issues/detail?id=1312603
@@ -78,13 +76,13 @@ export default async function load(fontFamily: string, cacheSize: number): Promi
          fonts[metadata.family].push(metadata);
        }
        fontsPromise = Promise.resolve(fonts);
-      } catch (err: unknown) {
-        if (err instanceof Error) {
-          console.error(err.name, err.message);
-        }
+      } catch (err: any) {
+        console.error(err.name, err.message);
      }
    }
-    fontsPromise ??= Promise.resolve({});
+    if (!fontsPromise) {
+      fontsPromise = Promise.resolve({});
+    }
  }

  const fonts = await fontsPromise;
@@ -1,40 +0,0 @@
-import { ILookupTree, IFlattenedLookupTree, ILookupTreeEntry, IFlattenedLookupTreeEntry } from './types';
-
-export default function flatten(tree: ILookupTree, visited: Map<ILookupTreeEntry, IFlattenedLookupTreeEntry> = new Map()): IFlattenedLookupTree {
-  const result: IFlattenedLookupTree = {};
-  for (const [glyphId, entry] of Object.entries(tree.individual)) {
-    result[glyphId] = flattenEntry(entry, visited);
-  }
-
-  for (const { range, entry } of tree.range) {
-    const flattened = flattenEntry(entry, visited);
-    for (let glyphId = range[0]; glyphId < range[1]; glyphId++) {
-      result[glyphId] = flattened;
-    }
-  }
-
-  return result;
-}
-
-function flattenEntry(entry: ILookupTreeEntry, visited: Map<ILookupTreeEntry, IFlattenedLookupTreeEntry>): IFlattenedLookupTreeEntry {
-  if (visited.has(entry)) {
-    return visited.get(entry)!;
-  }
-
-  const result: IFlattenedLookupTreeEntry = {};
-  visited.set(entry, result);
-
-  if (entry.forward) {
-    result.forward = flatten(entry.forward, visited);
-  }
-
-  if (entry.reverse) {
-    result.reverse = flatten(entry.reverse, visited);
-  }
-
-  if (entry.lookup) {
-    result.lookup = entry.lookup;
-  }
-
-  return result;
-}
@@ -1,358 +0,0 @@
-/**
- * Copyright (c) 2018 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import * as path from 'path';
-import * as fs from 'fs';
-import { assert } from 'chai';
-import { loadBuffer } from './index';
-
-interface IFont {
-  findLigatures(text: string): { outputGlyphs: number[], contextRanges: [number, number][] };
-  findLigatureRanges(text: string): [number, number][];
-}
-
-interface ITestCase {
-  font: string;
-  input: string;
-  glyphs: number[];
-  ranges: [number, number][];
-}
-
-const fira = (input: string, glyphs: number[], ranges: [number, number][]): ITestCase =>
-  ({ font: 'Fira Code', input, glyphs, ranges });
-
-const iosevka = (input: string, glyphs: number[], ranges: [number, number][]): ITestCase =>
-  ({ font: 'Iosevka', input, glyphs, ranges });
-
-const monoid = (input: string, glyphs: number[], ranges: [number, number][]): ITestCase =>
-  ({ font: 'Monoid', input, glyphs, ranges });
-
-const ubuntu = (input: string, glyphs: number[], ranges: [number, number][]): ITestCase =>
-  ({ font: 'Ubuntu Mono', input, glyphs, ranges });
-
-const firaCases: ITestCase[] = [
-  fira('abc', [133, 145, 146], []),
-  fira('.=', [1614, 1081], [[0, 2]]),
-  fira('..=', [1614, 1614, 1083], [[0, 3]]),
-  fira('.-', [1614, 1080], [[0, 2]]),
-  fira(':=', [1614, 1055], [[0, 2]]),
-  fira('=:=', [1614, 1614, 1483], [[0, 3]]),
-  fira('=!=', [1614, 1614, 1484], [[0, 3]]),
-  fira('__', [1614, 1099], [[0, 2]]),
-  fira('==', [1614, 1485], [[0, 2]]),
-  fira('!=', [1614, 1058], [[0, 2]]),
-  fira('===', [1614, 1614, 1486], [[0, 3]]),
-  fira('!==', [1614, 1614, 1059], [[0, 3]]),
-  fira('=/=', [1614, 1614, 1491], [[0, 3]]),
-  fira('<-<', [1614, 1614, 1513], [[0, 3]]),
-  fira('<<-', [1614, 1614, 1522], [[0, 3]]),
-  fira('<--', [1614, 1614, 1511], [[0, 3]]),
-  fira('<-', [1614, 1510], [[0, 2]]),
-  fira('<->', [1614, 1614, 1512], [[0, 3]]),
-  fira('->', [1614, 1064], [[0, 2]]),
-  fira('-->', [1614, 1614, 1063], [[0, 3]]),
-  fira('->>', [1614, 1614, 1065], [[0, 3]]),
-  fira('>->', [1614, 1614, 1493], [[0, 3]]),
-  fira('<=<', [1614, 1614, 1519], [[0, 3]]),
-  fira('<<=', [1614, 1614, 1523], [[0, 3]]),
-  fira('<==', [1614, 1614, 1517], [[0, 3]]),
-  fira('<=>', [1614, 1614, 1518], [[0, 3]]),
-  fira('=>', [1614, 1488], [[0, 2]]),
-  fira('==>', [1614, 1614, 1487], [[0, 3]]),
-  fira('=>>', [1614, 1614, 1489], [[0, 3]]),
-  fira('>=>', [1614, 1614, 1495], [[0, 3]]),
-  fira('>>=', [1614, 1614, 1498], [[0, 3]]),
-  fira('>>-', [1614, 1614, 1497], [[0, 3]]),
-  fira('>-', [1614, 1492], [[0, 2]]),
-  fira('<~>', [1614, 1614, 1526], [[0, 3]]),
-  fira('-<', [1614, 1066], [[0, 2]]),
-  fira('-<<', [1614, 1614, 1067], [[0, 3]]),
-  fira('=<<', [1614, 1614, 1490], [[0, 3]]),
-  fira('<~~', [1614, 1614, 1527], [[0, 3]]),
-  fira('<~', [1614, 1525], [[0, 2]]),
-  fira('~~', [1614, 1534], [[0, 2]]),
-  fira('~>', [1614, 1533], [[0, 2]]),
-  fira('~~>', [1614, 1614, 1535], [[0, 3]]),
-  fira('<<<', [1614, 1614, 1524], [[0, 3]]),
-  fira('<<', [1614, 1521], [[0, 2]]),
-  fira('<=', [1614, 1516], [[0, 2]]),
-  fira('<>', [1614, 1520], [[0, 2]]),
-  fira('>=', [1614, 1494], [[0, 2]]),
-  fira('>>', [1614, 1496], [[0, 2]]),
-  fira('>>>', [1614, 1614, 1499], [[0, 3]]),
-  fira('{.', [1001, 977], [[0, 2]]),
-  fira('{|', [1614, 1049], [[0, 2]]),
-  fira('[|', [1614, 1050], [[0, 2]]),
-  fira('<:', [1614, 1506], [[0, 2]]),
-  fira(':>', [1614, 1056], [[0, 2]]),
-  fira('|]', [1614, 1474], [[0, 2]]),
-  fira('|}', [1614, 1473], [[0, 2]]),
-  fira('.}', [977, 1002], [[0, 2]]),
-  fira('<|||', [1614, 1614, 1614, 1504], [[0, 4]]),
-  fira('<||', [1614, 1614, 1503], [[0, 3]]),
-  fira('<|', [1614, 1502], [[0, 2]]),
-  fira('<|>', [1614, 1614, 1505], [[0, 3]]),
-  fira('|>', [1614, 1477], [[0, 2]]),
-  fira('||>', [1614, 1614, 1472], [[0, 3]]),
-  fira('|||>', [1614, 1614, 1614, 1470], [[0, 4]]),
-  fira('<$', [1614, 1507], [[0, 2]]),
-  fira('<$>', [1614, 1614, 1508], [[0, 3]]),
-  fira('$>', [1614, 1479], [[0, 2]]),
-  fira('<+', [1614, 1514], [[0, 2]]),
-  fira('<+>', [1614, 1614, 1515], [[0, 3]]),
-  fira('+>', [1614, 1482], [[0, 2]]),
-  fira('<*', [1614, 1500], [[0, 2]]),
-  fira('<*>', [1614, 1614, 1501], [[0, 3]]),
-  fira('*>', [1614, 1047], [[0, 2]]),
-  fira('/*', [1614, 1092], [[0, 2]]),
-  fira('*/', [1614, 1048], [[0, 2]]),
-  fira('///', [1614, 1614, 1097], [[0, 3]]),
-  fira('//', [1614, 1096], [[0, 2]]),
-  fira('</', [1614, 1528], [[0, 2]]),
-  fira('<!--', [1614, 1614, 1614, 1509], [[0, 4]]),
-  fira('</>', [1614, 1614, 1529], [[0, 3]]),
-  fira('/>', [1614, 1095], [[0, 2]]),
-  fira('0xff', [895, 270, 166, 166], [[0, 3]]),
-  fira('10x10', [896, 895, 270, 896, 895], [[1, 4]]),
-  fira('9:45', [904, 998, 899, 900], [[0, 2]]),
-  fira('[:]', [1003, 998, 1004], [[0, 2]]),
-  fira(';;', [1614, 1091], [[0, 2]]),
-  fira('::', [1614, 1052], [[0, 2]]),
-  fira(':::', [1614, 1614, 1053], [[0, 3]]),
-  fira('..', [1614, 1082], [[0, 2]]),
-  fira('...', [1614, 1614, 1085], [[0, 3]]),
-  fira('..<', [1614, 1614, 1084], [[0, 3]]),
-  fira('!!', [1614, 1057], [[0, 2]]),
-  fira('??', [1614, 1090], [[0, 2]]),
-  fira('%%', [1614, 1536], [[0, 2]]),
-  fira('&&', [1614, 1468], [[0, 2]]),
-  fira('||', [1614, 1469], [[0, 2]]),
-  fira('?.', [1614, 1089], [[0, 2]]),
-  fira('?:', [1614, 1087], [[0, 2]]),
-  fira('++', [1614, 1480], [[0, 2]]),
-  fira('+++', [1614, 1614, 1481], [[0, 3]]),
-  fira('--', [1614, 1061], [[0, 2]]),
-  fira('---', [1614, 1614, 1062], [[0, 3]]),
-  fira('**', [1614, 1045], [[0, 2]]),
-  fira('***', [1614, 1614, 1046], [[0, 3]]),
-  fira('~=', [1614, 1532], [[0, 2]]),
-  fira('~-', [1614, 1531], [[0, 2]]),
-  fira('www', [1614, 1614, 271], [[0, 3]]),
-  fira('-~', [1614, 1068], [[0, 2]]),
-  fira('~@', [1614, 1530], [[0, 2]]),
-  fira('^=', [1614, 1478], [[0, 2]]),
-  fira('?=', [1614, 1088], [[0, 2]]),
-  fira('/=', [1614, 1093], [[0, 2]]),
-  fira('/==', [1614, 1614, 1094], [[0, 3]]),
-  fira('-|', [1614, 1060], [[0, 2]]),
-  fira('_|_', [1614, 1614, 1098], [[0, 3]]),
-  fira('|-', [1614, 1475], [[0, 2]]),
-  fira('|=', [1614, 1476], [[0, 2]]),
-  fira('||=', [1614, 1614, 1471], [[0, 3]]),
-  fira('#!', [1614, 1071], [[0, 2]]),
-  fira('#=', [1614, 1075], [[0, 2]]),
-  fira('##', [1614, 1072], [[0, 2]]),
-  fira('###', [1614, 1614, 1073], [[0, 3]]),
-  fira('####', [1614, 1614, 1614, 1074], [[0, 4]]),
-  fira('#{', [1614, 1069], [[0, 2]]),
-  fira('#[', [1614, 1070], [[0, 2]]),
-  fira(']#', [1614, 1051], [[0, 2]]),
-  fira('#(', [1614, 1076], [[0, 2]]),
-  fira('#?', [1614, 1077], [[0, 2]]),
-  fira('#_', [1614, 1078], [[0, 2]]),
-  fira('#_(', [1614, 1614, 1079], [[0, 3]]),
-  fira('::=', [1614, 1614, 1054], [[0, 3]]),
-  fira('.?', [1614, 1086], [[0, 2]]),
-  fira('===>', [1614, 1614, 1486, 1148], [[0, 4]])
-];
-
-const iosevkaCases: ITestCase[] = [
-  iosevka('<-', [31, 3127], [[0, 2]]),
-  iosevka('<--', [31, 3129, 3139], [[0, 3]]),
-  iosevka('<---', [31, 3129, 3150, 3139], [[0, 4]]),
-  iosevka('<-----', [31, 3129, 3150, 3139, 3151, 3151], [[0, 6]]),
-  iosevka('->', [3126, 33], [[0, 2]]),
-  iosevka('-->', [3140, 3128, 33], [[0, 3]]),
-  iosevka('--->', [3140, 3150, 3128, 33], [[0, 4]]),
-  iosevka('----->', [3153, 3153, 3140, 3150, 3128, 33], [[0, 6]]),
-  iosevka('<->', [31, 3149, 33], [[0, 3]]),
-  iosevka('<-->', [31, 3129, 3128, 33], [[0, 4]]),
-  iosevka('<--->', [31, 3129, 3150, 3128, 33], [[0, 5]]),
-  iosevka('<----->', [31, 3129, 3150, 3150, 3150, 3128, 33], [[0, 7]]),
-  iosevka('<=', [3094, 3095], [[0, 2]]),
-  iosevka('<==', [31, 3158, 3168], [[0, 3]]),
-  iosevka('<===', [31, 3158, 3179, 3168], [[0, 4]]),
-  iosevka('<=====', [31, 3158, 3179, 3168, 3180, 3180], [[0, 6]]),
-  iosevka('=>', [3155, 33], [[0, 2]]),
-  iosevka('==>', [3169, 3157, 33], [[0, 3]]),
-  iosevka('===>', [3169, 3179, 3157, 33], [[0, 4]]),
-  iosevka('=====>', [3182, 3182, 3169, 3179, 3157, 33], [[0, 6]]),
-  iosevka('<=>', [31, 3178, 33], [[0, 3]]),
-  iosevka('<==>', [31, 3158, 3157, 33], [[0, 4]]),
-  iosevka('<===>', [31, 3158, 3179, 3157, 33], [[0, 5]]),
-  iosevka('<=====>', [31, 3158, 3179, 3179, 3179, 3157, 33], [[0, 7]]),
-  iosevka('<!--', [31, 3184, 3130, 3139], [[0, 4]]),
-  iosevka('<!---', [31, 3184, 3130, 3150, 3139], [[0, 5]]),
-  iosevka('<!-----', [31, 3184, 3130, 3150, 3139, 3151, 3151], [[0, 7]]),
-  iosevka('a:b', [68, 29, 69], []),
-  iosevka('a::b', [68, 3012, 3013, 69], [[1, 3]]),
-  iosevka('a:::b', [68, 3012, 3010, 3013, 69], [[1, 4]]),
-  iosevka(':=', [3011, 32], [[0, 2]]),
-  iosevka(':-', [3011, 16], [[0, 2]]),
-  iosevka(':+', [3011, 14], [[0, 2]]),
-  iosevka('=:', [32, 3011], [[0, 2]]),
-  iosevka('-:', [16, 3011], [[0, 2]]),
-  iosevka('+:', [14, 3011], [[0, 2]]),
-  iosevka('<*', [31, 3023], [[0, 2]]),
-  iosevka('*>', [3023, 33], [[0, 2]]),
-  iosevka('<*>', [31, 3023, 33], [[1, 3]]),
-  iosevka('<**>', [31, 3023, 3023, 33], [[1, 4]]),
-  iosevka('<****>', [31, 3023, 3023, 3023, 3023, 33], [[0, 3], [3, 6]]),
-  iosevka('==', [3083, 3084], [[0, 2]]),
-  iosevka('!=', [3098, 3084], [[0, 2]]),
-  iosevka('===', [3083, 3085, 3084], [[0, 3]]),
-  iosevka('!==', [3099, 3085, 3084], [[0, 3]]),
-  iosevka('====', [3083, 3085, 3085, 3084], [[0, 4]]),
-  iosevka('!===', [3100, 3085, 3085, 3084], [[0, 4]])
-];
-
-const monoidCases: ITestCase[] = [
-  monoid('<!--', [775, 775, 775, 643], [[0, 4]]),
-  monoid('-->', [779, 779, 628], [[0, 3]]),
-  monoid('<--', [776, 776, 627], [[0, 3]]),
-  monoid('->>', [780, 780, 626], [[0, 3]]),
-  monoid('<<-', [777, 777, 625], [[0, 3]]),
-  monoid('->', [781, 623], [[0, 2]]),
-  monoid('<-', [778, 624], [[0, 2]]),
-  monoid('=>', [793, 666], [[0, 2]]),
-  monoid('<=>', [785, 785, 760], [[0, 3]]),
-  monoid('<==>', [786, 786, 786, 771], [[0, 4]]),
-  monoid('==>', [787, 787, 672], [[0, 3]]),
-  monoid('<==', [788, 788, 671], [[0, 3]]),
-  monoid('>>=', [791, 791, 758], [[0, 3]]),
-  monoid('=<<', [792, 792, 759], [[0, 3]]),
-  monoid('--', [667, 667], [[0, 2]]),
-  monoid(':=', [29, 761], [[0, 2]]),
-  monoid('=:=', [789, 789, 665], [[0, 3]]),
-  monoid('==', [794, 641], [[0, 2]]),
-  monoid('!==', [782, 782, 646], [[0, 3]]),
-  monoid('!=', [783, 629], [[0, 2]]),
-  monoid('<=', [790, 630], [[0, 2]]),
-  monoid('>=', [792, 631], [[0, 2]]),
-  monoid('//', [621, 664], [[0, 2]]),
-  monoid('/**', [18, 753, 753], [[0, 3]]),
-  monoid('/*', [18, 753], [[0, 2]]),
-  monoid('*/', [754, 18], [[0, 2]]),
-  monoid('&&', [633, 775], [[0, 2]]),
-  monoid('.&', [17, 755], [[0, 2]]),
-  monoid('||', [634, 635], [[0, 2]]),
-  monoid('!!', [769, 770], [[0, 2]]),
-  monoid('::', [772, 773], [[0, 2]]),
-  monoid('>>', [637, 638], [[0, 2]]),
-  monoid('<<', [639, 640], [[0, 2]]),
-  monoid('¯\\_(ツ)_/¯', [113, 765, 66, 767, 613, 768, 66, 766, 113], [[0, 3], [3, 6], [6, 9]]),
-  monoid('__', [763, 764], [[0, 2]])
-];
-
-const ubuntuCases: ITestCase[] = [
-  ubuntu('==>', [32, 32, 33], [])
-];
-
-const fontPaths: Record<string, string> = {
-  'Fira Code': path.join(__dirname, '../../fonts/FiraCode-Regular.otf'),
-  'Iosevka': path.join(__dirname, '../../fonts/iosevka-regular.ttf'),
-  'Monoid': path.join(__dirname, '../../fonts/Monoid-Regular.ttf'),
-  'Ubuntu Mono': path.join(__dirname, '../../fonts/UbuntuMono-Regular.ttf')
-};
-
-const fontCache: Map<string, IFont> = new Map();
-
-function loadFont(fontName: string): IFont {
-  let font = fontCache.get(fontName);
-  if (!font) {
-    const fontPath = fontPaths[fontName];
-    const buffer = fs.readFileSync(fontPath);
-    font = loadBuffer(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength));
-    fontCache.set(fontName, font);
-  }
-  return font;
-}
-
-describe('addon-ligatures - index', () => {
-  describe('findLigatures', () => {
-    for (const { font: fontName, input, glyphs, ranges } of [...firaCases, ...iosevkaCases, ...monoidCases, ...ubuntuCases]) {
-      it(`${fontName}: '${input}'`, () => {
-        const font = loadFont(fontName);
-        const result = font.findLigatures(input);
-        assert.deepEqual(result.outputGlyphs, glyphs);
-        assert.deepEqual(result.contextRanges, ranges);
-      });
-    }
-  });
-
-  describe('findLigatureRanges', () => {
-    for (const { font: fontName, input, ranges } of [...firaCases, ...iosevkaCases, ...monoidCases, ...ubuntuCases]) {
-      it(`${fontName}: '${input}'`, () => {
-        const font = loadFont(fontName);
-        const result = font.findLigatureRanges(input);
-        assert.deepEqual(result, ranges);
-      });
-    }
-  });
-
-  describe('caching', () => {
-    it('findLigatures caches successive calls correctly', () => {
-      const fontPath = fontPaths['Fira Code'];
-      const buffer = fs.readFileSync(fontPath);
-      const font = loadBuffer(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength), { cacheSize: 100 });
-      const result1 = font.findLigatures('in --> out');
-      const result2 = font.findLigatures('in --> out');
-      assert.deepEqual(result1, result2);
-    });
-
-    it('findLigatureRanges caches successive calls correctly', () => {
-      const fontPath = fontPaths['Fira Code'];
-      const buffer = fs.readFileSync(fontPath);
-      const font = loadBuffer(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength), { cacheSize: 100 });
-      const result1 = font.findLigatureRanges('in --> out');
-      const result2 = font.findLigatureRanges('in --> out');
-      assert.deepEqual(result1, result2);
-    });
-
-    it('caches calls to findLigatures after findLigatureRanges correctly', () => {
-      const fontPath = fontPaths['Fira Code'];
-      const buffer = fs.readFileSync(fontPath);
-
-      const uncached = loadBuffer(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength));
-      const uncachedResult1 = uncached.findLigatureRanges('in --> out');
-      const uncachedResult2 = uncached.findLigatures('in --> out');
-
-      const font = loadBuffer(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength), { cacheSize: 100 });
-      const result1 = font.findLigatureRanges('in --> out');
-      const result2 = font.findLigatures('in --> out');
-
-      assert.deepEqual(result1, uncachedResult1);
-      assert.deepEqual(result2, uncachedResult2);
-      assert.deepEqual(result1, result2.contextRanges);
-    });
-
-    it('caches calls to findLigatureRanges after findLigatures correctly', () => {
-      const fontPath = fontPaths['Fira Code'];
-      const buffer = fs.readFileSync(fontPath);
-
-      const uncached = loadBuffer(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength));
-      const uncachedResult1 = uncached.findLigatures('in --> out');
-      const uncachedResult2 = uncached.findLigatureRanges('in --> out');
-
-      const font = loadBuffer(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength), { cacheSize: 100 });
-      const result1 = font.findLigatures('in --> out');
-      const result2 = font.findLigatureRanges('in --> out');
-
-      assert.deepEqual(result1, uncachedResult1);
-      assert.deepEqual(result2, uncachedResult2);
-      assert.deepEqual(result1.contextRanges, result2);
-    });
-  });
-});
@@ -1,262 +0,0 @@
-import * as opentype from 'opentype.js';
-import { LRUCache } from 'lru-cache';
-
-import { IFont, ILigatureData, IFlattenedLookupTree, ILookupTree, IOptions } from './types';
-import mergeTrees from './merge';
-import walkTree from './walk';
-import mergeRange from './mergeRange';
-
-import buildTreeGsubType6Format1 from './processors/6-1';
-import buildTreeGsubType6Format2 from './processors/6-2';
-import buildTreeGsubType6Format3 from './processors/6-3';
-import buildTreeGsubType8Format1 from './processors/8-1';
-import flatten from './flatten';
-
-class FontImpl implements IFont {
-  private _font: opentype.Font;
-  private _lookupTrees: { tree: IFlattenedLookupTree, processForward: boolean }[] = [];
-  private _glyphLookups: { [glyphId: string]: number[] } = {};
-  private _cache?: LRUCache<string, ILigatureData | [number, number][]>;
-
-  constructor(font: opentype.Font, options: Required<IOptions>) {
-    this._font = font;
-
-    if (options.cacheSize > 0) {
-      this._cache = new LRUCache({
-        maxSize: options.cacheSize,
-        sizeCalculation: ((val: ILigatureData | [number, number][], key: string) => key.length) as any
-      });
-    }
-
-    const caltFeatures = this._font.tables.gsub && this._font.tables.gsub.features.filter((f: { tag: string }) => f.tag === 'calt') || [];
-    const lookupIndices: number[] = caltFeatures
-      .reduce((acc: number[], val: { feature: { lookupListIndexes: number[] } }) => [...acc, ...val.feature.lookupListIndexes], []);
-
-    const allLookups = this._font.tables.gsub && this._font.tables.gsub.lookups || [];
-    const lookupGroups = allLookups.filter((l: unknown, i: number) => lookupIndices.some(idx => idx === i));
-
-    for (const [index, lookup] of lookupGroups.entries()) {
-      const trees: ILookupTree[] = [];
-      switch (lookup.lookupType) {
-        case 6:
-          for (const [index, table] of lookup.subtables.entries()) {
-            switch (table.substFormat) {
-              case 1:
-                trees.push(buildTreeGsubType6Format1(table, allLookups, index));
-                break;
-              case 2:
-                trees.push(buildTreeGsubType6Format2(table, allLookups, index));
-                break;
-              case 3:
-                trees.push(buildTreeGsubType6Format3(table, allLookups, index));
-                break;
-            }
-          }
-          break;
-        case 8:
-          for (const [index, table] of lookup.subtables.entries()) {
-            trees.push(buildTreeGsubType8Format1(table, index));
-          }
-          break;
-      }
-
-      const tree = flatten(mergeTrees(trees));
-
-      this._lookupTrees.push({
-        tree,
-        processForward: lookup.lookupType !== 8
-      });
-
-      for (const glyphId of Object.keys(tree)) {
-        if (!this._glyphLookups[glyphId]) {
-          this._glyphLookups[glyphId] = [];
-        }
-
-        this._glyphLookups[glyphId].push(index);
-      }
-    }
-  }
-
-  public findLigatures(text: string): ILigatureData {
-    const cached = this._cache && this._cache.get(text);
-    if (cached && !Array.isArray(cached)) {
-      return cached;
-    }
-
-    const glyphIds: number[] = [];
-    for (const char of text) {
-      glyphIds.push(this._font.charToGlyphIndex(char));
-    }
-
-    // If there are no lookup groups, there's no point looking for
-    // replacements. This gives us a minor performance boost for fonts with
-    // no ligatures
-    if (this._lookupTrees.length === 0) {
-      return {
-        inputGlyphs: glyphIds,
-        outputGlyphs: glyphIds,
-        contextRanges: []
-      };
-    }
-
-    const result = this._findInternal(glyphIds.slice());
-    const finalResult: ILigatureData = {
-      inputGlyphs: glyphIds,
-      outputGlyphs: result.sequence,
-      contextRanges: result.ranges
-    };
-    if (this._cache) {
-      this._cache.set(text, finalResult);
-    }
-
-    return finalResult;
-  }
-
-  public findLigatureRanges(text: string): [number, number][] {
-    // Short circuit the process if there are no possible ligatures in the
-    // font
-    if (this._lookupTrees.length === 0) {
-      return [];
-    }
-
-    const cached = this._cache && this._cache.get(text);
-    if (cached) {
-      return Array.isArray(cached) ? cached : cached.contextRanges;
-    }
-
-    const glyphIds: number[] = [];
-    for (const char of text) {
-      glyphIds.push(this._font.charToGlyphIndex(char));
-    }
-
-    const result = this._findInternal(glyphIds);
-    if (this._cache) {
-      this._cache.set(text, result.ranges);
-    }
-
-    return result.ranges;
-  }
-
-  private _findInternal(sequence: number[]): { sequence: number[], ranges: [number, number][] } {
-    const ranges: [number, number][] = [];
-
-    let nextLookup = this._getNextLookup(sequence, 0);
-    while (nextLookup.index !== null) {
-      const lookup = this._lookupTrees[nextLookup.index];
-      if (lookup.processForward) {
-        let lastGlyphIndex = nextLookup.last;
-        for (let i = nextLookup.first; i < lastGlyphIndex; i++) {
-          const result = walkTree(lookup.tree, sequence, i, i);
-          if (result) {
-            for (let j = 0; j < result.substitutions.length; j++) {
-              const sub = result.substitutions[j];
-              if (sub !== null) {
-                sequence[i + j] = sub;
-              }
-            }
-
-            mergeRange(
-              ranges,
-              result.contextRange[0] + i,
-              result.contextRange[1] + i
-            );
-
-            // Substitutions can end up extending the search range
-            if (i + result.length >= lastGlyphIndex) {
-              lastGlyphIndex = i + result.length + 1;
-            }
-
-            i += result.length - 1;
-          }
-        }
-      } else {
-        // We don't need to do the lastGlyphIndex tracking here because
-        // reverse processing isn't allowed to replace more than one
-        // character at a time.
-        for (let i = nextLookup.last - 1; i >= nextLookup.first; i--) {
-          const result = walkTree(lookup.tree, sequence, i, i);
-          if (result) {
-            for (let j = 0; j < result.substitutions.length; j++) {
-              const sub = result.substitutions[j];
-              if (sub !== null) {
-                sequence[i + j] = sub;
-              }
-            }
-
-            mergeRange(
-              ranges,
-              result.contextRange[0] + i,
-              result.contextRange[1] + i
-            );
-
-            i -= result.length - 1;
-          }
-        }
-      }
-
-      nextLookup = this._getNextLookup(sequence, nextLookup.index + 1);
-    }
-
-    return { sequence, ranges };
-  }
-
-  /**
-   * Returns the lookup and glyph range for the first lookup that might
-   * contain a match.
-   *
-   * @param sequence Input glyph sequence
-   * @param start The first input to try
-   */
-  private _getNextLookup(sequence: number[], start: number): { index: number | null, first: number, last: number } {
-    const result: { index: number | null, first: number, last: number } = {
-      index: null,
-      first: Infinity,
-      last: -1
-    };
-
-    // Loop through each glyph and find the first valid lookup for it
-    for (let i = 0; i < sequence.length; i++) {
-      const lookups = this._glyphLookups[sequence[i]];
-      if (!lookups) {
-        continue;
-      }
-
-      for (let j = 0; j < lookups.length; j++) {
-        const lookupIndex = lookups[j];
-        if (lookupIndex >= start) {
-          // Update the lookup information if it's the one we're
-          // storing or earlier than it.
-          if (result.index === null || lookupIndex <= result.index) {
-            result.index = lookupIndex;
-
-            if (result.first > i) {
-              result.first = i;
-            }
-
-            result.last = i + 1;
-          }
-
-          break;
-        }
-      }
-    }
-
-    return result;
-  }
-}
-
-/**
- * Load the font from it's binary data. The returned value can be used to find
- * ligatures for the font.
- *
- * @param buffer ArrayBuffer of the font to load
- */
-export function loadBuffer(buffer: ArrayBuffer, options?: IOptions): IFont {
-  const font = opentype.parse(buffer);
-  return new FontImpl(font, {
-    cacheSize: 0,
-    ...options
-  });
-}
-
-export { IFont as Font, ILigatureData as LigatureData, IOptions as Options };
@@ -1,225 +0,0 @@
-/**
- * Copyright (c) 2018 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { assert } from 'chai';
-import mergeTrees from './merge';
-
-interface ILookupResult {
-  contextRange: [number, number];
-  index: number;
-  subIndex: number;
-  length: number;
-  substitutions: number[];
-}
-
-function lookup(substitutionGlyph: number, index?: number, subIndex?: number): ILookupResult {
-  return {
-    contextRange: [0, 1],
-    index: index || 0,
-    subIndex: subIndex || 0,
-    length: 1,
-    substitutions: [substitutionGlyph]
-  };
-}
-
-describe('addon-ligatures - merge', () => {
-  describe('mergeTrees', () => {
-    it('combines disjoint trees', () => {
-      const result = mergeTrees([
-        {
-          individual: {
-            '1': { lookup: lookup(1) }
-          },
-          range: []
-        },
-        {
-          individual: {},
-          range: [{
-            entry: { lookup: lookup(2) },
-            range: [2, 4]
-          }]
-        },
-        {
-          individual: {
-            '5': { lookup: lookup(3) }
-          },
-          range: []
-        },
-        {
-          individual: {},
-          range: [{
-            entry: { lookup: lookup(4) },
-            range: [8, 10]
-          }]
-        }
-      ]);
-
-      assert.deepEqual(result, {
-        individual: {
-          '1': { lookup: lookup(1) },
-          '5': { lookup: lookup(3) }
-        },
-        range: [{
-          entry: { lookup: lookup(2) },
-          range: [2, 4]
-        }, {
-          entry: { lookup: lookup(4) },
-          range: [8, 10]
-        }]
-      });
-    });
-
-    it('merges matching individual glyphs', () => {
-      const result = mergeTrees([
-        {
-          individual: {
-            '1': { lookup: lookup(1, 1) }
-          },
-          range: []
-        },
-        {
-          individual: {
-            '1': { lookup: lookup(2, 0) }
-          },
-          range: []
-        },
-        {
-          individual: {
-            '1': { lookup: lookup(3, 2) }
-          },
-          range: []
-        }
-      ]);
-
-      assert.deepEqual(result, {
-        individual: {
-          '1': { lookup: lookup(2, 0) }
-        },
-        range: []
-      });
-    });
-
-    it('merges range glyphs overlapping individual glyphs', () => {
-      const result = mergeTrees([
-        {
-          individual: {
-            '1': { lookup: lookup(1, 0) }
-          },
-          range: []
-        },
-        {
-          individual: {},
-          range: [{
-            entry: { lookup: lookup(2, 1) },
-            range: [0, 4]
-          }]
-        }
-      ]);
-
-      assert.deepEqual(result, {
-        individual: {
-          '0': { lookup: lookup(2, 1) },
-          '1': { lookup: lookup(1, 0) }
-        },
-        range: [{
-          entry: { lookup: lookup(2, 1) },
-          range: [2, 4]
-        }]
-      });
-    });
-
-    it('merges individual glyphs overlapping range glyphs', () => {
-      const result = mergeTrees([
-        {
-          individual: {},
-          range: [{
-            entry: { lookup: lookup(2, 1) },
-            range: [0, 4]
-          }]
-        },
-        {
-          individual: {
-            '1': { lookup: lookup(1, 0) }
-          },
-          range: []
-        }
-      ]);
-
-      assert.deepEqual(result, {
-        individual: {
-          '0': { lookup: lookup(2, 1) },
-          '1': { lookup: lookup(1, 0) }
-        },
-        range: [{
-          entry: { lookup: lookup(2, 1) },
-          range: [2, 4]
-        }]
-      });
-    });
-
-    it('merges multiple overlapping ranges', () => {
-      const result = mergeTrees([
-        {
-          individual: {},
-          range: [{
-            entry: { lookup: lookup(1, 2) },
-            range: [0, 3]
-          }, {
-            entry: { lookup: lookup(2, 1) },
-            range: [6, 12]
-          }, {
-            entry: { lookup: lookup(5, 3) },
-            range: [15, 20]
-          }, {
-            entry: { lookup: lookup(7, 4) },
-            range: [20, 22]
-          }]
-        },
-        {
-          individual: {},
-          range: [{
-            entry: { lookup: lookup(3, 0) },
-            range: [2, 8]
-          }, {
-            entry: { lookup: lookup(4, 0) },
-            range: [10, 13]
-          }, {
-            entry: { lookup: lookup(6, 0) },
-            range: [16, 21]
-          }]
-        }
-      ]);
-
-      assert.deepEqual(result, {
-        individual: {
-          '2': { lookup: lookup(3, 0) },
-          '12': { lookup: lookup(4, 0) },
-          '15': { lookup: lookup(5, 3) },
-          '20': { lookup: lookup(6, 0) },
-          '21': { lookup: lookup(7, 4) }
-        },
-        range: [{
-          entry: { lookup: lookup(1, 2) },
-          range: [0, 2]
-        }, {
-          entry: { lookup: lookup(3, 0) },
-          range: [6, 8]
-        }, {
-          entry: { lookup: lookup(3, 0) },
-          range: [3, 6]
-        }, {
-          entry: { lookup: lookup(2, 1) },
-          range: [8, 10]
-        }, {
-          entry: { lookup: lookup(4, 0) },
-          range: [10, 12]
-        }, {
-          entry: { lookup: lookup(6, 0) },
-          range: [16, 20]
-        }]
-      });
-    });
-  });
-});
@@ -1,393 +0,0 @@
-import { ILookupTree, ILookupTreeEntry } from './types';
-
-/**
- * Merges the provided trees into a single lookup tree. When conflicting lookups
- * are encountered between two trees, the one with the lower index, then the
- * lower subindex is chosen.
- *
- * @param trees Array of trees to merge. Entries in earlier trees are favored
- *              over those in later trees when there is a choice.
- */
-export default function mergeTrees(trees: ILookupTree[]): ILookupTree {
-  const result: ILookupTree = {
-    individual: {},
-    range: []
-  };
-
-  const mergedEntries = new WeakMap<ILookupTreeEntry, Set<ILookupTreeEntry>>();
-  for (const tree of trees) {
-    mergeSubtree(result, tree, mergedEntries);
-  }
-
-  return result;
-}
-
-/**
- * Recursively merges the data for the mergeTree into the mainTree.
- *
- * @param mainTree The tree where the values should be merged
- * @param mergeTree The tree to be merged into the mainTree
- * @param mergedEntries WeakMap to track already merged entry pairs
- */
-function mergeSubtree(mainTree: ILookupTree, mergeTree: ILookupTree, mergedEntries: WeakMap<ILookupTreeEntry, Set<ILookupTreeEntry>>): void {
-  // Need to fix this recursively (and handle lookups)
-  for (const [glyphId, value] of Object.entries(mergeTree.individual)) {
-    // The main tree is guaranteed to have no overlaps between the
-    // individual and range values, so if we match an invididual, there
-    // must not be a range
-    if (mainTree.individual[glyphId]) {
-      mergeTreeEntry(mainTree.individual[glyphId], value, mergedEntries);
-    } else {
-      let matched = false;
-      for (const [index, { range, entry }] of mainTree.range.entries()) {
-        const overlap = getIndividualOverlap(Number(glyphId), range);
-
-        // Don't overlap
-        if (overlap.both === null) {
-          continue;
-        }
-
-        matched = true;
-
-        // If they overlap, we have to split the range and then
-        // merge the overlap
-        mainTree.individual[glyphId] = value;
-        mergeTreeEntry(mainTree.individual[glyphId], cloneEntry(entry), mergedEntries);
-
-        // When there's an overlap, we also have to fix up the range
-        // that we had already processed
-        mainTree.range.splice(index, 1);
-        for (const glyph of overlap.second) {
-          if (Array.isArray(glyph)) {
-            mainTree.range.push({
-              range: glyph,
-              entry: cloneEntry(entry)
-            });
-          } else {
-            mainTree.individual[glyph] = cloneEntry(entry);
-          }
-        }
-      }
-
-      if (!matched) {
-        mainTree.individual[glyphId] = value;
-      }
-    }
-  }
-
-  for (const { range, entry } of mergeTree.range) {
-    // Ranges are more complicated, because they can overlap with
-    // multiple things, individual and range alike. We start by
-    // eliminating ranges that are already present in another range
-    let remainingRanges: (number | [number, number])[] = [range];
-
-    for (let index = 0; index < mainTree.range.length; index++) {
-      const { range, entry: resultEntry } = mainTree.range[index];
-      for (const [remainingIndex, remainingRange] of remainingRanges.entries()) {
-        if (Array.isArray(remainingRange)) {
-          const overlap = getRangeOverlap(remainingRange, range);
-          if (overlap.both === null) {
-            continue;
-          }
-
-          mainTree.range.splice(index, 1);
-          index--;
-
-          const entryToMerge: ILookupTreeEntry = cloneEntry(resultEntry);
-          if (Array.isArray(overlap.both)) {
-            mainTree.range.push({
-              range: overlap.both,
-              entry: entryToMerge
-            });
-          } else {
-            mainTree.individual[overlap.both] = entryToMerge;
-          }
-
-          mergeTreeEntry(entryToMerge, cloneEntry(entry), mergedEntries);
-
-          for (const second of overlap.second) {
-            if (Array.isArray(second)) {
-              mainTree.range.push({
-                range: second,
-                entry: cloneEntry(resultEntry)
-              });
-            } else {
-              mainTree.individual[second] = cloneEntry(resultEntry);
-            }
-          }
-
-          remainingRanges = overlap.first;
-        } else {
-          const overlap = getIndividualOverlap(remainingRange, range);
-          if (overlap.both === null) {
-            continue;
-          }
-
-          // If they overlap, we have to split the range and then
-          // merge the overlap
-          mainTree.individual[remainingRange] = cloneEntry(entry);
-          mergeTreeEntry(mainTree.individual[remainingRange], cloneEntry(resultEntry), mergedEntries);
-
-          // When there's an overlap, we also have to fix up the range
-          // that we had already processed
-          mainTree.range.splice(index, 1);
-          index--;
-
-          for (const glyph of overlap.second) {
-            if (Array.isArray(glyph)) {
-              mainTree.range.push({
-                range: glyph,
-                entry: cloneEntry(resultEntry)
-              });
-            } else {
-              mainTree.individual[glyph] = cloneEntry(resultEntry);
-            }
-          }
-
-          remainingRanges.splice(remainingIndex, 1, ...overlap.first);
-          break;
-        }
-      }
-    }
-
-    // Next, we run the same against any individual glyphs
-    for (const glyphId of Object.keys(mainTree.individual)) {
-      for (const [remainingIndex, remainingRange] of remainingRanges.entries()) {
-        if (Array.isArray(remainingRange)) {
-          const overlap = getIndividualOverlap(Number(glyphId), remainingRange);
-          if (overlap.both === null) {
-            continue;
-          }
-
-          // If they overlap, we have to merge the overlap
-          mergeTreeEntry(mainTree.individual[glyphId], cloneEntry(entry), mergedEntries);
-
-          // Update the remaining ranges
-          remainingRanges.splice(remainingIndex, 1, ...overlap.second);
-          break;
-        } else {
-          if (Number(glyphId) === remainingRange) {
-            mergeTreeEntry(mainTree.individual[glyphId], cloneEntry(entry), mergedEntries);
-            break;
-          }
-        }
-      }
-    }
-
-    // Any remaining ranges should just be added directly
-    for (const remainingRange of remainingRanges) {
-      if (Array.isArray(remainingRange)) {
-        mainTree.range.push({
-          range: remainingRange,
-          entry: cloneEntry(entry)
-        });
-      } else {
-        mainTree.individual[remainingRange] = cloneEntry(entry);
-      }
-    }
-  }
-}
-
-/**
- * Recursively merges the entry forr the mergeTree into the mainTree
- *
- * @param mainTree The entry where the values should be merged
- * @param mergeTree The entry to merge into the mainTree
- * @param mergedEntries WeakMap to track already merged entry pairs
- */
-function mergeTreeEntry(mainTree: ILookupTreeEntry, mergeTree: ILookupTreeEntry, mergedEntries: WeakMap<ILookupTreeEntry, Set<ILookupTreeEntry>>): void {
-  // Check if we've already merged this pair
-  let mergedSet = mergedEntries.get(mainTree);
-  if (mergedSet?.has(mergeTree)) {
-    return;
-  }
-  if (!mergedSet) {
-    mergedSet = new Set();
-    mergedEntries.set(mainTree, mergedSet);
-  }
-  mergedSet.add(mergeTree);
-
-  if (
-    mergeTree.lookup && (
-      !mainTree.lookup ||
-      mainTree.lookup.index > mergeTree.lookup.index ||
-      (mainTree.lookup.index === mergeTree.lookup.index && mainTree.lookup.subIndex > mergeTree.lookup.subIndex)
-    )
-  ) {
-    mainTree.lookup = mergeTree.lookup;
-  }
-
-  if (mergeTree.forward) {
-    if (!mainTree.forward) {
-      mainTree.forward = mergeTree.forward;
-    } else {
-      mergeSubtree(mainTree.forward, mergeTree.forward, mergedEntries);
-    }
-  }
-
-  if (mergeTree.reverse) {
-    if (!mainTree.reverse) {
-      mainTree.reverse = mergeTree.reverse;
-    } else {
-      mergeSubtree(mainTree.reverse, mergeTree.reverse, mergedEntries);
-    }
-  }
-}
-
-interface IOverlap {
-  first: (number | [number, number])[];
-  second: (number | [number, number])[];
-  both: number | [number, number] | null;
-}
-
-/**
- * Determines the overlap (if any) between two ranges. Returns the distinct
- * ranges for each range and the overlap (if any).
- *
- * @param first First range
- * @param second Second range
- */
-function getRangeOverlap(first: [number, number], second: [number, number]): IOverlap {
-  const result: IOverlap = {
-    first: [],
-    second: [],
-    both: null
-  };
-
-  // Both
-  if (first[0] < second[1] && second[0] < first[1]) {
-    const start = Math.max(first[0], second[0]);
-    const end = Math.min(first[1], second[1]);
-    result.both = rangeOrIndividual(start, end);
-  }
-
-  // Before
-  if (first[0] < second[0]) {
-    const start = first[0];
-    const end = Math.min(second[0], first[1]);
-    result.first.push(rangeOrIndividual(start, end));
-  } else if (second[0] < first[0]) {
-    const start = second[0];
-    const end = Math.min(second[1], first[0]);
-    result.second.push(rangeOrIndividual(start, end));
-  }
-
-  // After
-  if (first[1] > second[1]) {
-    const start = Math.max(first[0], second[1]);
-    const end = first[1];
-    result.first.push(rangeOrIndividual(start, end));
-  } else if (second[1] > first[1]) {
-    const start = Math.max(first[1], second[0]);
-    const end = second[1];
-    result.second.push(rangeOrIndividual(start, end));
-  }
-
-  return result;
-}
-
-/**
- * Determines the overlap (if any) between the individual glyph and the range
- * provided. Returns the glyphs and/or ranges that are unique to each provided
- * and the overlap (if any).
- *
- * @param first Individual glyph
- * @param second Range
- */
-function getIndividualOverlap(first: number, second: [number, number]): IOverlap {
-  // Disjoint
-  if (first < second[0] || first > second[1]) {
-    return {
-      first: [first],
-      second: [second],
-      both: null
-    };
-  }
-
-  const result: IOverlap = {
-    first: [],
-    second: [],
-    both: first
-  };
-
-  if (second[0] < first) {
-    result.second.push(rangeOrIndividual(second[0], first));
-  }
-
-  if (second[1] > first) {
-    result.second.push(rangeOrIndividual(first + 1, second[1]));
-  }
-
-  return result;
-}
-
-/**
- * Returns an individual glyph if the range is of size one or a range if it is
- * larger.
- *
- * @param start Beginning of the range (inclusive)
- * @param end End of the range (exclusive)
- */
-function rangeOrIndividual(start: number, end: number): number | [number, number] {
-  if (end - start === 1) {
-    return start;
-  }
-  return [start, end];
-
-}
-
-/**
- * Clones an individual lookup tree entry.
- *
- * @param entry Lookup tree entry to clone
- * @param visited Map to track already cloned entries (prevents infinite loops)
- */
-function cloneEntry(entry: ILookupTreeEntry, visited: Map<ILookupTreeEntry, ILookupTreeEntry> = new Map()): ILookupTreeEntry {
-  if (visited.has(entry)) {
-    return visited.get(entry)!;
-  }
-
-  const result: ILookupTreeEntry = {};
-  visited.set(entry, result);
-
-  if (entry.forward) {
-    result.forward = cloneTree(entry.forward, visited);
-  }
-
-  if (entry.reverse) {
-    result.reverse = cloneTree(entry.reverse, visited);
-  }
-
-  if (entry.lookup) {
-    result.lookup = {
-      contextRange: entry.lookup.contextRange.slice() as [number, number],
-      index: entry.lookup.index,
-      length: entry.lookup.length,
-      subIndex: entry.lookup.subIndex,
-      substitutions: entry.lookup.substitutions.slice()
-    };
-  }
-
-  return result;
-}
-
-/**
- * Clones a lookup tree.
- *
- * @param tree Lookup tree to clone
- * @param visited Map to track already cloned entries (prevents infinite loops)
- */
-function cloneTree(tree: ILookupTree, visited: Map<ILookupTreeEntry, ILookupTreeEntry> = new Map()): ILookupTree {
-  const individual: { [glyphId: string]: ILookupTreeEntry } = {};
-  for (const [glyphId, entry] of Object.entries(tree.individual)) {
-    individual[glyphId] = cloneEntry(entry, visited);
-  }
-
-  return {
-    individual,
-    range: tree.range.map(({ range, entry }) => ({
-      range: range.slice() as [number, number],
-      entry: cloneEntry(entry, visited)
-    }))
-  };
-}
@@ -1,49 +0,0 @@
-/**
- * Copyright (c) 2018 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { assert } from 'chai';
-import mergeRange from './mergeRange';
-
-describe('addon-ligatures - mergeRange', () => {
-  it('inserts a new range before the existing ones', () => {
-    const result = mergeRange([[1, 2], [2, 3]], 0, 1);
-    assert.deepEqual(result, [[0, 1], [1, 2], [2, 3]]);
-  });
-
-  it('inserts in between two ranges', () => {
-    const result = mergeRange([[0, 2], [4, 6]], 2, 4);
-    assert.deepEqual(result, [[0, 2], [2, 4], [4, 6]]);
-  });
-
-  it('inserts after the last range', () => {
-    const result = mergeRange([[0, 2], [4, 6]], 6, 8);
-    assert.deepEqual(result, [[0, 2], [4, 6], [6, 8]]);
-  });
-
-  it('extends the beginning of a range', () => {
-    const result = mergeRange([[0, 2], [4, 6]], 3, 5);
-    assert.deepEqual(result, [[0, 2], [3, 6]]);
-  });
-
-  it('extends the end of a range', () => {
-    const result = mergeRange([[0, 2], [4, 6]], 1, 4);
-    assert.deepEqual(result, [[0, 4], [4, 6]]);
-  });
-
-  it('extends the last range', () => {
-    const result = mergeRange([[0, 2], [4, 6]], 5, 7);
-    assert.deepEqual(result, [[0, 2], [4, 7]]);
-  });
-
-  it('connects two ranges', () => {
-    const result = mergeRange([[0, 2], [4, 6]], 1, 5);
-    assert.deepEqual(result, [[0, 6]]);
-  });
-
-  it('connects more than two ranges', () => {
-    const result = mergeRange([[0, 2], [4, 6], [8, 10], [12, 14]], 1, 10);
-    assert.deepEqual(result, [[0, 10], [12, 14]]);
-  });
-});
@@ -1,65 +0,0 @@
-/**
- * Merges the range defined by the provided start and end into the list of
- * existing ranges. The merge is done in place on the existing range for
- * performance and is also returned.
- *
- * @param ranges Existing range list
- * @param newRangeStart Start position of the range to merge, inclusive
- * @param newRangeEnd End position of range to merge, exclusive
- */
-export default function mergeRange(ranges: [number, number][], newRangeStart: number, newRangeEnd: number): [number, number][] {
-  let inRange = false;
-  for (let i = 0; i < ranges.length; i++) {
-    const range = ranges[i];
-    if (!inRange) {
-      if (newRangeEnd <= range[0]) {
-        // Case 1: New range is before the search range
-        ranges.splice(i, 0, [newRangeStart, newRangeEnd]);
-        return ranges;
-      }
-      if (newRangeEnd <= range[1]) {
-        // Case 2: New range is either wholly contained within the
-        // search range or overlaps with the front of it
-        range[0] = Math.min(newRangeStart, range[0]);
-        return ranges;
-      }
-      if (newRangeStart < range[1]) {
-        // Case 3: New range either wholly contains the search range
-        // or overlaps with the end of it
-        range[0] = Math.min(newRangeStart, range[0]);
-        inRange = true;
-      } else {
-        // Case 4: New range starts after the search range
-        continue;
-      }
-    } else {
-      if (newRangeEnd <= range[0]) {
-        // Case 5: New range extends from previous range but doesn't
-        // reach the current one
-        ranges[i - 1][1] = newRangeEnd;
-        return ranges;
-      }
-      if (newRangeEnd <= range[1]) {
-        // Case 6: New range extends from prvious range into the
-        // current range
-        ranges[i - 1][1] = Math.max(newRangeEnd, range[1]);
-        ranges.splice(i, 1);
-        return ranges;
-      }
-      // Case 7: New range extends from previous range past the
-      // end of the current range
-      ranges.splice(i, 1);
-      i--;
-    }
-  }
-
-  if (inRange) {
-    // Case 8: New range extends past the last existing range
-    ranges[ranges.length - 1][1] = newRangeEnd;
-  } else {
-    // Case 9: New range starts after the last existing range
-    ranges.push([newRangeStart, newRangeEnd]);
-  }
-
-  return ranges;
-}
@@ -1,82 +0,0 @@
-import { ChainingContextualSubstitutionTable, Lookup } from '../tables';
-import { ILookupTree } from '../types';
-
-import { listGlyphsByIndex } from './coverage';
-import { processInputPosition, processLookaheadPosition, processBacktrackPosition, getInputTree, IEntryMeta } from './helper';
-
-/**
- * Build lookup tree for GSUB lookup table 6, format 1.
- * https://docs.microsoft.com/en-us/typography/opentype/spec/gsub#61-chaining-context-substitution-format-1-simple-glyph-contexts
- *
- * @param table JSON representation of the table
- * @param lookups List of lookup tables
- * @param tableIndex Index of this table in the overall lookup
- */
-export default function buildTree(table: ChainingContextualSubstitutionTable.IFormat1, lookups: Lookup[], tableIndex: number): ILookupTree {
-  const result: ILookupTree = {
-    individual: {},
-    range: []
-  };
-
-  const firstGlyphs = listGlyphsByIndex(table.coverage);
-
-  for (const { glyphId, index } of firstGlyphs) {
-    const chainRuleSet = table.chainRuleSets[index];
-
-    // If the chain rule set is null there's nothing to do with this table.
-    if (!chainRuleSet) {
-      continue;
-    }
-
-    for (const [subIndex, subTable] of chainRuleSet.entries()) {
-      let currentEntries: IEntryMeta[] = getInputTree(
-        result,
-        subTable.lookupRecords,
-        lookups,
-        0,
-        glyphId
-      ).map(({ entry, substitution }) => ({ entry, substitutions: [substitution] }));
-
-      // We walk forward, then backward
-      for (const [index, glyph] of subTable.input.entries()) {
-        currentEntries = processInputPosition(
-          [glyph],
-          index + 1,
-          currentEntries,
-          subTable.lookupRecords,
-          lookups
-        );
-      }
-
-      for (const glyph of subTable.lookahead) {
-        currentEntries = processLookaheadPosition(
-          [glyph],
-          currentEntries
-        );
-      }
-
-      for (const glyph of subTable.backtrack) {
-        currentEntries = processBacktrackPosition(
-          [glyph],
-          currentEntries
-        );
-      }
-
-      // When we get to the end, insert the lookup information
-      for (const { entry, substitutions } of currentEntries) {
-        entry.lookup = {
-          substitutions,
-          length: subTable.input.length + 1,
-          index: tableIndex,
-          subIndex,
-          contextRange: [
-            -1 * subTable.backtrack.length,
-            1 + subTable.input.length + subTable.lookahead.length
-          ]
-        };
-      }
-    }
-  }
-
-  return result;
-}
@@ -1,96 +0,0 @@
-import { ChainingContextualSubstitutionTable, Lookup } from '../tables';
-import { ILookupTree } from '../types';
-import mergeTrees from '../merge';
-
-import { listGlyphsByIndex } from './coverage';
-import getGlyphClass, { listClassGlyphs } from './classDef';
-import { processInputPosition, processLookaheadPosition, processBacktrackPosition, getInputTree, IEntryMeta } from './helper';
-
-/**
- * Build lookup tree for GSUB lookup table 6, format 2.
- * https://docs.microsoft.com/en-us/typography/opentype/spec/gsub#62-chaining-context-substitution-format-2-class-based-glyph-contexts
- *
- * @param table JSON representation of the table
- * @param lookups List of lookup tables
- * @param tableIndex Index of this table in the overall lookup
- */
-export default function buildTree(table: ChainingContextualSubstitutionTable.IFormat2, lookups: Lookup[], tableIndex: number): ILookupTree {
-  const results: ILookupTree[] = [];
-
-  const firstGlyphs = listGlyphsByIndex(table.coverage);
-
-  for (const { glyphId } of firstGlyphs) {
-    const firstInputClass = getGlyphClass(table.inputClassDef, glyphId);
-    for (const [glyphId, inputClass] of firstInputClass.entries()) {
-      // istanbul ignore next - invalid font
-      if (inputClass === null) {
-        continue;
-      }
-
-      const classSet = table.chainClassSet[inputClass];
-
-      // If the class set is null there's nothing to do with this table.
-      if (!classSet) {
-        continue;
-      }
-
-      for (const [subIndex, subTable] of classSet.entries()) {
-        const result: ILookupTree = {
-          individual: {},
-          range: []
-        };
-
-        let currentEntries: IEntryMeta[] = getInputTree(
-          result,
-          subTable.lookupRecords,
-          lookups,
-          0,
-          glyphId
-        ).map(({ entry, substitution }) => ({ entry, substitutions: [substitution] }));
-
-        for (const [index, classNum] of subTable.input.entries()) {
-          currentEntries = processInputPosition(
-            listClassGlyphs(table.inputClassDef, classNum),
-            index + 1,
-            currentEntries,
-            subTable.lookupRecords,
-            lookups
-          );
-        }
-
-        for (const classNum of subTable.lookahead) {
-          currentEntries = processLookaheadPosition(
-            listClassGlyphs(table.lookaheadClassDef, classNum),
-            currentEntries
-          );
-        }
-
-        for (const classNum of subTable.backtrack) {
-          currentEntries = processBacktrackPosition(
-            listClassGlyphs(table.backtrackClassDef, classNum),
-            currentEntries
-          );
-        }
-
-        // When we get to the end, all of the entries we've accumulated
-        // should have a lookup defined
-        for (const { entry, substitutions } of currentEntries) {
-          entry.lookup = {
-            substitutions,
-            index: tableIndex,
-            subIndex,
-            length: subTable.input.length + 1,
-            contextRange: [
-              -1 * subTable.backtrack.length,
-              1 + subTable.input.length + subTable.lookahead.length
-            ]
-          };
-        }
-
-        results.push(result);
-      }
-    }
-  }
-
-  return mergeTrees(results);
-}
@@ -1,73 +0,0 @@
-import { ChainingContextualSubstitutionTable, Lookup } from '../tables';
-import { ILookupTree } from '../types';
-
-import { listGlyphsByIndex } from './coverage';
-import { processInputPosition, processLookaheadPosition, processBacktrackPosition, getInputTree, IEntryMeta } from './helper';
-
-/**
- * Build lookup tree for GSUB lookup table 6, format 3.
- * https://docs.microsoft.com/en-us/typography/opentype/spec/gsub#63-chaining-context-substitution-format-3-coverage-based-glyph-contexts
- *
- * @param table JSON representation of the table
- * @param lookups List of lookup tables
- * @param tableIndex Index of this table in the overall lookup
- */
-export default function buildTree(table: ChainingContextualSubstitutionTable.IFormat3, lookups: Lookup[], tableIndex: number): ILookupTree {
-  const result: ILookupTree = {
-    individual: {},
-    range: []
-  };
-
-  const firstGlyphs = listGlyphsByIndex(table.inputCoverage[0]);
-
-  for (const { glyphId } of firstGlyphs) {
-    let currentEntries: IEntryMeta[] = getInputTree(
-      result,
-      table.lookupRecords,
-      lookups,
-      0,
-      glyphId
-    ).map(({ entry, substitution }) => ({ entry, substitutions: [substitution] }));
-
-    for (const [index, coverage] of table.inputCoverage.slice(1).entries()) {
-      currentEntries = processInputPosition(
-        listGlyphsByIndex(coverage).map(glyph => glyph.glyphId),
-        index + 1,
-        currentEntries,
-        table.lookupRecords,
-        lookups
-      );
-    }
-
-    for (const coverage of table.lookaheadCoverage) {
-      currentEntries = processLookaheadPosition(
-        listGlyphsByIndex(coverage).map(glyph => glyph.glyphId),
-        currentEntries
-      );
-    }
-
-    for (const coverage of table.backtrackCoverage) {
-      currentEntries = processBacktrackPosition(
-        listGlyphsByIndex(coverage).map(glyph => glyph.glyphId),
-        currentEntries
-      );
-    }
-
-    // When we get to the end, all of the entries we've accumulated
-    // should have a lookup defined
-    for (const { entry, substitutions } of currentEntries) {
-      entry.lookup = {
-        substitutions,
-        index: tableIndex,
-        subIndex: 0,
-        length: table.inputCoverage.length,
-        contextRange: [
-          -1 * table.backtrackCoverage.length,
-          table.inputCoverage.length + table.lookaheadCoverage.length
-        ]
-      };
-    }
-  }
-
-  return result;
-}
@@ -1,69 +0,0 @@
-import { IReverseChainingContextualSingleSubstitutionTable } from '../tables';
-import { ILookupTree, ILookupTreeEntry } from '../types';
-
-import { listGlyphsByIndex } from './coverage';
-import { processLookaheadPosition, processBacktrackPosition, IEntryMeta } from './helper';
-
-/**
- * Build lookup tree for GSUB lookup table 8, format 1.
- * https://docs.microsoft.com/en-us/typography/opentype/spec/gsub#81-reverse-chaining-contextual-single-substitution-format-1-coverage-based-glyph-contexts
- *
- * @param table JSON representation of the table
- * @param tableIndex Index of this table in the overall lookup
- */
-export default function buildTree(table: IReverseChainingContextualSingleSubstitutionTable, tableIndex: number): ILookupTree {
-  const result: ILookupTree = {
-    individual: {},
-    range: []
-  };
-
-  const glyphs = listGlyphsByIndex(table.coverage);
-
-  for (const { glyphId, index } of glyphs) {
-    const initialEntry: ILookupTreeEntry = {};
-    if (Array.isArray(glyphId)) {
-      result.range.push({
-        entry: initialEntry,
-        range: glyphId
-      });
-    } else {
-      result.individual[glyphId] = initialEntry;
-    }
-
-    let currentEntries: IEntryMeta[] = [{
-      entry: initialEntry,
-      substitutions: [table.substitutes[index]]
-    }];
-
-    // We walk forward, then backward
-    for (const coverage of table.lookaheadCoverage) {
-      currentEntries = processLookaheadPosition(
-        listGlyphsByIndex(coverage).map(glyph => glyph.glyphId),
-        currentEntries
-      );
-    }
-
-    for (const coverage of table.backtrackCoverage) {
-      currentEntries = processBacktrackPosition(
-        listGlyphsByIndex(coverage).map(glyph => glyph.glyphId),
-        currentEntries
-      );
-    }
-
-    // When we get to the end, insert the lookup information
-    for (const { entry, substitutions } of currentEntries) {
-      entry.lookup = {
-        substitutions,
-        index: tableIndex,
-        subIndex: 0,
-        length: 1,
-        contextRange: [
-          -1 * table.backtrackCoverage.length,
-          1 + table.lookaheadCoverage.length
-        ]
-      };
-    }
-  }
-
-  return result;
-}
@@ -1,84 +0,0 @@
-import { ClassDefTable } from '../tables';
-
-/**
- * Get the number of the class to which the glyph belongs, or null if it doesn't
- * belong to any of them.
- *
- * @param table JSON representation of the class def table
- * @param glyphId Index of the glyph to look for
- */
-export default function getGlyphClass(table: ClassDefTable, glyphId: number | [number, number]): Map<number | [number, number], number | null> {
-  switch (table.format) {
-    // https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#class-definition-table-format-2
-    case 2:
-      if (Array.isArray(glyphId)) {
-        return getRangeGlyphClass(table, glyphId);
-      }
-      return new Map([[
-        glyphId,
-        getIndividualGlyphClass(table, glyphId)
-      ]]);
-    // https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#class-definition-table-format-1
-    default:
-      return new Map([[glyphId, null]]);
-  }
-}
-
-function getRangeGlyphClass(table: ClassDefTable.IFormat2, glyphId: [number, number]): Map<number | [number, number], number | null> {
-  const classStart: number = glyphId[0];
-  const currentClass: number | null = getIndividualGlyphClass(table, classStart);
-  let search: number = glyphId[0] + 1;
-
-  const result = new Map<[number, number] | number, number | null>();
-
-  while (search < glyphId[1]) {
-    const clazz = getIndividualGlyphClass(table, search);
-    if (clazz !== currentClass) {
-      if (search - classStart <= 1) {
-        result.set(classStart, currentClass);
-      } else {
-        result.set([classStart, search], currentClass);
-      }
-    }
-    search++;
-  }
-
-  if (search - classStart <= 1) {
-    result.set(classStart, currentClass);
-  } else {
-    result.set([classStart, search], currentClass);
-  }
-
-  return result;
-}
-
-function getIndividualGlyphClass(table: ClassDefTable.IFormat2, glyphId: number): number | null {
-  for (const range of table.ranges) {
-    if (range.start <= glyphId && range.end >= glyphId) {
-      return range.classId;
-    }
-  }
-
-  return null;
-}
-
-export function listClassGlyphs(table: ClassDefTable, index: number): (number | [number, number])[] {
-  switch (table.format) {
-    case 2:
-      const results: (number | [number, number])[] = [];
-      for (const range of table.ranges) {
-        if (range.classId !== index) {
-          continue;
-        }
-
-        if (range.end === range.start) {
-          results.push(range.start);
-        } else {
-          results.push([range.start, range.end + 1]);
-        }
-      }
-      return results;
-    default:
-      return [];
-  }
-}
@@ -1,43 +0,0 @@
-import { CoverageTable } from '../tables';
-
-/**
- * Get the index of the given glyph in the coverage table, or null if it is not
- * present in the table.
- *
- * @param table JSON representation of the coverage table
- * @param glyphId Index of the glyph to look for
- */
-export default function getCoverageGlyphIndex(table: CoverageTable, glyphId: number): number | null {
-  switch (table.format) {
-    // https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#coverage-format-1
-    case 1:
-      const index = table.glyphs.indexOf(glyphId);
-      return index !== -1
-        ? index
-        : null;
-    // https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#coverage-format-2
-    case 2:
-      const range = table.ranges
-        .find(range => range.start <= glyphId && range.end >= glyphId);
-      return range
-        ? range.index
-        : null;
-  }
-}
-
-export function listGlyphsByIndex(table: CoverageTable): { glyphId: number | [number, number], index: number }[] {
-  switch (table.format) {
-    case 1:
-      return table.glyphs.map((glyphId, index) => ({ glyphId, index }));
-    case 2:
-      const results: { glyphId: number | [number, number], index: number }[] = [];
-      for (const [index, range] of table.ranges.entries()) {
-        if (range.end === range.start) {
-          results.push({ glyphId: range.start, index });
-        } else {
-          results.push({ glyphId: [range.start, range.end + 1], index });
-        }
-      }
-      return results;
-  }
-}
@@ -1,183 +0,0 @@
-import { ILookupTreeEntry, ILookupTree } from '../types';
-import { ISubstitutionLookupRecord, Lookup } from '../tables';
-
-import { getIndividualSubstitutionGlyph, getRangeSubstitutionGlyphs } from './substitution';
-
-export interface IEntryMeta {
-  entry: ILookupTreeEntry;
-  substitutions: (number | null)[];
-}
-
-export function processInputPosition(
-  glyphs: (number | [number, number])[],
-  position: number,
-  currentEntries: IEntryMeta[],
-  lookupRecords: ISubstitutionLookupRecord[],
-  lookups: Lookup[]
-): IEntryMeta[] {
-  const nextEntries: IEntryMeta[] = [];
-  for (const currentEntry of currentEntries) {
-    currentEntry.entry.forward = {
-      individual: {},
-      range: []
-    };
-    for (const glyph of glyphs) {
-      nextEntries.push(...getInputTree(
-        currentEntry.entry.forward,
-        lookupRecords,
-        lookups,
-        position,
-        glyph
-      ).map(({ entry, substitution }) => ({
-        entry,
-        substitutions: [...currentEntry.substitutions, substitution]
-      })));
-    }
-  }
-
-  return nextEntries;
-}
-
-export function processLookaheadPosition(
-  glyphs: (number | [number, number])[],
-  currentEntries: IEntryMeta[]
-): IEntryMeta[] {
-  const nextEntries: IEntryMeta[] = [];
-  const processedEntries = new Set<ILookupTreeEntry>();
-
-  for (const currentEntry of currentEntries) {
-    // Skip if we've already processed this entry object
-    if (processedEntries.has(currentEntry.entry)) {
-      continue;
-    }
-    processedEntries.add(currentEntry.entry);
-
-    currentEntry.entry.forward ??= {
-      individual: {},
-      range: []
-    };
-
-    // All glyphs at this position share ONE entry - lookahead just needs to match,
-    // all paths lead to the same result
-    const sharedEntry: ILookupTreeEntry = {};
-
-    for (const glyph of glyphs) {
-      if (Array.isArray(glyph)) {
-        currentEntry.entry.forward.range.push({
-          entry: sharedEntry,
-          range: glyph
-        });
-      } else {
-        currentEntry.entry.forward.individual[glyph] = sharedEntry;
-      }
-    }
-
-    nextEntries.push({
-      entry: sharedEntry,
-      substitutions: currentEntry.substitutions
-    });
-  }
-
-  return nextEntries;
-}
-
-export function processBacktrackPosition(
-  glyphs: (number | [number, number])[],
-  currentEntries: IEntryMeta[]
-): IEntryMeta[] {
-  const nextEntries: IEntryMeta[] = [];
-  const processedEntries = new Set<ILookupTreeEntry>();
-
-  for (const currentEntry of currentEntries) {
-    // Skip if we've already processed this entry object
-    if (processedEntries.has(currentEntry.entry)) {
-      continue;
-    }
-    processedEntries.add(currentEntry.entry);
-
-    currentEntry.entry.reverse ??= {
-      individual: {},
-      range: []
-    };
-
-    // All glyphs at this position share ONE entry - backtrack just needs to match,
-    // all paths lead to the same result
-    const sharedEntry: ILookupTreeEntry = {};
-
-    for (const glyph of glyphs) {
-      if (Array.isArray(glyph)) {
-        currentEntry.entry.reverse.range.push({
-          entry: sharedEntry,
-          range: glyph
-        });
-      } else {
-        currentEntry.entry.reverse.individual[glyph] = sharedEntry;
-      }
-    }
-
-    nextEntries.push({
-      entry: sharedEntry,
-      substitutions: currentEntry.substitutions
-    });
-  }
-
-  return nextEntries;
-}
-
-export function getInputTree(tree: ILookupTree, substitutions: ISubstitutionLookupRecord[], lookups: Lookup[], inputIndex: number, glyphId: number | [number, number]): { entry: ILookupTreeEntry, substitution: number | null }[] {
-  const result: { entry: ILookupTreeEntry, substitution: number | null }[] = [];
-  if (!Array.isArray(glyphId)) {
-    tree.individual[glyphId] = {};
-    result.push({
-      entry: tree.individual[glyphId],
-      substitution: getSubstitutionAtPosition(substitutions, lookups, inputIndex, glyphId)
-    });
-  } else {
-    const subs = getSubstitutionAtPositionRange(substitutions, lookups, inputIndex, glyphId);
-    for (const [range, substitution] of subs) {
-      const entry: ILookupTreeEntry = {};
-      if (Array.isArray(range)) {
-        tree.range.push({ range, entry });
-      } else {
-        tree.individual[range] = {};
-      }
-      result.push({ entry, substitution });
-    }
-  }
-
-  return result;
-}
-
-function getSubstitutionAtPositionRange(substitutions: ISubstitutionLookupRecord[], lookups: Lookup[], index: number, range: [number, number]): Map<number | [number, number], number | null> {
-  for (const substitution of substitutions.filter(s => s.sequenceIndex === index)) {
-    for (const substitutionTable of (lookups[substitution.lookupListIndex] as Lookup.IType1).subtables) {
-      const sub = getRangeSubstitutionGlyphs(
-        substitutionTable,
-        range
-      );
-
-      if (!Array.from(sub.values()).every(val => val !== null)) {
-        return sub;
-      }
-    }
-  }
-
-  return new Map([[range, null]]);
-}
-
-function getSubstitutionAtPosition(substitutions: ISubstitutionLookupRecord[], lookups: Lookup[], index: number, glyphId: number): number | null {
-  for (const substitution of substitutions.filter(s => s.sequenceIndex === index)) {
-    for (const substitutionTable of (lookups[substitution.lookupListIndex] as Lookup.IType1).subtables) {
-      const sub = getIndividualSubstitutionGlyph(
-        substitutionTable,
-        glyphId
-      );
-
-      if (sub !== null) {
-        return sub;
-      }
-    }
-  }
-
-  return null;
-}
@@ -1,59 +0,0 @@
-import { SubstitutionTable } from '../tables';
-
-import getCoverageGlyphIndex from './coverage';
-
-/**
- * Get the substitution glyph for the givne glyph, or null if the glyph was not
- * found in the table.
- *
- * @param table JSON representation of the substitution table
- * @param glyphId The index of the glpyh to find substitutions for
- */
-export function getRangeSubstitutionGlyphs(table: SubstitutionTable, glyphId: [number, number]): Map<[number, number] | number, number | null> {
-  const replacementStart: number = glyphId[0];
-  const currentReplacement: number | null = getIndividualSubstitutionGlyph(table, replacementStart);
-  let search: number = glyphId[0] + 1;
-
-  const result = new Map<[number, number] | number, number | null>();
-
-  while (search < glyphId[1]) {
-    const sub = getIndividualSubstitutionGlyph(table, search);
-    if (sub !== currentReplacement) {
-      if (search - replacementStart <= 1) {
-        result.set(replacementStart, currentReplacement);
-      } else {
-        result.set([replacementStart, search], currentReplacement);
-      }
-    }
-
-    search++;
-  }
-
-  if (search - replacementStart <= 1) {
-    result.set(replacementStart, currentReplacement);
-  } else {
-    result.set([replacementStart, search], currentReplacement);
-  }
-
-  return result;
-}
-
-export function getIndividualSubstitutionGlyph(table: SubstitutionTable, glyphId: number): number | null {
-  const coverageIndex = getCoverageGlyphIndex(table.coverage, glyphId);
-
-  // istanbul ignore next - invalid font
-  if (coverageIndex === null) {
-    return null;
-  }
-
-  switch (table.substFormat) {
-    // https://docs.microsoft.com/en-us/typography/opentype/spec/gsub#11-single-substitution-format-1
-    case 1:
-      // TODO: determine if there's a rhyme or reason to the 16-bit
-      // wraparound and if it can ever be a different number
-      return (glyphId + table.deltaGlyphId) % (2 ** 16);
-    // https://docs.microsoft.com/en-us/typography/opentype/spec/gsub#12-single-substitution-format-2
-    case 2:
-      return table.substitute[coverageIndex] ?? null;
-  }
-}
@@ -1,112 +0,0 @@
-export type SubstitutionTable = SubstitutionTable.IFormat1 | SubstitutionTable.IFormat2;
-export namespace SubstitutionTable {
-  export interface IFormat1 {
-    substFormat: 1;
-    coverage: CoverageTable;
-    deltaGlyphId: number;
-  }
-
-  export interface IFormat2 {
-    substFormat: 2;
-    coverage: CoverageTable;
-    substitute: number[];
-  }
-}
-
-export type CoverageTable = CoverageTable.IFormat1 | CoverageTable.IFormat2;
-export namespace CoverageTable {
-  export interface IFormat1 {
-    format: 1;
-    glyphs: number[];
-  }
-
-  export interface IFormat2 {
-    format: 2;
-    ranges: {
-      start: number;
-      end: number;
-      index: number;
-    }[];
-  }
-}
-
-export type ChainingContextualSubstitutionTable = ChainingContextualSubstitutionTable.IFormat1 |
-  ChainingContextualSubstitutionTable.IFormat2 | ChainingContextualSubstitutionTable.IFormat3;
-export namespace ChainingContextualSubstitutionTable {
-  export interface IFormat1 {
-    substFormat: 1;
-    coverage: CoverageTable;
-    chainRuleSets: ChainSubRuleTable[][];
-  }
-
-  export interface IFormat2 {
-    substFormat: 2;
-    coverage: CoverageTable;
-    backtrackClassDef: ClassDefTable;
-    inputClassDef: ClassDefTable;
-    lookaheadClassDef: ClassDefTable;
-    chainClassSet: (null | IChainSubClassRuleTable[])[];
-  }
-
-  export interface IFormat3 {
-    substFormat: 3;
-    backtrackCoverage: CoverageTable[];
-    inputCoverage: CoverageTable[];
-    lookaheadCoverage: CoverageTable[];
-    lookupRecords: ISubstitutionLookupRecord[];
-  }
-}
-
-export interface IReverseChainingContextualSingleSubstitutionTable {
-  substFormat: 1;
-  coverage: CoverageTable;
-  backtrackCoverage: CoverageTable[];
-  lookaheadCoverage: CoverageTable[];
-  substitutes: number[];
-}
-
-export type ClassDefTable = ClassDefTable.IFormat2;
-export namespace ClassDefTable {
-  export interface IFormat2 {
-    format: 2;
-    ranges: {
-      start: number;
-      end: number;
-      classId: number;
-    }[];
-  }
-}
-
-export interface ISubstitutionLookupRecord {
-  sequenceIndex: number;
-  lookupListIndex: number;
-}
-
-export type ChainSubRuleTable = IChainSubClassRuleTable;
-export interface IChainSubClassRuleTable {
-  backtrack: number[];
-  input: number[];
-  lookahead: number[];
-  lookupRecords: ISubstitutionLookupRecord[];
-}
-
-export type Lookup = Lookup.IType1 | Lookup.IType6 | Lookup.IType8;
-export namespace Lookup {
-  export interface IType1 {
-    lookupType: 1;
-    lookupFlag: number;
-    subtables: SubstitutionTable[];
-  }
-
-  export interface IType6 {
-    lookupType: 6;
-    lookupFlag: number;
-    subtables: ChainingContextualSubstitutionTable[];
-  }
-
-  export interface IType8 {
-    lookupType: 8;
-    lookupFlag: number;
-    subtables: IReverseChainingContextualSingleSubstitutionTable[];
-  }
-}
@@ -1,86 +0,0 @@
-export interface ISubstitutionResult {
-  index: number;
-  contextRange: [number, number];
-}
-
-/**
- * Information about ligatures found in a sequence of text
- */
-export interface ILigatureData {
-  /**
-   * The list of font glyphs in the input text.
-   */
-  inputGlyphs: number[];
-
-  /**
-   * The list of font glyphs after performing replacements for font ligatures.
-   */
-  outputGlyphs: number[];
-
-  /**
-   * Sorted array of ranges that must be rendered together to produce the
-   * ligatures in the output sequence. The ranges are inclusive on the left and
-   * exclusive on the right.
-   */
-  contextRanges: [number, number][];
-}
-
-export interface IFont {
-  /**
-   * Scans the provided text for font ligatures, returning an object with
-   * metadata about the text and any ligatures found.
-   *
-   * @param text String to search for ligatures
-   */
-  findLigatures(text: string): ILigatureData;
-
-  /**
-   * Scans the provided text for font ligatures, returning an array of ranges
-   * where ligatures are located.
-   *
-   * @param text String to search for ligatures
-   */
-  findLigatureRanges(text: string): [number, number][];
-}
-
-export interface IOptions {
-  /**
-   * Optional size of previous results to store, measured in total number of
-   * characters from input strings. Defaults to no cache (0)
-   */
-  cacheSize?: number;
-}
-
-export interface ILookupTree {
-  individual: {
-    [glyphId: string]: ILookupTreeEntry;
-  };
-  range: {
-    range: [number, number];
-    entry: ILookupTreeEntry;
-  }[];
-}
-
-export interface ILookupTreeEntry {
-  lookup?: ILookupResult;
-  forward?: ILookupTree;
-  reverse?: ILookupTree;
-}
-
-export interface ILookupResult {
-  substitutions: (number | null)[];
-  length: number;
-  index: number;
-  subIndex: number;
-  contextRange: [number, number];
-}
-
-export interface IFlattenedLookupTree {
-  [glyphId: string]: IFlattenedLookupTreeEntry;
-}
-
-export interface IFlattenedLookupTreeEntry {
-  lookup?: ILookupResult;
-  forward?: IFlattenedLookupTree;
-  reverse?: IFlattenedLookupTree;
-}
@@ -1,67 +0,0 @@
-import { IFlattenedLookupTree, ILookupResult } from './types';
-
-export default function walkTree(tree: IFlattenedLookupTree, sequence: number[], startIndex: number, index: number): ILookupResult | undefined {
-  const glyphId = sequence[index];
-  const subtree = tree[glyphId];
-  if (!subtree) {
-    return undefined;
-  }
-
-  let lookup = subtree.lookup;
-  if (subtree.reverse) {
-    const reverseLookup = walkReverse(subtree.reverse, sequence, startIndex);
-
-    if (
-      (!lookup && reverseLookup) ||
-      (
-        reverseLookup && lookup && (
-          lookup.index > reverseLookup.index ||
-          (lookup.index === reverseLookup.index && lookup.subIndex > reverseLookup.subIndex)
-        )
-      )
-    ) {
-      lookup = reverseLookup;
-    }
-  }
-
-  if (++index >= sequence.length || !subtree.forward) {
-    return lookup;
-  }
-
-  const forwardLookup = walkTree(subtree.forward, sequence, startIndex, index);
-
-  if (
-    (!lookup && forwardLookup) ||
-    (
-      forwardLookup && lookup && (
-        lookup.index > forwardLookup.index ||
-        (lookup.index === forwardLookup.index && lookup.subIndex > forwardLookup.subIndex)
-      )
-    )
-  ) {
-    lookup = forwardLookup;
-  }
-
-  return lookup;
-}
-
-function walkReverse(tree: IFlattenedLookupTree, sequence: number[], index: number): ILookupResult | undefined {
-  let subtree = tree[sequence[--index]];
-  let lookup: ILookupResult | undefined = subtree && subtree.lookup;
-  while (subtree) {
-    if (
-      (!lookup && subtree.lookup) ||
-      (subtree.lookup && lookup && lookup.index > subtree.lookup.index)
-    ) {
-      lookup = subtree.lookup;
-    }
-
-    if (--index < 0 || !subtree.reverse) {
-      break;
-    }
-
-    subtree = subtree.reverse[sequence[index]];
-  }
-
-  return lookup;
-}
@@ -4,62 +4,61 @@
 */

 import * as path from 'path';
+import * as sinon from 'sinon';
 import { assert } from 'chai';
+import * as fontFinder from 'font-finder';

-// Use require to get a mutable module object (ESM imports create read-only bindings)
-const fontFinder = require('font-finder');
-const ligatureSupport = require('../out-esbuild/index');
-
-const originalList = fontFinder.list;
+import * as ligatureSupport from '.';

 describe('LigaturesAddon', () => {
-  let onRefresh: { called: boolean, callCount: number, (...args: any[]): void };
+  let onRefresh: sinon.SinonStub;
  let term: MockTerminal;

+  // -> forms a ligature in Fira Code and Iosevka, but www only forms a ligature
+  // in Fira Code
  const input = 'a -> b www c';

  before(() => {
-    fontFinder.list = () => Promise.resolve({
+    sinon.stub(fontFinder, 'list').returns(Promise.resolve({
+      // eslint-disable-next-line @typescript-eslint/naming-convention
      'Fira Code': [{
        path: path.join(__dirname, '../fonts/firaCode.otf'),
        style: fontFinder.Style.Regular,
        type: fontFinder.Type.Monospace,
        weight: 400
      }],
+      // eslint-disable-next-line @typescript-eslint/naming-convention
      'Iosevka': [{
        path: path.join(__dirname, '../fonts/iosevka.ttf'),
        style: fontFinder.Style.Regular,
        type: fontFinder.Type.Monospace,
        weight: 400
      }],
+      // eslint-disable-next-line @typescript-eslint/naming-convention
      'Nonexistant Font': [{
        path: path.join(__dirname, '../fonts/nonexistant.ttf'),
        style: fontFinder.Style.Regular,
        type: fontFinder.Type.Monospace,
        weight: 400
      }]
-    });
-  });
-
-  after(() => {
-    fontFinder.list = originalList;
+    } as fontFinder.FontList));
  });

  beforeEach(() => {
-    onRefresh = Object.assign((..._args: any[]) => { onRefresh.called = true; onRefresh.callCount++; }, { called: false, callCount: 0 });
+    onRefresh = sinon.stub();
    term = new MockTerminal(onRefresh);
    ligatureSupport.enableLigatures(term as any);
  });

  it('registers itself correctly', () => {
-    const term = new MockTerminal(() => {});
+    const term = new MockTerminal(sinon.spy());
    assert.isUndefined(term.joiner);
    ligatureSupport.enableLigatures(term as any);
    assert.isFunction(term.joiner);
  });

  it('registers itself correctly when called directly', () => {
-    const term = new MockTerminal(() => {});
+    const term = new MockTerminal(sinon.spy());
    assert.isUndefined(term.joiner);
    ligatureSupport.enableLigatures(term as any);
    assert.isFunction(term.joiner);
@@ -73,14 +72,14 @@ describe('LigaturesAddon', () => {
    term.options.fontFamily = 'Nonexistant Font, monospace';
    assert.deepEqual(term.joiner!(input), []);
    await delay(500);
-    assert.strictEqual(onRefresh.callCount, 0);
+    assert.isTrue(onRefresh.notCalled);
  });

  it('returns nothing if the font is not present on the system', async () => {
    term.options.fontFamily = 'notinstalled';
    assert.deepEqual(term.joiner!(input), []);
    await delay(500);
-    assert.strictEqual(onRefresh.callCount, 0);
+    assert.isTrue(onRefresh.notCalled);
    assert.deepEqual(term.joiner!(input), []);
  });

@@ -88,7 +87,7 @@ describe('LigaturesAddon', () => {
    term.options.fontFamily = 'monospace';
    assert.deepEqual(term.joiner!(input), []);
    await delay(500);
-    assert.strictEqual(onRefresh.callCount, 0);
+    assert.isTrue(onRefresh.notCalled);
    assert.deepEqual(term.joiner!(input), []);
  });

@@ -96,7 +95,7 @@ describe('LigaturesAddon', () => {
    term.options.fontFamily = '';
    assert.deepEqual(term.joiner!(input), []);
    await delay(500);
-    assert.strictEqual(onRefresh.callCount, 0);
+    assert.isTrue(onRefresh.notCalled);
    assert.deepEqual(term.joiner!(input), []);
  });

@@ -104,7 +103,7 @@ describe('LigaturesAddon', () => {
    term.options.fontFamily = {} as any;
    assert.deepEqual(term.joiner!(input), []);
    await delay(500);
-    assert.strictEqual(onRefresh.callCount, 0);
+    assert.isTrue(onRefresh.notCalled);
  });
 });

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
copilot-swe-agent[bot]andTyriar	6e39f74f2c	Document Alt+- keyboard issue investigation with comprehensive tests Co-authored-by: Tyriar <2193314+Tyriar@users.noreply.github.com>	2025-08-24 13:08:56 +00:00
copilot-swe-agent[bot]andTyriar	9a64c2cb63	Add comprehensive tests for Alt+- keyboard handling Co-authored-by: Tyriar <2193314+Tyriar@users.noreply.github.com>	2025-08-24 13:04:42 +00:00
copilot-swe-agent[bot]	dc2ac0b78b	Initial plan	2025-08-24 12:47:20 +00:00