@xterm/addon-image 0.10.0-beta.28 → 0.10.0-beta.281

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xterm/addon-image",
-  "version": "0.10.0-beta.28",
+  "version": "0.10.0-beta.281",
   "author": {
     "name": "The xterm.js authors",
     "url": "https://xtermjs.org/"
@@ -18,17 +18,17 @@
     "xterm.js"
   ],
   "scripts": {
-    "prepackage": "../../node_modules/.bin/tsc -p .",
+    "prepackage": "../../node_modules/.bin/tsgo -p .",
     "package": "../../node_modules/.bin/webpack",
     "prepublishOnly": "npm run package",
     "start": "node ../../demo/start"
   },
   "devDependencies": {
     "sixel": "^0.16.0",
-    "xterm-wasm-parts": "^0.1.0"
+    "xterm-wasm-parts": "^0.4.1"
   },
-  "commit": "d4f725c6499ec3efb723c27adce3762746d0d5d6",
+  "commit": "2fe3fd13a164f956d0c6a2365fa89feaf4366074",
   "peerDependencies": {
-    "@xterm/xterm": "^6.1.0-beta.28"
+    "@xterm/xterm": "^6.1.0-beta.281"
   }
 }

package/src/IIPHandler.ts

@@ -4,20 +4,26 @@
  */
 import { IImageAddonOptions, IOscHandler, IResetHandler, ITerminalExt } from './Types';
 import { ImageRenderer } from './ImageRenderer';
-import { ImageStorage, CELL_SIZE_DEFAULT } from './ImageStorage';
+import { IIPImageStorage } from './IIPImageStorage';
+import { CELL_SIZE_DEFAULT } from './ImageStorage';
 import Base64Decoder from 'xterm-wasm-parts/lib/base64/Base64Decoder.wasm';
-import { HeaderParser, IHeaderFields, HeaderState } from './IIPHeaderParser';
+import QoiDecoder from 'xterm-wasm-parts/lib/qoi/QoiDecoder.wasm';
+import { HeaderParser, IHeaderFields, HeaderState, SequenceType } from './IIPHeaderParser';
 import { imageType, UNSUPPORTED_TYPE } from './IIPMetrics';
 
-
-// eslint-disable-next-line
-declare const Buffer: any;
-
-// limit hold memory in base64 decoder
-const KEEP_DATA = 4194304;
+// 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
+}
 
 // default IIP header values
 const DEFAULT_HEADER: IHeaderFields = {
+  type: SequenceType.INVALID,
   name: 'Unnamed file',
   size: 0,
   width: 'auto',
@@ -31,21 +37,32 @@ export class IIPHandler implements IOscHandler, IResetHandler {
   private _aborted = false;
   private _hp = new HeaderParser();
   private _header: IHeaderFields = DEFAULT_HEADER;
-  private _dec = new Base64Decoder(KEEP_DATA);
+  private _dec: Base64Decoder;
+  private _qoiDec: QoiDecoder;
   private _metrics = UNSUPPORTED_TYPE;
+  private _isMultipart = false;
+  private _abortMulti = false;
 
   constructor(
     private readonly _opts: IImageAddonOptions,
     private readonly _renderer: ImageRenderer,
-    private readonly _storage: ImageStorage,
+    private readonly _storage: IIPImageStorage,
     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 {}
+  public reset(): void {
+    this._hp.reset();
+    this._dec.release();
+    this._qoiDec.release();
+  }
 
   public start(): void {
     this._aborted = false;
-    this._header = DEFAULT_HEADER;
     this._metrics  = UNSUPPORTED_TYPE;
     this._hp.reset();
   }
@@ -54,7 +71,7 @@ export class IIPHandler implements IOscHandler, IResetHandler {
     if (this._aborted) return;
 
     if (this._hp.state === HeaderState.END) {
-      if (this._dec.put(data, start, end)) {
+      if ((this._dec.put(data.subarray(start, end)) as number) !== DecoderConst.OK) {
         this._dec.release();
         this._aborted = true;
       }
@@ -65,15 +82,27 @@ export class IIPHandler implements IOscHandler, IResetHandler {
         return;
       }
       if (dataPos > 0) {
-        this._header = Object.assign({}, DEFAULT_HEADER, this._hp.fields);
-        if (!this._header.inline || !this._header.size || this._header.size > this._opts.iipSizeLimit) {
+        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._aborted = true;
           return;
         }
-        this._dec.init(this._header.size);
-        if (this._dec.put(data, dataPos, end)) {
+        if ((this._dec.put(data.subarray(dataPos, end)) as number) !== DecoderConst.OK) {
           this._dec.release();
           this._aborted = true;
+          if (this._isMultipart) this._abortMulti = true;
         }
       }
     }
@@ -82,11 +111,49 @@ 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 = true;
+    let cond: number | boolean;
     if (cond = success) {
       if (cond = !this._dec.end()) {
         this._metrics = imageType(this._dec.data8);
@@ -105,26 +172,27 @@ export class IIPHandler implements IOscHandler, IResetHandler {
       return true;
     }
 
-    const blob = new Blob([this._dec.data8], { type: this._metrics.mime });
-    this._dec.release();
-
-    if (!window.createImageBitmap) {
-      const url = URL.createObjectURL(blob);
-      const img = new Image();
-      return new Promise<boolean>(r => {
-        img.addEventListener('load', () => {
-          URL.revokeObjectURL(url);
-          const canvas = ImageRenderer.createCanvas(window.document, w, h);
-          canvas.getContext('2d')?.drawImage(img, 0, 0, w, h);
-          this._storage.addImage(canvas);
-          r(true);
-        });
-        img.src = url;
-        // sanity measure to avoid terminal blocking from dangling promise
-        // happens from corrupt data (onload never gets fired)
-        setTimeout(() => r(true), 1000);
-      });
+    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 });
     }
+    this._dec.release();
     return createImageBitmap(blob, { resizeWidth: w, resizeHeight: h })
       .then(bm => {
         this._storage.addImage(bm);
@@ -154,8 +222,8 @@ export class IIPHandler implements IOscHandler, IResetHandler {
 
   private _dim(s: string, total: number, cdim: number): number {
     if (s === 'auto') return 0;
-    if (s.endsWith('%')) return parseInt(s.slice(0, -1)) * total / 100;
-    if (s.endsWith('px')) return parseInt(s.slice(0, -2));
-    return parseInt(s) * cdim;
+    if (s.endsWith('%')) return parseInt(s.slice(0, -1), 10) * total / 100;
+    if (s.endsWith('px')) return parseInt(s.slice(0, -2), 10);
+    return parseInt(s, 10) * cdim;
   }
 }

package/src/IIPHeaderParser.ts

@@ -6,8 +6,27 @@
 // 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.
@@ -28,14 +47,6 @@ 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
@@ -81,7 +92,7 @@ function toName(data: Uint32Array): string {
   return new TextDecoder().decode(b);
 }
 
-const DECODERS: {[key: string]: (v: Uint32Array) => any} = {
+const DECODERS: {[key: string]: (v: Uint32Array) => number | string} = {
   inline: toInt,
   size: toInt,
   name: toName,
@@ -91,7 +102,19 @@ const DECODERS: {[key: string]: (v: Uint32Array) => any} = {
 };
 
 
+// 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;
 
 
@@ -100,7 +123,7 @@ export class HeaderParser {
   private _buffer = new Uint32Array(MAX_FIELDCHARS);
   private _position = 0;
   private _key = '';
-  public fields: {[key: string]: any} = {};
+  public fields: {[key: string]: number | string | Uint32Array | null | undefined} = {};
 
   public reset(): void {
     this._buffer.fill(0);
@@ -110,12 +133,43 @@ 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 > 6) return -1;
+    if (state === HeaderState.START && pos > 14) return -1;
     for (let i = start; i < end; ++i) {
       const c = data[i];
       switch (c) {
@@ -126,8 +180,29 @@ export class HeaderParser {
           break;
         case 61: // =
           if (state === HeaderState.START) {
-            for (let k = 0; k < FILE_MARKER.length; ++k) {
-              if (buffer[k] !== FILE_MARKER[k]) return this._a();
+            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();
             }
             state = HeaderState.KEY;
             pos = 0;
@@ -157,6 +232,7 @@ export class HeaderParser {
   }
 
   private _a(): number {
+    this.fields.type = SequenceType.INVALID;
     this.state = HeaderState.ABORT;
     return -1;
   }

package/src/IIPImageStorage.ts

@@ -0,0 +1,28 @@
+/**
+ * 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);
+  }
+}

package/src/IIPMetrics.ts

@@ -4,7 +4,7 @@
  */
 
 
-export type ImageType = 'image/png' | 'image/jpeg' | 'image/gif' | 'unsupported' | '';
+export type ImageType = 'image/png' | 'image/jpeg' | 'image/gif' | 'image/qoi' | 'unsupported' | '';
 
 export interface IMetrics {
   mime: ImageType;
@@ -45,6 +45,14 @@ 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;
 }
 

package/src/ImageAddon.ts

@@ -5,24 +5,72 @@
 
 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: 256,
-  sixelSizeLimit: 25000000,
+  sixelPaletteLimit: 4096,
+  sixelSizeLimit: 33554432,
   storageLimit: 128,
   showPlaceholder: true,
   iipSupport: true,
-  iipSizeLimit: 20000000
+  iipSizeLimit: 33554432,
+  kittySupport: true,
+  kittySizeLimit: 33554432
 };
 
 // max palette size supported by the sixel lib (compile time setting)
@@ -48,7 +96,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;
@@ -56,6 +104,8 @@ 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);
@@ -68,6 +118,7 @@ export class ImageAddon implements ITerminalAddon , IImageApi {
     }
     this._disposables.length = 0;
     this._handlers.clear();
+    this._onImageAdded.dispose();
   }
 
   private _disposeLater(...args: IDisposable[]): void {
@@ -82,15 +133,11 @@ 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 windowOptions = terminal.getOption('windowOptions');
-      // windowOptions.getWinSizePixels = true;
-      // windowOptions.getCellSizePixels = true;
-      // windowOptions.getWinSizeChars = true;
-      // terminal.setOption('windowOptions', windowOptions);
-      const windowOps = terminal.options.windowOptions || {};
+      const windowOps = terminal.options.windowOptions ?? {};
       windowOps.getWinSizePixels = true;
       windowOps.getCellSizePixels = true;
       windowOps.getWinSizeChars = true;
@@ -129,7 +176,8 @@ export class ImageAddon implements ITerminalAddon , IImageApi {
 
     // SIXEL handler
     if (this._opts.sixelSupport) {
-      const sixelHandler = new SixelHandler(this._opts, this._storage!, terminal);
+      const sixelStorage = new SixelImageStorage(this._storage!, this._opts, this._renderer!, terminal);
+      const sixelHandler = new SixelHandler(this._opts, sixelStorage, terminal);
       this._handlers.set('sixel', sixelHandler);
       this._disposeLater(
         terminal._core._inputHandler._parser.registerDcsHandler({ final: 'q' }, sixelHandler)
@@ -138,12 +186,25 @@ export class ImageAddon implements ITerminalAddon , IImageApi {
 
     // iTerm IIP handler
     if (this._opts.iipSupport) {
-      const iipHandler = new IIPHandler(this._opts, this._renderer!, this._storage!, terminal);
+      const iipStorage = new IIPImageStorage(this._storage!);
+      const iipHandler = new IIPHandler(this._opts, this._renderer!, iipStorage, 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.
@@ -194,7 +255,7 @@ export class ImageAddon implements ITerminalAddon , IImageApi {
   }
 
   private _report(s: string): void {
-    this._terminal?._core.coreService.triggerDataEvent(s);
+    this._terminal?._core.input(s, false);
   }
 
   private _decset(params: (number | number[])[]): boolean {