Compare commits

..
Author SHA1 Message Date
Cursor AgentandDaniel Imms 511ce3f5d3 Remove unused type imports from common/Types.ts
Co-authored-by: Daniel Imms <Tyriar@users.noreply.github.com>
2026-06-06 18:43:00 +00:00
Cursor AgentandDaniel Imms cf68f0b514 Restore tsconfig files to match master (undo whitespace-only changes)
Co-authored-by: Daniel Imms <Tyriar@users.noreply.github.com>
2026-06-06 18:39:14 +00:00
Cursor AgentandDaniel Imms bd8510e3ab Move primitive types from common/Types.ts to common/primitives/Types.ts
Extract low-level types (IParams, ParamsArray, IDisposable, color,
keyboard, mouse, charset, etc.) into primitives/Types.ts. Keep
runtime/integration types (ITerminalOptions, IInputHandler, terminal
modes) in common/Types.ts. Lifecycle re-exports IDisposable from
primitives/Types.ts.

Co-authored-by: Daniel Imms <Tyriar@users.noreply.github.com>
2026-06-06 18:32:48 +00:00
Cursor AgentandDaniel Imms f6c1b21258 Revert esbuild.mjs entry point split for primitives folder
src/common/**/*.ts already covers primitives since they remain under
common/. No build configuration changes are needed for this move.

Co-authored-by: Daniel Imms <Tyriar@users.noreply.github.com>
2026-06-06 18:29:16 +00:00
Cursor AgentandDaniel Imms b7d45bfefa Revert tsconfig path mapping changes for primitives folder
Primitives remain under src/common/, so common/* aliases do not need
a separate primitives entry. Restore original tsconfig paths.

Co-authored-by: Daniel Imms <Tyriar@users.noreply.github.com>
2026-06-06 18:24:02 +00:00
Cursor AgentandDaniel Imms 701c0affd5 Move common primitives to src/common/primitives/
Phase 1 of #5963: reorganize building blocks (buffer, parser, input,
data, and shared utilities) under common/primitives/. Runtime code
(services, public API, CoreTerminal, InputHandler) stays in place.

Update import paths across browser, headless, addons, and tests.
Add TypeScript path mappings so common/* aliases resolve primitives
first, then the common root.

Co-authored-by: Daniel Imms <Tyriar@users.noreply.github.com>
2026-06-06 18:21:03 +00:00
181 changed files with 720 additions and 2294 deletions
-1
View File
@@ -254,7 +254,6 @@ Xterm.js is used in many world-class applications to provide great terminal expe
- [**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.
- [**Cate**](https://github.com/0-AI-UG/cate): Open source desktop IDE on an infinite zoomable canvas. Editor, browser, and terminal panels float in spatial space; the terminals are xterm.js with the WebGL addon, backed by node-pty.
- [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.
+1 -1
View File
@@ -5,7 +5,7 @@
import type { ITerminalAddon, IDisposable } from '@xterm/xterm';
import type { ImageAddon as IImageApi } from '@xterm/addon-image';
import { Emitter, type IEvent } from 'common/Event';
import { Emitter, type IEvent } from 'common/primitives/Event';
import { IIPHandler } from './IIPHandler';
import { ImageRenderer } from './ImageRenderer';
import { ImageStorage, CELL_SIZE_DEFAULT } from './ImageStorage';
+1 -1
View File
@@ -6,7 +6,7 @@
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 { Disposable, MutableDisposable, toDisposable } from 'common/primitives/Lifecycle';
const enum Constants {
PLACEHOLDER_LENGTH = 4096,
+4 -4
View File
@@ -6,11 +6,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 { Attributes, BgFlags, Content, ExtFlags, UnderlineStyle } from 'common/primitives/buffer/Constants';
import type { AttributeData } from 'common/primitives/buffer/AttributeData';
import type { IParams, IDcsHandler, IOscHandler, IApcHandler, IEscapeSequenceParser } from 'common/primitives/parser/Types';
import type { IInputHandler } from 'common/Types';
import type { IBufferLine, IExtendedAttrs } from 'common/buffer/Types';
import type { IBufferLine, IExtendedAttrs } from 'common/primitives/buffer/Types';
import type { ITerminal, ReadonlyColorSet } from 'browser/Types';
import type { IRenderDimensions } from 'browser/renderer/shared/Types';
import type { ICoreBrowserService, IRenderService, IThemeService } from 'browser/services/Services';
+1 -1
View File
@@ -5,7 +5,7 @@
import type { Terminal, ITerminalAddon, IDisposable } from '@xterm/xterm';
import type { ProgressAddon as IProgressApi, IProgressState } from '@xterm/addon-progress';
import type { Emitter, IEvent } from 'common/Event';
import type { Emitter, IEvent } from 'common/primitives/Event';
const enum ProgressType {
@@ -10,7 +10,7 @@ import { SearchLineCache } from './SearchLineCache';
import { Terminal } from 'browser/public/Terminal';
import type { ISearchDecorationOptions } from '@xterm/addon-search';
import type { IDecorationOptions } from '@xterm/xterm';
import { DisposableStore } from 'common/Lifecycle';
import { DisposableStore } from 'common/primitives/Lifecycle';
function writeP(terminal: Terminal, data: string): Promise<void> {
return new Promise(r => terminal.write(data, r));
+1 -1
View File
@@ -5,7 +5,7 @@
import type { Terminal, IDisposable, IDecoration } from '@xterm/xterm';
import type { ISearchDecorationOptions } from '@xterm/addon-search';
import { dispose, Disposable, toDisposable } from 'common/Lifecycle';
import { dispose, Disposable, toDisposable } from 'common/primitives/Lifecycle';
import type { ISearchResult } from './SearchEngine';
/**
+3 -3
View File
@@ -5,9 +5,9 @@
import type { Terminal, IDisposable, ITerminalAddon } from '@xterm/xterm';
import type { SearchAddon as ISearchApi, ISearchOptions, ISearchAddonOptions, ISearchResultChangeEvent, ISearchDecorationOptions } from '@xterm/addon-search';
import { Emitter, type IEvent } from 'common/Event';
import { Disposable, MutableDisposable, toDisposable } from 'common/Lifecycle';
import { disposableTimeout } from 'common/Async';
import { Emitter, type IEvent } from 'common/primitives/Event';
import { Disposable, MutableDisposable, toDisposable } from 'common/primitives/Lifecycle';
import { disposableTimeout } from 'common/primitives/Async';
import { SearchLineCache } from './SearchLineCache';
import { SearchState } from './SearchState';
import { SearchEngine, type ISearchResult } from './SearchEngine';
+1 -1
View File
@@ -7,7 +7,7 @@ import { SearchEngine } from './SearchEngine';
import { SearchLineCache } from './SearchLineCache';
import { Terminal } from 'browser/public/Terminal';
import type { ISearchOptions } from '@xterm/addon-search';
import { DisposableStore } from 'common/Lifecycle';
import { DisposableStore } from 'common/primitives/Lifecycle';
function writeP(terminal: Terminal, data: string): Promise<void> {
return new Promise(r => terminal.write(data, r));
@@ -5,7 +5,7 @@
import { assert } from 'chai';
import { SearchLineCache, LineCacheEntry } from './SearchLineCache';
import { Terminal } from 'browser/public/Terminal';
import { timeout } from 'common/Async';
import { timeout } from 'common/primitives/Async';
function writeP(terminal: Terminal, data: string): Promise<void> {
return new Promise(r => terminal.write(data, r));
+2 -2
View File
@@ -4,8 +4,8 @@
*/
import type { Terminal } from '@xterm/xterm';
import { combinedDisposable, Disposable, MutableDisposable, toDisposable } from 'common/Lifecycle';
import { disposableTimeout } from 'common/Async';
import { combinedDisposable, Disposable, MutableDisposable, toDisposable } from 'common/primitives/Lifecycle';
import { disposableTimeout } from 'common/primitives/Async';
export type LineCacheEntry = [
/**
@@ -5,8 +5,8 @@
import type { ISearchResultChangeEvent } from '@xterm/addon-search';
import type { IDisposable } from '@xterm/xterm';
import { Emitter, type IEvent } from 'common/Event';
import { Disposable } from 'common/Lifecycle';
import { Emitter, type IEvent } from 'common/primitives/Event';
import { Disposable } from 'common/primitives/Lifecycle';
import type { ISearchResult } from './SearchEngine';
/**
@@ -6,7 +6,7 @@
import { perfContext, before, ThroughputRuntimeCase } from 'xterm-benchmark';
import { spawn } from 'node-pty';
import { Utf8ToUtf32, stringFromCodePoint } from 'common/input/TextDecoder';
import { Utf8ToUtf32, stringFromCodePoint } from 'common/primitives/input/TextDecoder';
import { Terminal } from 'browser/public/Terminal';
import { SerializeAddon } from 'SerializeAddon';
+3 -3
View File
@@ -7,10 +7,10 @@
import type { IBuffer, IBufferCell, IBufferRange, ITerminalAddon, Terminal } from '@xterm/xterm';
import type { IHTMLSerializeOptions, SerializeAddon as ISerializeApi, ISerializeOptions, ISerializeRange } from '@xterm/addon-serialize';
import { IColor } from 'common/Types';
import { IAttributeData } from 'common/buffer/Types';
import { IColor } from 'common/primitives/Types';
import { IAttributeData } from 'common/primitives/buffer/Types';
import { DEFAULT_ANSI_COLORS } from 'browser/Types';
import { UnderlineStyle } from 'common/buffer/Constants';
import { UnderlineStyle } from 'common/primitives/buffer/Constants';
function constrain(value: number, low: number, high: number): number {
return Math.max(low, Math.min(value, high));
@@ -6,7 +6,7 @@
import { perfContext, before, ThroughputRuntimeCase } from 'xterm-benchmark';
import { spawn } from 'node-pty';
import { Utf8ToUtf32, stringFromCodePoint } from 'common/input/TextDecoder';
import { Utf8ToUtf32, stringFromCodePoint } from 'common/primitives/input/TextDecoder';
import { CoreBrowserTerminal } from 'browser/CoreBrowserTerminal';
import { UnicodeGraphemeProvider } from 'UnicodeGraphemeProvider';
+3 -3
View File
@@ -1,11 +1,11 @@
import { ISelectionRenderModel } from 'browser/renderer/shared/Types';
import { ICoreBrowserService, IThemeService } from 'browser/services/Services';
import { ReadonlyColorSet } from 'browser/Types';
import { Attributes, BgFlags, ExtFlags, FgFlags, NULL_CELL_CODE, UnderlineStyle } from 'common/buffer/Constants';
import { Attributes, BgFlags, ExtFlags, FgFlags, NULL_CELL_CODE, UnderlineStyle } from 'common/primitives/buffer/Constants';
import { IDecorationService, IOptionsService } from 'common/services/Services';
import { ICellData } from 'common/buffer/Types';
import { ICellData } from 'common/primitives/buffer/Types';
import { Terminal } from '@xterm/xterm';
import { rgba } from 'common/Color';
import { rgba } from 'common/primitives/Color';
import { treatGlyphAsBackgroundColor } from 'browser/renderer/shared/RendererUtils';
import { blockPatternCodepoints } from './customGlyphs/CustomGlyphDefinitions';
@@ -6,8 +6,8 @@
import { assert } from 'chai';
import { configEquals } from './CharAtlasUtils';
import { ICharAtlasConfig } from './Types';
import { NULL_COLOR } from 'common/Color';
import { IColor } from 'common/Types';
import { NULL_COLOR } from 'common/primitives/Color';
import { IColor } from 'common/primitives/Types';
function createTestConfig(overrides: Partial<ICharAtlasConfig> = {}): ICharAtlasConfig {
const color: IColor = { css: '#ffffff', rgba: 0xffffffff };
+2 -2
View File
@@ -4,10 +4,10 @@
*/
import { ICharAtlasConfig } from './Types';
import { Attributes } from 'common/buffer/Constants';
import { Attributes } from 'common/primitives/buffer/Constants';
import { ITerminalOptions } from '@xterm/xterm';
import { IColorSet, ReadonlyColorSet } from 'browser/Types';
import { NULL_COLOR } from 'common/Color';
import { NULL_COLOR } from 'common/primitives/Color';
export function generateConfig(deviceCellWidth: number, deviceCellHeight: number, deviceCharWidth: number, deviceCharHeight: number, options: Required<ITerminalOptions>, colors: ReadonlyColorSet, devicePixelRatio: number, deviceMaxTextureSize: number, customGlyphs: boolean = true): ICharAtlasConfig {
// null out some fields that don't matter
+1 -1
View File
@@ -3,7 +3,7 @@
* @license MIT
*/
import { isFirefox, isLegacyEdge } from 'common/Platform';
import { isFirefox, isLegacyEdge } from 'common/primitives/Platform';
export const DIM_OPACITY = 0.5;
// The text baseline is set conditionally by browser. Using 'ideographic' for Firefox or Legacy Edge
@@ -3,7 +3,7 @@
* @license MIT
*/
import { toDisposable, IDisposable } from 'common/Lifecycle';
import { toDisposable, IDisposable } from 'common/primitives/Lifecycle';
export function observeDevicePixelDimensions(element: HTMLElement, parentWindow: Window & typeof globalThis, callback: (deviceWidth: number, deviceHeight: number) => void): IDisposable {
// Observe any resizes to the element and extract the actual pixel size of the element if the
+5 -30
View File
@@ -4,8 +4,8 @@
*/
import { TextureAtlas } from './TextureAtlas';
import { IRenderDimensions } from 'browser/renderer/shared/Types';
import { NULL_CELL_CODE } from 'common/buffer/Constants';
import { Disposable, toDisposable } from 'common/Lifecycle';
import { NULL_CELL_CODE } from 'common/primitives/buffer/Constants';
import { Disposable, toDisposable } from 'common/primitives/Lifecycle';
import { Terminal } from '@xterm/xterm';
import { IRenderModel, IWebGL2RenderingContext, IWebGLVertexArrayObject, type IRasterizedGlyph, type ITextureAtlas } from './Types';
import { createProgram, GLTexture, PROJECTION_MATRIX } from './WebglUtils';
@@ -100,8 +100,6 @@ export class GlyphRenderer extends Disposable {
private readonly _attributesBuffer: WebGLBuffer;
private _atlas: ITextureAtlas | undefined;
private _lastAtlasPagesVersion: number = -1;
private _pageOverflowWarned: boolean = false;
private _activeBuffer: number = 0;
private readonly _vertices: IVertices = {
count: 0,
@@ -215,21 +213,8 @@ export class GlyphRenderer extends Disposable {
this.handleResize();
}
/**
* Returns whether the full model must be rebuilt before rendering this frame.
* This is tracked per renderer (not on the shared atlas) so that every
* terminal sharing the atlas rebuilds its model after a page merge, not just
* the first one to render (vscode#322756).
*/
public beginFrame(): boolean {
if (!this._atlas) {
return true;
}
if (this._atlas.pagesVersion !== this._lastAtlasPagesVersion) {
this._lastAtlasPagesVersion = this._atlas.pagesVersion;
return true;
}
return false;
return this._atlas ? this._atlas.beginFrame() : true;
}
public updateCell(x: number, y: number, code: number, bg: number, fg: number, ext: number, chars: string, width: number, lastBg: number): void {
@@ -377,15 +362,8 @@ export class GlyphRenderer extends Disposable {
// Bind the atlas page texture if they have changed. AtlasPage.version is globally
// monotonic, so a page object swap at the same index (which happens after a page merge)
// is detected by the same comparison. The page count is clamped to the fixed texture
// array size so an atlas page overflow degrades (untextured glyphs) instead of throwing
// mid-frame; the atlas is responsible for never exceeding maxAtlasPages.
const pageCount = Math.min(this._atlas.pages.length, this._atlasTextures.length);
if (this._atlas.pages.length > this._atlasTextures.length && !this._pageOverflowWarned) {
this._pageOverflowWarned = true;
this._logService.warn(`Atlas page count (${this._atlas.pages.length}) exceeds the renderer's texture capacity (${this._atlasTextures.length}), some glyphs will not render correctly`);
}
for (let i = 0; i < pageCount; i++) {
// is detected by the same comparison.
for (let i = 0; i < this._atlas.pages.length; i++) {
if (this._atlas.pages[i].version !== this._atlasTextures[i].version) {
this._bindAtlasPageTexture(gl, this._atlas, i);
}
@@ -397,9 +375,6 @@ export class GlyphRenderer extends Disposable {
public setAtlas(atlas: ITextureAtlas): void {
this._atlas = atlas;
// Force a model rebuild on the next frame as glyph coordinates from a
// previous atlas are meaningless in the new one.
this._lastAtlasPagesVersion = -1;
this.invalidateAtlasTextures();
}
+3 -3
View File
@@ -6,9 +6,9 @@
import { IRenderDimensions } from 'browser/renderer/shared/Types';
import { IThemeService } from 'browser/services/Services';
import { ReadonlyColorSet } from 'browser/Types';
import { Attributes, FgFlags } from 'common/buffer/Constants';
import { Disposable, toDisposable } from 'common/Lifecycle';
import { IColor } from 'common/Types';
import { Attributes, FgFlags } from 'common/primitives/buffer/Constants';
import { Disposable, toDisposable } from 'common/primitives/Lifecycle';
import { IColor } from 'common/primitives/Types';
import { Terminal } from '@xterm/xterm';
import { RenderModelConstants } from './RenderModel';
import { IRenderModel, IWebGL2RenderingContext, IWebGLVertexArrayObject } from './Types';
+54 -86
View File
@@ -8,14 +8,14 @@ import { DIM_OPACITY, TEXT_BASELINE } from './Constants';
import { tryDrawCustomGlyph } from './customGlyphs/CustomGlyphRasterizer';
import { computeNextVariantOffset, treatGlyphAsBackgroundColor, isPowerlineGlyph, isRestrictedPowerlineGlyph, throwIfFalsy } from 'browser/renderer/shared/RendererUtils';
import { IBoundingBox, ICharAtlasConfig, IRasterizedGlyph, ITextureAtlas } from './Types';
import { NULL_COLOR, channels, color, rgba } from 'common/Color';
import { FourKeyMap } from 'common/MultiKeyMap';
import { IdleTaskQueue } from 'common/TaskQueue';
import { IColor } from 'common/Types';
import { AttributeData } from 'common/buffer/AttributeData';
import { Attributes, DEFAULT_COLOR, DEFAULT_EXT, UnderlineStyle } from 'common/buffer/Constants';
import { NULL_COLOR, channels, color, rgba } from 'common/primitives/Color';
import { FourKeyMap } from 'common/primitives/MultiKeyMap';
import { IdleTaskQueue } from 'common/primitives/TaskQueue';
import { IColor } from 'common/primitives/Types';
import { AttributeData } from 'common/primitives/buffer/AttributeData';
import { Attributes, DEFAULT_COLOR, DEFAULT_EXT, UnderlineStyle } from 'common/primitives/buffer/Constants';
import { ILogService, IUnicodeService } from 'common/services/Services';
import { Emitter } from 'common/Event';
import { Emitter } from 'common/primitives/Event';
/**
* A shared object which is used to draw nothing for a particular cell.
@@ -132,16 +132,12 @@ export class TextureAtlas implements ITextureAtlas {
}
}
/**
* Incremented whenever the structure of the pages array changes in a way that
* invalidates texture page indexes/coordinates cached outside the atlas (page
* merges, overflow page creation). Renderers compare this against their own
* last-seen value to decide when to rebuild their models; the atlas is shared
* across terminals, so a consume-once flag would only repair the first
* renderer to draw (see the shared-atlas garble in vscode#322756).
*/
private _pagesVersion = 0;
public get pagesVersion(): number { return this._pagesVersion; }
private _requestClearModel = false;
public beginFrame(): boolean {
const result = this._requestClearModel;
this._requestClearModel = false;
return result;
}
public clearTexture(): void {
if (this._pages[0].currentRow.x === 0 && this._pages[0].currentRow.y === 0) {
@@ -161,7 +157,7 @@ export class TextureAtlas implements ITextureAtlas {
// animation frame which would result in blank rendered areas. This is actually not that
// expensive relative to drawing the glyphs, so there is no need to wait for an idle callback.
if (TextureAtlas.maxAtlasPages && this._pages.length >= Math.max(4, TextureAtlas.maxAtlasPages)) {
// Find the set of the largest images, below the maximum size, with the highest
// Find the set of the largest 4 images, below the maximum size, with the highest
// percentages used
const pagesBySize = this._pages.filter(e => {
return e.canvas.width * 2 <= (TextureAtlas.maxTextureSize || Constants.FORCED_MAX_TEXTURE_SIZE);
@@ -171,55 +167,48 @@ export class TextureAtlas implements ITextureAtlas {
}
return b.percentageUsed - a.percentageUsed;
});
// Find the largest group (up to 4) of same-sized pages, preferring larger page sizes. A
// group of 2 or 3 still reduces (or at worst maintains) the page count net of the new page
// pushed below; growing past the cap is never an option as GlyphRenderer's texture and
// shader sampler arrays are sized to exactly maxAtlasPages (exceeding them crashes render).
let bestGroupStart = -1;
let bestGroupSize = 0;
let groupStart = 0;
for (let i = 1; i <= pagesBySize.length; i++) {
if (i === pagesBySize.length || pagesBySize[i].canvas.width !== pagesBySize[groupStart].canvas.width) {
const groupSize = Math.min(4, i - groupStart);
if (groupSize > bestGroupSize) {
bestGroupSize = groupSize;
bestGroupStart = groupStart;
if (groupSize === 4) {
break;
}
}
groupStart = i;
let sameSizeI = -1;
let size = 0;
for (let i = 0; i < pagesBySize.length; i++) {
if (pagesBySize[i].canvas.width !== size) {
sameSizeI = i;
size = pagesBySize[i].canvas.width;
} else if (i - sameSizeI === 3) {
break;
}
}
if (bestGroupSize >= 2) {
// Gather details of the merge
const mergingPages = pagesBySize.slice(bestGroupStart, bestGroupStart + bestGroupSize);
const sortedMergingPagesIndexes = mergingPages.map(e => this._pages.indexOf(e)).sort((a, b) => a - b);
const mergedPageIndex = this.pages.length - mergingPages.length;
// Gather details of the merge
const mergingPages = pagesBySize.slice(sameSizeI, sameSizeI + 4);
// Merge into the new page
const mergedPage = this._mergePages(mergingPages, mergedPageIndex);
mergedPage.version = ++AtlasPage.nextVersion;
// Delete the pages, shifting glyph texture pages as needed
for (let i = sortedMergingPagesIndexes.length - 1; i >= 0; i--) {
this._deletePage(sortedMergingPagesIndexes[i]);
}
// Add the new merged page to the end
this.pages.push(mergedPage);
// Invalidate models so all texture pages are refreshed.
this._pagesVersion++;
this._onAddTextureAtlasCanvas.fire(mergedPage.canvas);
} else {
// No two same-sized pages below the maximum size exist, so merging cannot reduce the
// page count. Evict all pages rather than exceed the renderers' fixed texture/sampler
// capacity; glyphs re-rasterize on demand and models rebuild via pagesVersion.
this._evictAllPages();
// Only proceed with merge if we have exactly 4 same-sized pages. If not, we cannot
// effectively reduce page count and merging would cause issues.
if (mergingPages.length < 4 || mergingPages.some(p => p.canvas.width !== mergingPages[0].canvas.width)) {
const newPage = new AtlasPage(this._document, this._textureSize);
this._pages.push(newPage);
this._activePages.push(newPage);
this._onAddTextureAtlasCanvas.fire(newPage.canvas);
return newPage;
}
const sortedMergingPagesIndexes = mergingPages.map(e => e.glyphs[0].texturePage).sort((a, b) => a - b);
const mergedPageIndex = this.pages.length - mergingPages.length;
// Merge into the new page
const mergedPage = this._mergePages(mergingPages, mergedPageIndex);
mergedPage.version = ++AtlasPage.nextVersion;
// Delete the pages, shifting glyph texture pages as needed
for (let i = sortedMergingPagesIndexes.length - 1; i >= 0; i--) {
this._deletePage(sortedMergingPagesIndexes[i]);
}
// Add the new merged page to the end
this.pages.push(mergedPage);
// Request the model to be cleared to refresh all texture pages.
this._requestClearModel = true;
this._onAddTextureAtlasCanvas.fire(mergedPage.canvas);
}
// All new atlas pages are created small as they are highly dynamic
@@ -269,27 +258,6 @@ export class TextureAtlas implements ITextureAtlas {
}
}
/**
* Removes every page and clears the glyph caches. This is the last resort when the page cap is
* reached but no same-sized pages exist to merge: the page count must never exceed
* maxAtlasPages because renderers size their texture and shader sampler arrays to exactly
* that. Glyphs re-rasterize on demand and renderers rebuild their models via
* {@link pagesVersion}.
*/
private _evictAllPages(): void {
for (const page of this._pages) {
this._onRemoveTextureAtlasCanvas.fire(page.canvas);
page.canvas.remove();
}
this._pages.length = 0;
this._activePages.length = 0;
this._overflowSizePage = undefined;
this._cacheMap.clear();
this._cacheMapCombined.clear();
this._didWarmUp = false;
this._pagesVersion++;
}
public getRasterizedGlyphCombinedChar(chars: string, bg: number, fg: number, ext: number, restrictToCellHeight: boolean, domContainer: HTMLElement | undefined): IRasterizedGlyph {
return this._getFromCacheMap(this._cacheMapCombined, chars, bg, fg, ext, restrictToCellHeight, domContainer);
}
@@ -850,8 +818,8 @@ export class TextureAtlas implements ITextureAtlas {
this._overflowSizePage = new AtlasPage(this._document, this._config.deviceMaxTextureSize);
this.pages.push(this._overflowSizePage);
// Invalidate models so all texture pages are refreshed.
this._pagesVersion++;
// Request the model to be cleared to refresh all texture pages.
this._requestClearModel = true;
this._onAddTextureAtlasCanvas.fire(this._overflowSizePage.canvas);
}
activePage = this._overflowSizePage;
@@ -1131,7 +1099,7 @@ class AtlasPage {
sourcePages[2]._usedPixels +
sourcePages[3]._usedPixels;
} else {
// 2- and 3-page merges, used when no 4-page same-size set exists at the page cap
// fallback for non quadmerges (should never be used)
for (let i = 0; i < sourcePages.length; ++i) {
this._glyphs = this._glyphs.concat(sourcePages[i].glyphs);
this._usedPixels += sourcePages[i]._usedPixels;
+5 -8
View File
@@ -6,8 +6,8 @@
import { FontWeight } from '@xterm/xterm';
import { IColorSet } from 'browser/Types';
import { ISelectionRenderModel } from 'browser/renderer/shared/Types';
import { CursorInactiveStyle, CursorStyle, type IDisposable } from 'common/Types';
import type { IEvent } from 'common/Event';
import { CursorInactiveStyle, CursorStyle, type IDisposable } from 'common/primitives/Types';
import type { IEvent } from 'common/primitives/Event';
export interface IRenderModel {
cells: Uint32Array;
@@ -68,13 +68,10 @@ export interface ITextureAtlas extends IDisposable {
warmUp(): void;
/**
* Incremented whenever the pages array changes structurally (page merge,
* overflow page creation), invalidating any texture page indexes/coordinates
* cached by renderers. Tracked as a version rather than a consumable flag
* because the atlas may be shared by multiple renderers, each of which must
* notice the change independently.
* Call when a frame is being drawn, this will return true if the atlas was cleared to make room
* for a new set of glyphs.
*/
readonly pagesVersion: number;
beginFrame(): boolean;
/**
* Clear all glyphs from the texture atlas.
+3 -3
View File
@@ -7,12 +7,12 @@ import type { ITerminalAddon, Terminal } from '@xterm/xterm';
import type { IWebglAddonOptions, WebglAddon as IWebglApi } from '@xterm/addon-webgl';
import { ICharacterJoinerService, ICharSizeService, ICoreBrowserService, IRenderService, IThemeService } from 'browser/services/Services';
import { ITerminal } from 'browser/Types';
import { Disposable, toDisposable } from 'common/Lifecycle';
import { getSafariVersion, isSafari } from 'common/Platform';
import { Disposable, toDisposable } from 'common/primitives/Lifecycle';
import { getSafariVersion, isSafari } from 'common/primitives/Platform';
import { ICoreService, IDecorationService, ILogService, IOptionsService } from 'common/services/Services';
import { IWebGL2RenderingContext } from './Types';
import { WebglRenderer } from './WebglRenderer';
import { Emitter, EventUtils } from 'common/Event';
import { Emitter, EventUtils } from 'common/primitives/Event';
export class WebglAddon extends Disposable implements ITerminalAddon, IWebglApi {
private _terminal?: Terminal;
+6 -6
View File
@@ -10,10 +10,10 @@ import { CursorBlinkStateManager } from './CursorBlinkStateManager';
import { observeDevicePixelDimensions } from './DevicePixelObserver';
import { IRenderDimensions, IRenderer, IRequestRedrawEvent } from 'browser/renderer/shared/Types';
import { ICharSizeService, ICharacterJoinerService, ICoreBrowserService, IThemeService } from 'browser/services/Services';
import { CharData, IBufferLine, ICellData } from 'common/buffer/Types';
import { AttributeData } from 'common/buffer/AttributeData';
import { CellData } from 'common/buffer/CellData';
import { Attributes, Content, FgFlags, NULL_CELL_CHAR, NULL_CELL_CODE } from 'common/buffer/Constants';
import { CharData, IBufferLine, ICellData } from 'common/primitives/buffer/Types';
import { AttributeData } from 'common/primitives/buffer/AttributeData';
import { CellData } from 'common/primitives/buffer/CellData';
import { Attributes, Content, FgFlags, NULL_CELL_CHAR, NULL_CELL_CODE } from 'common/primitives/buffer/Constants';
import { TextBlinkStateManager } from 'browser/renderer/shared/TextBlinkStateManager';
import { ICoreService, IDecorationService, ILogService, IOptionsService } from 'common/services/Services';
import { Terminal } from '@xterm/xterm';
@@ -23,9 +23,9 @@ import { COMBINED_CHAR_BIT_MASK, RenderModel, RenderModelConstants } from './Ren
import { IWebGL2RenderingContext, type ITextureAtlas } from './Types';
import { LinkRenderLayer } from './renderLayer/LinkRenderLayer';
import { IRenderLayer } from './renderLayer/Types';
import { Emitter, EventUtils } from 'common/Event';
import { Emitter, EventUtils } from 'common/primitives/Event';
import { addDisposableListener } from 'browser/Dom';
import { combinedDisposable, Disposable, MutableDisposable, toDisposable } from 'common/Lifecycle';
import { combinedDisposable, Disposable, MutableDisposable, toDisposable } from 'common/primitives/Lifecycle';
import { createRenderDimensions } from 'browser/renderer/shared/RendererUtils';
const enum Constants {
@@ -7,8 +7,8 @@ import { ReadonlyColorSet } from 'browser/Types';
import { acquireTextureAtlas } from '../CharAtlasCache';
import { IRenderDimensions } from 'browser/renderer/shared/Types';
import { ICoreBrowserService, IThemeService } from 'browser/services/Services';
import { Disposable, toDisposable } from 'common/Lifecycle';
import { CellData } from 'common/buffer/CellData';
import { Disposable, toDisposable } from 'common/primitives/Lifecycle';
import { CellData } from 'common/primitives/buffer/CellData';
import { IOptionsService } from 'common/services/Services';
import { Terminal } from '@xterm/xterm';
import { IRenderLayer } from './Types';
@@ -1,104 +0,0 @@
/**
* Copyright (c) 2025 The xterm.js authors. All rights reserved.
* @license MIT
*
* Reproduces the single-terminal WebGL crash/garble when the texture atlas
* page count overflows TextureAtlas.maxAtlasPages (vscode#322756 class).
*
* GlyphRenderer sizes its GL texture array and fragment-shader sampler array
* to exactly maxAtlasPages at construction time, but TextureAtlas._createNewPage
* pushes past that cap whenever a 4-page same-size merge is impossible (e.g. a
* heterogeneous mix like 1024+512+512+512). The next GlyphRenderer.render then
* throws "Cannot read properties of undefined (reading 'version')" and cells
* reference sampler indexes the shader does not have, freezing/garbling the
* terminal. Long heavy-CLI sessions hit this in production; the test makes it
* fast by building the renderer with a small cap (the same code path as the
* production 8/16/32 values).
*
* Chromium only (additive scope; Firefox/WebKit WebGL broken in CI, xtermjs#5854).
*/
import test, { expect } from '@playwright/test';
import { ITestContext, createTestContext, openTerminal } from '../../../test/playwright/TestUtils';
import {
captureRowSignatures,
expectSignatureMatches,
loadWebglStrict,
resetMaxAtlasPages,
setMaxAtlasPages,
writeAndWaitForRender
} from '../../../test/playwright/RendererTestUtils';
import { generateUniqueGlyphFlood } from '../../../test/playwright/SyntheticTui';
const HEADER = ' OVERFLOW_REF_0123456789';
const HEADER_COLS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
test.describe('atlas page overflow (#322756 class)', () => {
test.skip(({ browserName }) => browserName !== 'chromium');
test.describe.configure({ timeout: 60000 });
test('renderer survives the atlas exceeding maxAtlasPages-sized textures', async ({ browser }) => {
const ctx: ITestContext = await createTestContext(browser);
const errors: string[] = [];
const onError = (e: Error): void => { errors.push(e.message); };
ctx.page.on('pageerror', onError);
try {
// Bootstrap: create a throwaway WebGL terminal so the TextureAtlas class
// statics exist, then lower the page cap. openTerminal() disposes the old
// terminal (and its atlas), so the next WebGL renderer is CONSTRUCTED
// with the small cap: its GL texture array and fragment-shader sampler
// array have exactly 4 entries, faithfully mirroring production where
// they always equal maxAtlasPages.
await openTerminal(ctx, { cols: 80, rows: 24 });
await loadWebglStrict(ctx);
await setMaxAtlasPages(ctx, 4);
await openTerminal(ctx, { cols: 80, rows: 24 });
await loadWebglStrict(ctx);
const atlasTexturesLength = await ctx.page.evaluate(() =>
(window as any).term._core._renderService._renderer.value._glyphRenderer.value._atlasTextures.length);
expect(atlasTexturesLength, 'renderer must be built with the lowered page cap').toBe(4);
// Pinned header in the alt buffer; body churns distinct CJK glyphs below
// (cursor-positioned, no trailing linefeed on the bottom row -> no scroll).
await writeAndWaitForRender(ctx, `\x1b[?1049h\x1b[H${HEADER}`);
const reference = await captureRowSignatures(ctx, 1, HEADER_COLS);
await ctx.page.locator('#terminal-container .xterm-screen').screenshot({ path: 'out-esbuild-test/playwright/overflow-before.png' });
const glyphsPerChunk = 23 * 40 - 1;
for (let c = 0; c < 16; c++) {
// Plain write + short wait instead of waiting for a render event: once
// the overflow crash fires, render events stop arriving and a render
// wait would hang the test instead of failing it.
await ctx.proxy.write('\x1b[2;1H' + generateUniqueGlyphFlood(glyphsPerChunk, 80, c * glyphsPerChunk));
await ctx.page.waitForTimeout(50);
}
await ctx.page.waitForTimeout(300);
await ctx.page.locator('#terminal-container .xterm-screen').screenshot({ path: 'out-esbuild-test/playwright/overflow-after.png' });
const state = await ctx.page.evaluate(() => {
const renderer = (window as any).term._core._renderService._renderer.value;
return {
pages: renderer._charAtlas.pages.length,
atlasTextures: renderer._glyphRenderer.value._atlasTextures.length
};
});
console.error('[overflow] pages=', state.pages, 'atlasTextures=', state.atlasTextures, 'pageErrors=', errors.length, errors[0] ?? '');
// Contract: the page count must never exceed the renderer's texture and
// sampler capacity, and rendering must never throw.
expect(errors, `GlyphRenderer must not crash when the atlas is saturated: ${errors[0] ?? ''}`).toEqual([]);
expect(state.pages, 'atlas page count must stay within the renderer texture capacity').toBeLessThanOrEqual(state.atlasTextures);
// The untouched header must still render correctly after the churn.
const after = await captureRowSignatures(ctx, 1, HEADER_COLS);
for (let i = 0; i < HEADER_COLS.length; i++) {
expectSignatureMatches(after[i], reference[i], 14, `header col ${HEADER_COLS[i]} corrupted after atlas saturation`);
}
} finally {
ctx.page.off('pageerror', onError);
// Restore the default so a lowered cap can never leak into other tests.
await resetMaxAtlasPages(ctx).catch(() => { /* page may already be unusable after a crash */ });
await ctx.page.close();
}
});
});
@@ -1,109 +0,0 @@
/**
* Copyright (c) 2025 The xterm.js authors. All rights reserved.
* @license MIT
*
* WebGL device-pixel-ratio (HiDPI) and font-size ("resize") atlas tests.
*
* A devicePixelRatio > 1 and font-size changes both change the device cell
* dimensions, which key the texture atlas cache and force the atlas to be
* rebuilt. Historically these paths have produced blank/oversized/garbled glyphs
* (e.g. xtermjs#4728, #5915/#5929). These tests assert glyphs render and stay
* correct across those transitions.
*
* Chromium + SwiftShader only (additive scope; Firefox/WebKit WebGL broken in CI
* per xtermjs#5854).
*/
import test, { Browser, expect } from '@playwright/test';
import { ITestContext, TerminalProxy, openTerminal } from '../../../test/playwright/TestUtils';
import {
assertTextureAtlasPresent,
captureRowSignatures,
expectSignatureMatches,
loadWebglStrict,
waitForRender,
writeAndWaitForRender
} from '../../../test/playwright/RendererTestUtils';
const REFERENCE_COLS = [1, 2, 3, 4, 5, 6, 7, 8];
/**
* Creates a test context whose page uses a specific devicePixelRatio. The shared
* `createTestContext` helper always uses DPR 1 (`browser.newPage()`), so HiDPI
* tests build their own context here.
*/
async function createDprContext(browser: Browser, deviceScaleFactor: number): Promise<ITestContext> {
const context = await browser.newContext({ deviceScaleFactor });
const page = await context.newPage();
page.on('pageerror', e => console.error(`[dpr ${deviceScaleFactor}]`, e));
await page.goto('/test');
const proxy = new TerminalProxy(page);
proxy.initPage();
return {
browser,
page,
termHandle: await page.evaluateHandle('window.term'),
proxy
};
}
test.describe('WebGL HiDPI (devicePixelRatio) rendering', () => {
test.skip(({ browserName }) => browserName !== 'chromium', 'WebGL atlas tests run on Chromium/SwiftShader only');
test('initializes the WebGL renderer and scales to device pixels at devicePixelRatio 2', async ({ browser }) => {
const ctx = await createDprContext(browser, 2);
try {
await openTerminal(ctx, { cols: 80, rows: 24 });
// GPU must be genuinely active at HiDPI (asserted inside loadWebglStrict).
await loadWebglStrict(ctx);
await writeAndWaitForRender(ctx, 'A W .');
await assertTextureAtlasPresent(ctx);
// The WebGL renderer must render at the device resolution: device cell
// dimensions should be ~2x the CSS cell dimensions. This catches the
// DPR-scaling class of bugs (e.g. xtermjs#4728) without relying on
// screenshotting a WebGL canvas at a non-1 device scale factor.
const dims = await ctx.proxy.core.renderDimensions;
expect(dims.device.cell.width).toBeGreaterThan(dims.css.cell.width * 1.8);
expect(dims.device.cell.width).toBeLessThan(dims.css.cell.width * 2.2);
expect(dims.device.cell.height).toBeGreaterThan(dims.css.cell.height * 1.8);
expect(dims.device.cell.height).toBeLessThan(dims.css.cell.height * 2.2);
} finally {
await ctx.page.context().close();
}
});
});
test.describe('WebGL font-size change atlas integrity', () => {
let ctx: ITestContext;
test.skip(({ browserName }) => browserName !== 'chromium', 'WebGL atlas tests run on Chromium/SwiftShader only');
test.beforeAll(async ({ browser }) => {
ctx = await createDprContext(browser, 1);
});
test.afterAll(async () => await ctx.page.close());
test.beforeEach(async () => {
await openTerminal(ctx, { cols: 80, rows: 24, fontSize: 15 });
await loadWebglStrict(ctx);
});
test('glyphs stay correct after cycling font size (atlas rebuilds)', async () => {
await writeAndWaitForRender(ctx, 'FontRef0123456789');
const reference = await captureRowSignatures(ctx, 1, REFERENCE_COLS);
// Changing font size changes device cell dimensions -> the atlas is rebuilt.
for (const fontSize of [12, 18, 21, 15]) {
await ctx.proxy.setOption('fontSize', fontSize);
await writeAndWaitForRender(ctx, '\r\nchurn');
}
// Back at the original font size the reference glyphs must be unchanged.
await ctx.proxy.scrollToTop();
await waitForRender(ctx);
const after = await captureRowSignatures(ctx, 1, REFERENCE_COLS);
for (let i = 0; i < REFERENCE_COLS.length; i++) {
expectSignatureMatches(after[i], reference[i], 16, `reference glyph at col ${REFERENCE_COLS[i]} corrupted after font-size cycling`);
}
});
});
-121
View File
@@ -1,121 +0,0 @@
/**
* Copyright (c) 2025 The xterm.js authors. All rights reserved.
* @license MIT
*
* WebGL glyph + texture-atlas integrity tests.
*
* These tests verify that *glyphs* render correctly (not just that cell colors
* are right) under conditions that stress the texture atlas: multiple atlas
* pages, page merges and atlas clears. The goal is to catch the "garbled glyph"
* corruption class reported in microsoft/vscode#322756.
*
* Note: CI runs WebGL on Chromium + SwiftShader (software WebGL). That catches
* renderer/atlas *logic* corruption (stale texture pages, missing model clears),
* but not GPU-driver-specific glitches. These tests target the former.
*/
import test, { expect } from '@playwright/test';
import { ITestContext, createTestContext, openTerminal } from '../../../test/playwright/TestUtils';
import {
assertTextureAtlasPresent,
captureRowSignatures,
expectSignatureDiffers,
expectSignatureMatches,
floodDistinctGlyphs,
loadWebglStrict,
resetMaxAtlasPages,
setMaxAtlasPages,
waitForRender,
writeAndWaitForRender
} from '../../../test/playwright/RendererTestUtils';
let ctx: ITestContext;
test.beforeAll(async ({ browser }) => {
ctx = await createTestContext(browser);
});
test.afterAll(async () => await ctx.page.close());
test.describe('WebGL glyph + atlas integrity', () => {
// Additive scope: only run on Chromium (SwiftShader). Firefox/WebKit WebGL
// tests are known-broken in CI (xtermjs#5854) and out of scope here.
test.skip(({ browserName }) => browserName !== 'chromium', 'WebGL atlas tests run on Chromium/SwiftShader only');
test.beforeEach(async () => {
// Fresh terminal (and therefore a predictable atlas) per test.
await openTerminal(ctx, { cols: 80, rows: 24 });
await loadWebglStrict(ctx);
});
// A lowered page cap must not leak into renderers built by later tests.
test.afterEach(async () => await resetMaxAtlasPages(ctx));
test('renders distinct, non-blank glyphs', async () => {
await writeAndWaitForRender(ctx, 'A W .');
await assertTextureAtlasPresent(ctx);
const [a, w, dot, blank] = await captureRowSignatures(ctx, 1, [1, 3, 5, 40]);
// A written cell must differ from an empty cell (glyph actually drawn).
expectSignatureDiffers(a, blank, 24, 'glyph "A" should not be blank');
expectSignatureDiffers(w, blank, 24, 'glyph "W" should not be blank');
// Different glyphs must look different (signature has discriminating power).
expectSignatureDiffers(a, w, 24, 'glyphs "A" and "W" should render differently');
expectSignatureDiffers(a, dot, 24, 'glyphs "A" and "." should render differently');
});
test('glyphs on the first atlas page stay correct after more pages are allocated', async () => {
// Reference: a known row of glyphs that lands on the first atlas page.
await writeAndWaitForRender(ctx, 'REFERENCE_LINE_0123456789\r\n');
const cols = [1, 2, 3, 4, 5, 6, 7, 8, 9];
const reference = await captureRowSignatures(ctx, 1, cols);
// Flood thousands of distinct glyphs (one screenful rendered at a time, so
// they actually rasterize) to force multiple atlas pages.
const pages = await floodDistinctGlyphs(ctx, 4);
expect(pages, 'flooding distinct glyphs should allocate more than one atlas page').toBeGreaterThan(1);
// Bring the reference line back into view and re-check its glyphs.
await ctx.proxy.scrollToTop();
await waitForRender(ctx);
const after = await captureRowSignatures(ctx, 1, cols);
for (let i = 0; i < cols.length; i++) {
expectSignatureMatches(after[i], reference[i], 14, `reference glyph at col ${cols[i]} corrupted after multi-page allocation`);
}
});
test('glyphs stay correct after a texture-atlas page merge', async () => {
// Force merges to happen almost immediately.
await writeAndWaitForRender(ctx, 'MERGE_REF_LINE_0123456789\r\n');
await setMaxAtlasPages(ctx, 4);
const cols = [1, 2, 3, 4, 5, 6, 7, 8, 9];
const reference = await captureRowSignatures(ctx, 1, cols);
// Flood distinct glyphs (rendered per screenful) to exceed the tiny page cap
// and trigger merges.
const pages = await floodDistinctGlyphs(ctx, 12);
expect(pages, 'flood should have allocated multiple atlas pages (and merged)').toBeGreaterThan(1);
await ctx.proxy.scrollToTop();
await waitForRender(ctx);
const after = await captureRowSignatures(ctx, 1, cols);
for (let i = 0; i < cols.length; i++) {
expectSignatureMatches(after[i], reference[i], 14, `reference glyph at col ${cols[i]} corrupted after atlas page merge`);
}
});
test('glyphs re-render correctly after clearTextureAtlas() on the same terminal', async () => {
await writeAndWaitForRender(ctx, 'CLEAR_REF_LINE_0123456789');
const cols = [1, 2, 3, 4, 5, 6, 7, 8, 9];
const reference = await captureRowSignatures(ctx, 1, cols);
await ctx.proxy.clearTextureAtlas();
// Force a full redraw so glyphs are re-rasterized into the cleared atlas.
await ctx.proxy.refresh(0, (await ctx.proxy.rows) - 1);
await waitForRender(ctx);
const after = await captureRowSignatures(ctx, 1, cols);
for (let i = 0; i < cols.length; i++) {
expectSignatureMatches(after[i], reference[i], 14, `glyph at col ${cols[i]} corrupted after clearTextureAtlas()`);
}
});
});
@@ -1,65 +0,0 @@
/**
* Copyright (c) 2025 The xterm.js authors. All rights reserved.
* @license MIT
*
* Single-terminal guard for the vscode#322756 "garbled glyph" class: a pinned
* alt-buffer header must render identically while the body churns enough
* distinct colored glyphs to force texture-atlas page merges.
*
* Note this scenario is GREEN on current master: the single-terminal mid-frame
* merge race was fixed upstream (merge-retry loop in WebglRenderer.renderRows +
* globally monotonic AtlasPage versions). The test asserts the buffer content
* first so a content bug (e.g. an accidental scroll from the churn stream) can
* never masquerade as renderer corruption.
*/
import test, { expect } from '@playwright/test';
import { ITestContext, createTestContext, openTerminal } from '../../../test/playwright/TestUtils';
import { captureRowSignatures, expectSignatureMatches, getAtlasPageCount, loadWebglStrict, resetMaxAtlasPages, setMaxAtlasPages, writeAndWaitForRender } from '../../../test/playwright/RendererTestUtils';
import { generateColoredAsciiFlood } from '../../../test/playwright/SyntheticTui';
const HEADER = ' HEADER_REF_0123456789';
let ctx: ITestContext;
test.beforeAll(async ({ browser }) => { ctx = await createTestContext(browser); });
test.afterAll(async () => await ctx.page.close());
test.describe('single-terminal merge integrity (#322756 class)', () => {
test.skip(({ browserName }) => browserName !== 'chromium');
test.describe.configure({ timeout: 60000 });
// A lowered page cap must not leak into renderers built by later tests.
test.afterEach(async () => await resetMaxAtlasPages(ctx));
test('pinned header renders identically across 30 merge-heavy body redraws', async () => {
await openTerminal(ctx, { cols: 80, rows: 24 });
await loadWebglStrict(ctx);
await setMaxAtlasPages(ctx, 4);
const cols = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
// Alt-buffer TUI: pinned header on row 1, body churns below (like Copilot CLI).
await writeAndWaitForRender(ctx, `\x1b[?1049h\x1b[H${HEADER}`);
const ref = await captureRowSignatures(ctx, 1, cols);
let maxDiff = 0;
for (let c = 0; c < 30; c++) {
// Redraw body rows 2..24 with unique glyphs; the header row is never touched.
let frame = '\x1b[2;1H';
frame += generateColoredAsciiFlood(23 * 78, c * 23 * 78);
await writeAndWaitForRender(ctx, frame);
const now = await captureRowSignatures(ctx, 1, cols); // forces GPU sync
for (let i = 0; i < cols.length; i++) {
const d = Math.max(...ref[i].map((v, k) => Math.abs(v - now[i][k])));
maxDiff = Math.max(maxDiff, d);
}
}
console.error('[repro] pages=', await getAtlasPageCount(ctx), 'headerMaxDiff=', maxDiff);
// Guard: the header must still be in the buffer. If this fails the churn
// stream scrolled the screen and any pixel diff is meaningless.
const row1Text = await ctx.page.evaluate(() => (window as any).term.buffer.active.getLine(0)?.translateToString(true));
expect(row1Text, 'churn stream must not scroll the pinned header out of the buffer').toBe(HEADER);
const after = await captureRowSignatures(ctx, 1, cols);
for (let i = 0; i < cols.length; i++) {
expectSignatureMatches(after[i], ref[i], 14, `header col ${cols[i]} garbled`);
}
});
});
@@ -1,159 +0,0 @@
/**
* Copyright (c) 2025 The xterm.js authors. All rights reserved.
* @license MIT
*
* Reproduces the vscode#322756 "garbled glyph" corruption across terminals that
* SHARE a texture atlas (CharAtlasCache hands the same TextureAtlas to every
* terminal with an equal config — in VS Code that is every integrated terminal
* using the same font settings, including task/background terminals).
*
* Mechanism: when the atlas merges pages it raises a consume-once
* "clear model" flag (TextureAtlas.beginFrame). Only the FIRST terminal to
* render consumes it and rebuilds its vertex model; every other terminal keeps
* stale texture-page indexes/coordinates in its vertex buffer and draws wrong
* glyphs on its next partial render, even though its buffer content is intact.
*
* The DOM-renderer control shows the corruption is exclusive to the GPU path
* (`terminal.integrated.gpuAcceleration off` cannot reproduce it: the DOM
* renderer has no texture atlas).
*
* Chromium only (additive scope; Firefox/WebKit WebGL broken in CI, xtermjs#5854).
*/
import test, { expect } from '@playwright/test';
import { ITestContext, createTestContext, openTerminal } from '../../../test/playwright/TestUtils';
import {
captureRowSignatures,
expectSignatureMatches,
getAtlasPageCount,
loadWebglStrict,
setMaxAtlasPages,
writeAndWaitForRender
} from '../../../test/playwright/RendererTestUtils';
import { generateColoredAsciiFlood } from '../../../test/playwright/SyntheticTui';
const HEADER = ' HEADER_REF_0123456789';
const HEADER_COLS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const TERM_B_SELECTOR = '#terminal-container-b .xterm-screen';
/**
* Creates a second terminal ("termB") on the test page with the given options
* and optionally loads the WebGL addon on it. Identical rendering options mean
* CharAtlasCache gives it the same atlas instance as `window.term`.
*/
async function createTerminalB(ctx: ITestContext, options: { useWebgl: boolean }): Promise<void> {
await ctx.page.evaluate(async (useWebgl) => {
const w = window as any;
w.termB?.dispose();
document.getElementById('terminal-container-b')?.remove();
const el = document.createElement('div');
el.id = 'terminal-container-b';
document.body.appendChild(el);
w.termB = new w.Terminal({ cols: 80, rows: 24, allowProposedApi: true });
w.termB.open(el);
if (useWebgl) {
w.addonB = new w.WebglAddon({ preserveDrawingBuffer: true });
w.termB.loadAddon(w.addonB);
}
}, options.useWebgl);
}
/** Writes data to termB and resolves after its next render event. */
async function writeToBAndWaitForRender(ctx: ITestContext, data: string): Promise<void> {
await ctx.page.evaluate(d => new Promise<void>(resolve => {
const termB = (window as any).termB;
const disposable = termB.onRender(() => {
disposable.dispose();
resolve();
});
termB.write(d);
}), data);
}
async function getTermBRow1Text(ctx: ITestContext): Promise<string | undefined> {
return ctx.page.evaluate(() => (window as any).termB.buffer.active.getLine(0)?.translateToString(true));
}
test.describe('shared-atlas garble across terminals (#322756)', () => {
test.skip(({ browserName }) => browserName !== 'chromium');
test.describe.configure({ timeout: 60000 });
test('terminal B keeps rendering its header correctly while terminal A forces atlas merges', async ({ browser }) => {
const ctx: ITestContext = await createTestContext(browser);
try {
await openTerminal(ctx, { cols: 80, rows: 24 });
await loadWebglStrict(ctx);
await createTerminalB(ctx, { useWebgl: true });
// Both terminals must be using the same atlas instance for this test to
// mean anything.
const atlasShared = await ctx.page.evaluate(() => {
const w = window as any;
const atlasA = w.term._core._renderService._renderer.value._charAtlas;
const atlasB = w.termB._core._renderService._renderer.value._charAtlas;
return !!atlasA && atlasA === atlasB;
});
expect(atlasShared, 'terminals with equal configs should share one texture atlas').toBe(true);
// Lower the cap AFTER both renderers exist so their shaders/texture
// arrays keep the original size (this test targets stale vertex data,
// not the page-overflow crash).
await setMaxAtlasPages(ctx, 4);
// Render B's header pre-merge and capture its reference pixels.
await writeToBAndWaitForRender(ctx, HEADER);
await ctx.page.locator(TERM_B_SELECTOR).screenshot({ path: 'out-esbuild-test/playwright/termB-before.png' });
const reference = await captureRowSignatures(ctx, 1, HEADER_COLS, { selector: TERM_B_SELECTOR, termGlobal: 'termB' });
// Churn terminal A with distinct colored glyphs to force page merges in
// the SHARED atlas. A repairs itself (it consumes the clear-model flag);
// B is never told.
for (let c = 0; c < 10; c++) {
await writeAndWaitForRender(ctx, '\x1b[2;1H' + generateColoredAsciiFlood(23 * 78, c * 23 * 78));
}
const pages = await getAtlasPageCount(ctx);
expect(pages, 'churn should have exercised multiple atlas pages').toBeGreaterThan(1);
// A tiny unrelated update to B's LAST row triggers a partial render in B.
// B's header row is untouched; with a healthy renderer its pixels must
// not change.
await writeToBAndWaitForRender(ctx, '\x1b[24;1Hx');
await ctx.page.locator(TERM_B_SELECTOR).screenshot({ path: 'out-esbuild-test/playwright/termB-after.png' });
// Guard: B's buffer content is intact, so any pixel change is renderer
// corruption by construction.
expect(await getTermBRow1Text(ctx), 'terminal B buffer must still contain the header').toBe(HEADER);
const after = await captureRowSignatures(ctx, 1, HEADER_COLS, { selector: TERM_B_SELECTOR, termGlobal: 'termB' });
for (let i = 0; i < HEADER_COLS.length; i++) {
expectSignatureMatches(after[i], reference[i], 14, `terminal B header col ${HEADER_COLS[i]} garbled by terminal A's atlas merges`);
}
} finally {
await ctx.page.close();
}
});
test('DOM renderer control: same workload cannot garble terminal B (no atlas without GPU acceleration)', async ({ browser }) => {
const ctx: ITestContext = await createTestContext(browser);
try {
// No WebGL addon on either terminal -> DOM renderer -> no texture atlas.
await openTerminal(ctx, { cols: 80, rows: 24 });
await createTerminalB(ctx, { useWebgl: false });
await writeToBAndWaitForRender(ctx, HEADER);
const reference = await captureRowSignatures(ctx, 1, HEADER_COLS, { selector: TERM_B_SELECTOR, termGlobal: 'termB' });
for (let c = 0; c < 10; c++) {
await writeAndWaitForRender(ctx, '\x1b[2;1H' + generateColoredAsciiFlood(23 * 78, c * 23 * 78));
}
await writeToBAndWaitForRender(ctx, '\x1b[24;1Hx');
expect(await getTermBRow1Text(ctx), 'terminal B buffer must still contain the header').toBe(HEADER);
const after = await captureRowSignatures(ctx, 1, HEADER_COLS, { selector: TERM_B_SELECTOR, termGlobal: 'termB' });
for (let i = 0; i < HEADER_COLS.length; i++) {
expectSignatureMatches(after[i], reference[i], 14, `DOM-rendered terminal B header col ${HEADER_COLS[i]} unexpectedly changed`);
}
} finally {
await ctx.page.close();
}
});
});
@@ -1,104 +0,0 @@
/**
* Copyright (c) 2025 The xterm.js authors. All rights reserved.
* @license MIT
*
* Single-terminal WebGL atlas stress: try to reproduce the "garbled glyph"
* corruption from microsoft/vscode#322756 in ONE terminal (no shared atlas),
* via heavy unique-glyph churn that forces atlas page merges, both with content
* pinned on screen (TUI-style) and mid-scroll. Chromium/SwiftShader only.
*/
import test, { expect } from '@playwright/test';
import { ITestContext, createTestContext, openTerminal } from '../../../test/playwright/TestUtils';
import {
captureRowSignatures,
expectSignatureMatches,
floodDistinctGlyphs,
getAtlasPageCount,
loadWebglStrict,
resetMaxAtlasPages,
setMaxAtlasPages,
waitForRender,
writeAndWaitForRender
} from '../../../test/playwright/RendererTestUtils';
import { generateUniqueGlyphFlood } from '../../../test/playwright/SyntheticTui';
let ctx: ITestContext;
test.beforeAll(async ({ browser }) => {
ctx = await createTestContext(browser);
});
test.afterAll(async () => await ctx.page.close());
test.describe('WebGL single-terminal heavy render + merge', () => {
test.skip(({ browserName }) => browserName !== 'chromium', 'WebGL atlas tests run on Chromium/SwiftShader only');
test.describe.configure({ timeout: 30000 });
test.beforeEach(async () => {
await openTerminal(ctx, { cols: 80, rows: 24, scrollback: 5000 });
await loadWebglStrict(ctx);
});
// A lowered page cap must not leak into renderers built by later tests.
test.afterEach(async () => await resetMaxAtlasPages(ctx));
test('heavy merge churn must not crash the GlyphRenderer (vscode#322756)', async () => {
// Guard: heavy merges must not throw from GlyphRenderer.render. Note the
// page cap here is lowered AFTER the renderer was built, so _atlasTextures
// keeps its original (large) length and this test cannot hit the
// page-overflow crash; that scenario needs the cap lowered BEFORE loading
// the addon and is covered separately (WebglAtlasOverflow.test.ts).
const errors: string[] = [];
const onError = (e: Error): void => { errors.push(e.message); };
ctx.page.on('pageerror', onError);
try {
await setMaxAtlasPages(ctx, 4);
await floodDistinctGlyphs(ctx, 10);
// Force a GPU read (screenshot) mid-churn so a render lands during/after a
// merge, then churn more — this reliably exposes the version crash.
await captureRowSignatures(ctx, 1, [1, 2, 3]);
const pages = await floodDistinctGlyphs(ctx, 10);
expect(pages, 'should have allocated/merged pages').toBeGreaterThan(1);
await ctx.page.waitForTimeout(300);
expect(errors, `renderer crashed during atlas merges: ${errors[0] ?? ''}`).toEqual([]);
} finally {
ctx.page.off('pageerror', onError);
}
});
test('pinned header stays correct while body churns many pages', async () => {
const cols = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
await writeAndWaitForRender(ctx, 'HEADER_REF_0123456789');
const reference = await captureRowSignatures(ctx, 1, cols);
// Body churns unique glyphs (forces merges) while header line stays on screen.
const pages = await floodDistinctGlyphs(ctx, 8);
expect(pages, 'should have allocated/merged pages').toBeGreaterThan(1);
await ctx.proxy.scrollToTop();
await waitForRender(ctx);
const after = await captureRowSignatures(ctx, 1, cols);
for (let i = 0; i < cols.length; i++) {
expectSignatureMatches(after[i], reference[i], 14, `header glyph col ${cols[i]} corrupted by single-terminal merges`);
}
});
test('visible rows match content while scrolling (no merge)', async () => {
// Big scrollback of distinct glyphs across multiple pages (no tiny page cap,
// so no merge), then scroll up/down repeatedly.
for (let c = 0; c < 8; c++) {
await writeAndWaitForRender(ctx, generateUniqueGlyphFlood(24 * 40, 80, c * 24 * 40));
}
expect(await getAtlasPageCount(ctx)).toBeGreaterThan(1);
await ctx.proxy.scrollToTop();
await waitForRender(ctx);
const top = await captureRowSignatures(ctx, 1, [1, 2, 3, 4, 5]);
await ctx.proxy.scrollToBottom();
await ctx.proxy.scrollToTop();
await waitForRender(ctx);
const topAgain = await captureRowSignatures(ctx, 1, [1, 2, 3, 4, 5]);
for (let i = 0; i < top.length; i++) {
expectSignatureMatches(topAgain[i], top[i], 14, `row1 col${i + 1} changed after scroll round-trip`);
}
});
});
@@ -1,152 +0,0 @@
/**
* Copyright (c) 2025 The xterm.js authors. All rights reserved.
* @license MIT
*
* WebGL "heavy TUI" stress tests: large scrollback + scrolling, alternate-buffer
* full-screen redraws (like an agent CLI animating output), high-volume
* rendering and replay of recorded real-world TUI sessions (vim, colored ls).
*
* The shared invariant: a known reference row of glyphs, captured in a fresh
* atlas, must still render identically after the stress workload. If the WebGL
* texture atlas is corrupted by the workload the reference glyphs change and the
* test fails. See microsoft/vscode#322756.
*
* Chromium + SwiftShader only (additive scope; Firefox/WebKit WebGL are broken
* in CI per xtermjs#5854).
*/
import { readFileSync } from 'fs';
import test, { expect } from '@playwright/test';
import { ITestContext, createTestContext, openTerminal } from '../../../test/playwright/TestUtils';
import {
assertTextureAtlasPresent,
captureRowSignatures,
expectSignatureMatches,
loadWebglStrict,
waitForRender,
writeAndWaitForRender
} from '../../../test/playwright/RendererTestUtils';
import { generateMixedGlyphBlock, generateSyntheticTuiFrames, generateUniqueGlyphFlood } from '../../../test/playwright/SyntheticTui';
const REFERENCE_COLS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const REFERENCE_LINE = 'Ref0123456789ABCDEF';
let ctx: ITestContext;
test.beforeAll(async ({ browser }) => {
ctx = await createTestContext(browser);
});
test.afterAll(async () => await ctx.page.close());
test.describe('WebGL heavy TUI / scrolling stress', () => {
test.skip(({ browserName }) => browserName !== 'chromium', 'WebGL stress tests run on Chromium/SwiftShader only');
test.beforeEach(async () => {
await openTerminal(ctx, { cols: 80, rows: 24, scrollback: 5000 });
await loadWebglStrict(ctx);
});
test('reference glyphs survive heavy scrolling through large scrollback', async () => {
await writeAndWaitForRender(ctx, `${REFERENCE_LINE}\r\n`);
const reference = await captureRowSignatures(ctx, 1, REFERENCE_COLS);
// Push the reference far up into scrollback with thousands of varied glyphs.
for (let i = 0; i < 20; i++) {
await ctx.proxy.write(generateMixedGlyphBlock(i + 1, 30, 70));
}
await waitForRender(ctx);
// Scroll around, then back to the very top where the reference lives.
await ctx.proxy.scrollToTop();
await waitForRender(ctx);
await ctx.proxy.scrollPages(3);
await waitForRender(ctx);
await ctx.proxy.scrollToTop();
await waitForRender(ctx);
const after = await captureRowSignatures(ctx, 1, REFERENCE_COLS);
for (let i = 0; i < REFERENCE_COLS.length; i++) {
expectSignatureMatches(after[i], reference[i], 14, `reference glyph at col ${REFERENCE_COLS[i]} corrupted after heavy scrolling`);
}
});
test('alternate-buffer TUI redraws do not corrupt the restored primary buffer', async () => {
// Reference content lives in the PRIMARY buffer.
await writeAndWaitForRender(ctx, `${REFERENCE_LINE}`);
const reference = await captureRowSignatures(ctx, 1, REFERENCE_COLS);
// Animate a synthetic agent TUI in the alternate buffer.
const frames = generateSyntheticTuiFrames({ seed: 7, frames: 30, cols: 80, rows: 24, useAltBuffer: true });
for (const frame of frames) {
await ctx.proxy.write(frame);
}
await waitForRender(ctx);
await assertTextureAtlasPresent(ctx);
// Back in the primary buffer the reference glyphs must be intact.
await ctx.proxy.refresh(0, (await ctx.proxy.rows) - 1);
await waitForRender(ctx);
const after = await captureRowSignatures(ctx, 1, REFERENCE_COLS);
for (let i = 0; i < REFERENCE_COLS.length; i++) {
expectSignatureMatches(after[i], reference[i], 14, `primary-buffer glyph at col ${REFERENCE_COLS[i]} corrupted by alt-buffer TUI redraws`);
}
});
test('reference glyphs survive a heavy mixed render + unique-glyph churn', async () => {
// Capture the reference rendering of a known line in a fresh atlas.
await writeAndWaitForRender(ctx, `${REFERENCE_LINE}`);
const reference = await captureRowSignatures(ctx, 1, REFERENCE_COLS);
// High-volume rendering: synthetic TUI frames (which clear/redraw the screen)
// plus a large unique-glyph flood to churn the atlas, mimicking a long agent
// CLI session.
const frames = generateSyntheticTuiFrames({ seed: 3, frames: 40, cols: 80, rows: 24 });
for (const frame of frames) {
await ctx.proxy.write(frame);
}
await ctx.proxy.write(generateUniqueGlyphFlood(3000, 80));
await waitForRender(ctx);
// The synthetic frames erase the screen, so re-render the reference line and
// assert the (heavily churned) atlas still draws those glyphs correctly.
await writeAndWaitForRender(ctx, `\x1b[2J\x1b[H${REFERENCE_LINE}`);
const after = await captureRowSignatures(ctx, 1, REFERENCE_COLS);
for (let i = 0; i < REFERENCE_COLS.length; i++) {
expectSignatureMatches(after[i], reference[i], 14, `reference glyph at col ${REFERENCE_COLS[i]} corrupted after heavy render`);
}
});
test('replaying recorded TUI sessions renders without errors or atlas corruption', async () => {
const pageErrors: string[] = [];
const onError = (err: Error): void => {
pageErrors.push(err.message);
};
ctx.page.on('pageerror', onError);
try {
const fixtures = [
'./test/fixtures/escape_sequence_files/t0090-alt_screen.in',
'./test/fixtures/escape_sequence_files/t0502-bash_ls_color.in',
'./test/fixtures/escape_sequence_files/t0500-bash_long_line.in',
'./test/fixtures/escape_sequence_files/t0504-vim.in'
];
for (const fixture of fixtures) {
const data = readFileSync(fixture, { encoding: 'latin1' });
await ctx.proxy.write(data);
}
await waitForRender(ctx);
await assertTextureAtlasPresent(ctx);
// Re-rendering the final frame must be idempotent (self-consistent): if the
// atlas were corrupted, a forced redraw would differ from what's shown.
const before = await captureRowSignatures(ctx, 1, REFERENCE_COLS);
await ctx.proxy.refresh(0, (await ctx.proxy.rows) - 1);
await waitForRender(ctx);
const after = await captureRowSignatures(ctx, 1, REFERENCE_COLS);
for (let i = 0; i < REFERENCE_COLS.length; i++) {
expectSignatureMatches(after[i], before[i], 14, `fixture replay frame not self-consistent at col ${REFERENCE_COLS[i]}`);
}
expect(pageErrors, `no page errors during fixture replay, got: ${pageErrors.join(', ')}`).toEqual([]);
} finally {
ctx.page.off('pageerror', onError);
}
});
});
@@ -1,65 +0,0 @@
/**
* Copyright (c) 2025 The xterm.js authors. All rights reserved.
* @license MIT
* Produces BEFORE/AFTER screenshots of a single terminal under merge-heavy
* churn for manual inspection (before.png / after.png, mono-*.png). On current
* master the single-terminal merge path is healthy, so the pinned header lines
* are expected to remain readable in the "after" images; a corrupted header in
* these captures indicates a renderer regression. Note the mono "after" body is
* SUPPOSED to look like glyph soup — that is the mixed box-drawing/braille
* payload rendered faithfully, not corruption.
*/
import test from '@playwright/test';
import { ITestContext, createTestContext, openTerminal } from '../../../test/playwright/TestUtils';
import { loadWebglStrict, setMaxAtlasPages, writeAndWaitForRender } from '../../../test/playwright/RendererTestUtils';
import { generateColoredAsciiFlood, generateMixedGlyphBlock } from '../../../test/playwright/SyntheticTui';
test.describe('visual #322756', () => {
test.skip(({ browserName }) => browserName !== 'chromium');
test.describe.configure({ timeout: 60000 });
test('capture before/after pinned header under merge churn', async ({ browser }) => {
const ctx: ITestContext = await createTestContext(browser);
await openTerminal(ctx, { cols: 80, rows: 24 });
await loadWebglStrict(ctx);
await setMaxAtlasPages(ctx, 4);
const screen = ctx.page.locator('#terminal-container .xterm-screen');
// Header + readable sentences pinned at top; body region churns below.
await writeAndWaitForRender(ctx, '\x1b[?1049h\x1b[H\x1b[97mHEADER: THE QUICK BROWN FOX 0123456789\r\nSTATUS: this line should stay readable\r\n');
await screen.screenshot({ path: 'out-esbuild-test/playwright/before.png' });
for (let c = 0; c < 30; c++) {
await writeAndWaitForRender(ctx, '\x1b[5;1H' + generateColoredAsciiFlood(20 * 78, c * 20 * 78));
}
await screen.screenshot({ path: 'out-esbuild-test/playwright/after.png' });
await ctx.page.close();
});
// Issue-like framing: prefill realistic CLI text, force merges with a mixed
// glyph payload, then rewrite the top lines clean. The rewritten header lines
// must stay readable in mono-after.png.
test('capture mono before/after (issue-like)', async ({ browser }) => {
const ctx: ITestContext = await createTestContext(browser);
await openTerminal(ctx, { cols: 80, rows: 24 });
await loadWebglStrict(ctx);
await setMaxAtlasPages(ctx, 4);
const screen = ctx.page.locator('#terminal-container .xterm-screen');
// Prefill a screenful of normal-looking CLI output (all rendered fine).
await writeAndWaitForRender(ctx, '\x1b[?1049h\x1b[2J\x1b[H');
let pre = '';
for (let r = 0; r < 22; r++) {
pre += ` $ Shell inspect bundled MCP JSON schema for type enum values ${r} lines\r\n`;
}
await writeAndWaitForRender(ctx, pre);
await screen.screenshot({ path: 'out-esbuild-test/playwright/mono-before.png' });
// Overflow the atlas (cap=4) so pages MERGE while most rows keep their cells,
// then rewrite a few lines clean (like scroll/redraw).
for (let c = 0; c < 12; c++) {
let frame = '\x1b[3;1H';
frame += generateMixedGlyphBlock(c + 1, 18, 78);
await writeAndWaitForRender(ctx, frame);
}
await writeAndWaitForRender(ctx, '\x1b[1;1H\x1b[2K $ Shell grep installed Copilot CLI binary - 53 lines\r\n\x1b[2K Thought for 1s');
await screen.screenshot({ path: 'out-esbuild-test/playwright/mono-after.png' });
await ctx.page.close();
});
});
@@ -7,7 +7,7 @@ import { BaseWindow } from './baseWindow';
import type { IControlWindow } from '../controlBar';
import type { IBufferCell } from '@xterm/xterm';
// Underline style values from common/buffer/Constants.ts
// Underline style values from common/primitives/buffer/Constants.ts
const enum UnderlineStyle {
NONE = 0,
SINGLE = 1,
+107 -107
View File
@@ -663,9 +663,9 @@
}
},
"node_modules/@esbuild/aix-ppc64": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.1.tgz",
"integrity": "sha512-Svl7tq8k/08+p6CXPpRjQ1fKX+1odH/BQbb48fV6fj3CWHhsoIOoY87w1oHXm0qEpkIK3ZfVgp0hed3XBXzXMQ==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.0.tgz",
"integrity": "sha512-lhRUCeuOyJQURhTxl4WkpFTjIsbDayJHih5kZC1giwE+MhIzAb7mEsQMqMf18rHLsrb5qI1tafG20mLxEWcWlA==",
"cpu": [
"ppc64"
],
@@ -680,9 +680,9 @@
}
},
"node_modules/@esbuild/android-arm": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.1.tgz",
"integrity": "sha512-0k2F129Xdio1TdJfzJ8sy1Q47vUD2NnwdhiAf7drUN1EBTfPf4hsFCtmMgu/6m8JSzsBrlmVjudMBQqOfG8usQ==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.0.tgz",
"integrity": "sha512-wqh0ByljabXLKHeWXYLqoJ5jKC4XBaw6Hk08OfMrCRd2nP2ZQ5eleDZC41XHyCNgktBGYMbqnrJKq/K/lzPMSQ==",
"cpu": [
"arm"
],
@@ -697,9 +697,9 @@
}
},
"node_modules/@esbuild/android-arm64": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.1.tgz",
"integrity": "sha512-34EGEbCIAgosYz6goLcopX6Mo7NyGv9tfwEM2/7Ce2VcVRk568iSvniGWcUXIy7wEDR1wzolcxcriFVrWYcwBg==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.0.tgz",
"integrity": "sha512-+WzIXQOSaGs33tLEgYPYe/yQHf0WTU0X42Jca3y8NWMbUVhp7rUnw+vAsRC/QiDrdD31IszMrZy+qwPOPjd+rw==",
"cpu": [
"arm64"
],
@@ -714,9 +714,9 @@
}
},
"node_modules/@esbuild/android-x64": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.1.tgz",
"integrity": "sha512-dbwY7ltSMDWsRatcRpCnES4F+im88OCUgGZjy52shC7GqHRE/cYlxNbB4Z4UpJswpcc4Qxd2oE/ufM0p61IKng==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.0.tgz",
"integrity": "sha512-+VJggoaKhk2VNNqVL7f6S189UzShHC/mR9EE8rDdSkdpN0KflSwWY/gWjDrNxxisg8Fp1ZCD9jLMo4m0OUfeUA==",
"cpu": [
"x64"
],
@@ -731,9 +731,9 @@
}
},
"node_modules/@esbuild/darwin-arm64": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.1.tgz",
"integrity": "sha512-TZbWkQY7kvTAXbXUT7uVACR5cMHsDiSz9z7ZKAX/RTq/WJEk3QyRr0wZpNhBDX+/0CtdqUIJlOiodQcta6tY3Q==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.0.tgz",
"integrity": "sha512-0T+A9WZm+bZ84nZBtk1ckYsOvyA3x7e2Acj1KdVfV4/2tdG4fzUp91YHx+GArWLtwqp77pBXVCPn2We7Letr0Q==",
"cpu": [
"arm64"
],
@@ -748,9 +748,9 @@
}
},
"node_modules/@esbuild/darwin-x64": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.1.tgz",
"integrity": "sha512-zfdzgK9ACBNZLI/CyHTOx81SyNbM6YXn7rxSgX97VjyiPl9W1i4Ka4fgKECEoFCKGpvBj5qArWIGgQjOwkgskQ==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.0.tgz",
"integrity": "sha512-fyzLm/DLDl/84OCfp2f/XQ4flmORsjU7VKt8HLjvIXChJoFFOIL6pLJPH4Yhd1n1gGFF9mPwtlN5Wf82DZs+LQ==",
"cpu": [
"x64"
],
@@ -765,9 +765,9 @@
}
},
"node_modules/@esbuild/freebsd-arm64": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.1.tgz",
"integrity": "sha512-wG2EA8ENdEI0qhkSZMjfqrdY+ziCYCPMmtZjjIwOmXFjmyzEHn+UUxk5of+SYsjtfs3VpnlC7QLzSI5hY/rOAw==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.0.tgz",
"integrity": "sha512-l9GeW5UZBT9k9brBYI+0WDffcRxgHQD8ShN2Ur4xWq/NFzUKm3k5lsH4PdaRgb2w7mI9u61nr2gI2mLI27Nh3Q==",
"cpu": [
"arm64"
],
@@ -782,9 +782,9 @@
}
},
"node_modules/@esbuild/freebsd-x64": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.1.tgz",
"integrity": "sha512-i7dZ9vQgnvSCzi/rYCXNgtF/U+eKZNJBzu3eTQbRgHnM7tNSizLOkRFAl3qzVc/Op/u5YkHHa4pf/3DOYHthLQ==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.0.tgz",
"integrity": "sha512-BXoQai/A0wPO6Es3yFJ7APCiKGc1tdAEOgeTNy3SsB491S3aHn4S4r3e976eUnPdU+NbdtmBuLncYir2tMU9Nw==",
"cpu": [
"x64"
],
@@ -799,9 +799,9 @@
}
},
"node_modules/@esbuild/linux-arm": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.1.tgz",
"integrity": "sha512-qVXBOHQS+d5Y722GwJzJUtOLlX7km3CraOaGormF1pDtPd2C/l1SHRPgjLunLGe51Sh5YYWKMFDyV4SxgMQYTQ==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.0.tgz",
"integrity": "sha512-CjaaREJagqJp7iTaNQjjidaNbCKYcd4IDkzbwwxtSvjI7NZm79qiHc8HqciMddQ6CKvJT6aBd8lO9kN/ZudLlw==",
"cpu": [
"arm"
],
@@ -816,9 +816,9 @@
}
},
"node_modules/@esbuild/linux-arm64": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.1.tgz",
"integrity": "sha512-yHs+0uc8+nvEAfAfxrWQKK5peSNzBc4PegcMO0EJ2hT71uA7vB8Ihg2e77R2P7SG5uYjPbHlLLmve4LLLRCf0g==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.0.tgz",
"integrity": "sha512-RVyzfb3FWsGA55n6WY0MEIEPURL1FcbhFE6BffZEMEekfCzCIMtB5yyDcFnVbTnwk+CLAgTujmV/Lgvih56W+A==",
"cpu": [
"arm64"
],
@@ -833,9 +833,9 @@
}
},
"node_modules/@esbuild/linux-ia32": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.1.tgz",
"integrity": "sha512-d1z4ZuP0ajrfz/FhGT4vv278rX8KnPPJx8i5+AtK7TYbx9Le9F1hyzurZpkEyjkGa9dUGhQow4C1NmeGvqxN2w==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.0.tgz",
"integrity": "sha512-KBnSTt1kxl9x70q+ydterVdl+Cn0H18ngRMRCEQfrbqdUuntQQ0LoMZv47uB97NljZFzY6HcfqEZ2SAyIUTQBQ==",
"cpu": [
"ia32"
],
@@ -850,9 +850,9 @@
}
},
"node_modules/@esbuild/linux-loong64": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.1.tgz",
"integrity": "sha512-M5sRjUVZrkm1OAPR3dlOYzNmN+loZKGVi1VUQGrwuqLcbR6qeAz+famMhjASeH3YVKvZz+zT1jlh/keC3Rj/lg==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.0.tgz",
"integrity": "sha512-zpSlUce1mnxzgBADvxKXX5sl8aYQHo2ezvMNI8I0lbblJtp8V4odlm3Yzlj7gPyt3T8ReksE6bK+pT3WD+aJRg==",
"cpu": [
"loong64"
],
@@ -867,9 +867,9 @@
}
},
"node_modules/@esbuild/linux-mips64el": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.1.tgz",
"integrity": "sha512-mRObBZeHh2OxcBFPWE/FjylkRgZdYuiTR3vaTozquCGOH14iP9oN4x4Ge81CoIDYQrXmIxpFumJBu5MtZpnQJQ==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.0.tgz",
"integrity": "sha512-2jIfP6mmjkdmeTlsX/9vmdmhBmKADrWqN7zcdtHIeNSCH1SqIoNI63cYsjQR8J+wGa4Y5izRcSHSm8K3QWmk3w==",
"cpu": [
"mips64el"
],
@@ -884,9 +884,9 @@
}
},
"node_modules/@esbuild/linux-ppc64": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.1.tgz",
"integrity": "sha512-slScBsMAb3GFDcdrCgLwZtPYRoH2H/youv10QiZyRjmsP48fznoveWytSgCI/R0ZcUgpc0ZhIUEx6LHts8yrfQ==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.0.tgz",
"integrity": "sha512-bc0FE9wWeC0WBm49IQMPSPILRocGTQt3j5KPCA8os6VprfuJ7KD+5PzESSrJ6GmPIPJK965ZJHTUlSA6GNYEhg==",
"cpu": [
"ppc64"
],
@@ -901,9 +901,9 @@
}
},
"node_modules/@esbuild/linux-riscv64": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.1.tgz",
"integrity": "sha512-kw0owk1o0GFETUJyW0jc0G4Yzs0BHZn0JDZ8JRT088vjJYX777BAs1fDGxAC+q831qOs2DTC96mNsG2opdfyyQ==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.0.tgz",
"integrity": "sha512-SQPZOwoTTT/HXFXQJG/vBX8sOFagGqvZyXcgLA3NhIqcBv1BJU1d46c0rGcrij2B56Z2rNiSLaZOYW5cUk7yLQ==",
"cpu": [
"riscv64"
],
@@ -918,9 +918,9 @@
}
},
"node_modules/@esbuild/linux-s390x": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.1.tgz",
"integrity": "sha512-/lAIjX8aYFRByhh6L5rYtPEDRqa9de/4V/juOXcta5frjvzXO4/sqEtyytse0g3zZFuWu5cDN0MkLz2qRDD2Ag==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.0.tgz",
"integrity": "sha512-SCfR0HN8CEEjnYnySJTd2cw0k9OHB/YFzt5zgJEwa+wL/T/raGWYMBqwDNAC6dqFKmJYZoQBRfHjgwLHGSrn3Q==",
"cpu": [
"s390x"
],
@@ -935,9 +935,9 @@
}
},
"node_modules/@esbuild/linux-x64": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.1.tgz",
"integrity": "sha512-u/anNYF2mmVOEDwLtnQ1wOr3EZ9sTNGLWrsYGYwHWzGA3Si84IOkHXlbWTD1NB+9/1lcnweYKO54uhxZydNzfA==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.0.tgz",
"integrity": "sha512-us0dSb9iFxIi8srnpl931Nvs65it/Jd2a2K3qs7fz2WfGPHqzfzZTfec7oxZJRNPXPnNYZtanmRc4AL/JwVzHQ==",
"cpu": [
"x64"
],
@@ -952,9 +952,9 @@
}
},
"node_modules/@esbuild/netbsd-arm64": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.1.tgz",
"integrity": "sha512-oks0DYbLwWMmaakTsCb+zL4E+aHRVLom9IJZOAthMQEPiQmydXHkziYEsGYRx0uNV/IjEKGAV941JzH02pflqw==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.0.tgz",
"integrity": "sha512-CR/RYotgtCKwtftMwJlUU7xCVNg3lMYZ0RzTmAHSfLCXw3NtZtNpswLEj/Kkf6kEL3Gw+BpOekRX0BYCtklhUw==",
"cpu": [
"arm64"
],
@@ -969,9 +969,9 @@
}
},
"node_modules/@esbuild/netbsd-x64": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.1.tgz",
"integrity": "sha512-aeL6lAnN89Hz43Mlh1G8ARasbuoYvSITDEx0tHh5b7jJnHcssqgjy9Yx430GDpmCa6OyrKoS0aNRjKundRizGg==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.0.tgz",
"integrity": "sha512-nU1yhmYutL+fQ71Kxnhg8uEOdC0pwEW9entHykTgEbna2pw2dkbFSMeqjjyHZoCmt8SBkOSvV+yNmm94aUrrqw==",
"cpu": [
"x64"
],
@@ -986,9 +986,9 @@
}
},
"node_modules/@esbuild/openbsd-arm64": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.1.tgz",
"integrity": "sha512-MEFJe5C3R8pwXdZ5Y21oo6m7ePiS0d9pWucn99O/wvyJZChoIQKrQDxKrGeW8F5+T0okTHesAmDeiHDTIq0V/Q==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.0.tgz",
"integrity": "sha512-cXb5vApOsRsxsEl4mcZ1XY3D4DzcoMxR/nnc4IyqYs0rTI8ZKmW6kyyg+11Z8yvgMfAEldKzP7AdP64HnSC/6g==",
"cpu": [
"arm64"
],
@@ -1003,9 +1003,9 @@
}
},
"node_modules/@esbuild/openbsd-x64": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.1.tgz",
"integrity": "sha512-i/ZLIOafE0Z8cI/XANJAixoJL/uRAoS2xOA3rb0xN+KK0K177cMAsQYkzHtBrtMXAKuAc7HGgcWiZ/sRC1Nxgw==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.0.tgz",
"integrity": "sha512-8wZM2qqtv9UP3mzy7HiGYNH/zjTA355mpeuA+859TyR+e+Tc08IHYpLJuMsfpDJwoLo1ikIJI8jC3GFjnRClzA==",
"cpu": [
"x64"
],
@@ -1020,9 +1020,9 @@
}
},
"node_modules/@esbuild/openharmony-arm64": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.1.tgz",
"integrity": "sha512-ge+Z7EXFNt2BO1oAMsVpiQ8EwndV9i1xXerAeTIK7AtPs3bKFXQM7nlRxDSIUIMeueR1CNXxqztLzdNeReKBJg==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.0.tgz",
"integrity": "sha512-FLGfyizszcef5C3YtoyQDACyg95+dndv79i2EekILBofh5wpCa1KuBqOWKrEHZg3zrL3t5ouE5jgr94vA+Wb2w==",
"cpu": [
"arm64"
],
@@ -1037,9 +1037,9 @@
}
},
"node_modules/@esbuild/sunos-x64": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.1.tgz",
"integrity": "sha512-BEjgtECkL3vY+SaSQ6nzVfiALUeFxpawyp8Jmf5PtYhf1Ug40N1h/hxlhts+f1FvSvarEigdxS3BlSMI2PJLcQ==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.0.tgz",
"integrity": "sha512-1ZgjUoEdHZZl/YlV76TSCz9Hqj9h9YmMGAgAPYd+q4SicWNX3G5GCyx9uhQWSLcbvPW8Ni7lj4gDa1T40akdlw==",
"cpu": [
"x64"
],
@@ -1054,9 +1054,9 @@
}
},
"node_modules/@esbuild/win32-arm64": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.1.tgz",
"integrity": "sha512-lCv9eK/H6ZJWbE7bh2nw54CZ9M2nupBxJcTsdk/QQnWkdSjKGuxmmH8/GWrlT1eMmZfn4dGcCjRte397WqfQXA==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.0.tgz",
"integrity": "sha512-Q9StnDmQ/enxnpxCCLSg0oo4+34B9TdXpuyPeTedN/6+iXBJ4J+zwfQI28u/Jl40nOYAxGoNi7mFP40RUtkmUA==",
"cpu": [
"arm64"
],
@@ -1071,9 +1071,9 @@
}
},
"node_modules/@esbuild/win32-ia32": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.1.tgz",
"integrity": "sha512-zvb/mB2bSCoJOpoCBgYKKpX6YM6mJBlBUVUtVj41DlZJVEB6/0CKlRYxP5wWl1C1ILiCoAU5wZZ4q1P3qeS6Eg==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.0.tgz",
"integrity": "sha512-zF3ag/gfiCe6U2iczcRzSYJKH1DCI+ByzSENHlM2FcDbEeo5Zd2C86Aq0tKUYAJJ1obRP84ymxIAksZUcdztHA==",
"cpu": [
"ia32"
],
@@ -1088,9 +1088,9 @@
}
},
"node_modules/@esbuild/win32-x64": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.1.tgz",
"integrity": "sha512-bm4Mowrv+GXMlpWX++EcXw/iLyd1o3+bJkC2DkWXYVvgZCqD/bSj9ctZeAMC3cIxgjRVR2Dufaiu4YPxr5gW1A==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.0.tgz",
"integrity": "sha512-pEl1bO9mfAmIC+tW5btTmrKaujg3zGtUmWNdCw/xs70FBjwAL3o9OEKNHvNmnyylD6ubxUERiEhdsL0xBQ9efw==",
"cpu": [
"x64"
],
@@ -3869,9 +3869,9 @@
"license": "MIT"
},
"node_modules/esbuild": {
"version": "0.28.1",
"resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.1.tgz",
"integrity": "sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw==",
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.0.tgz",
"integrity": "sha512-sNR9MHpXSUV/XB4zmsFKN+QgVG82Cc7+/aaxJ8Adi8hyOac+EXptIp45QBPaVyX3N70664wRbTcLTOemCAnyqw==",
"dev": true,
"hasInstallScript": true,
"license": "MIT",
@@ -3882,32 +3882,32 @@
"node": ">=18"
},
"optionalDependencies": {
"@esbuild/aix-ppc64": "0.28.1",
"@esbuild/android-arm": "0.28.1",
"@esbuild/android-arm64": "0.28.1",
"@esbuild/android-x64": "0.28.1",
"@esbuild/darwin-arm64": "0.28.1",
"@esbuild/darwin-x64": "0.28.1",
"@esbuild/freebsd-arm64": "0.28.1",
"@esbuild/freebsd-x64": "0.28.1",
"@esbuild/linux-arm": "0.28.1",
"@esbuild/linux-arm64": "0.28.1",
"@esbuild/linux-ia32": "0.28.1",
"@esbuild/linux-loong64": "0.28.1",
"@esbuild/linux-mips64el": "0.28.1",
"@esbuild/linux-ppc64": "0.28.1",
"@esbuild/linux-riscv64": "0.28.1",
"@esbuild/linux-s390x": "0.28.1",
"@esbuild/linux-x64": "0.28.1",
"@esbuild/netbsd-arm64": "0.28.1",
"@esbuild/netbsd-x64": "0.28.1",
"@esbuild/openbsd-arm64": "0.28.1",
"@esbuild/openbsd-x64": "0.28.1",
"@esbuild/openharmony-arm64": "0.28.1",
"@esbuild/sunos-x64": "0.28.1",
"@esbuild/win32-arm64": "0.28.1",
"@esbuild/win32-ia32": "0.28.1",
"@esbuild/win32-x64": "0.28.1"
"@esbuild/aix-ppc64": "0.28.0",
"@esbuild/android-arm": "0.28.0",
"@esbuild/android-arm64": "0.28.0",
"@esbuild/android-x64": "0.28.0",
"@esbuild/darwin-arm64": "0.28.0",
"@esbuild/darwin-x64": "0.28.0",
"@esbuild/freebsd-arm64": "0.28.0",
"@esbuild/freebsd-x64": "0.28.0",
"@esbuild/linux-arm": "0.28.0",
"@esbuild/linux-arm64": "0.28.0",
"@esbuild/linux-ia32": "0.28.0",
"@esbuild/linux-loong64": "0.28.0",
"@esbuild/linux-mips64el": "0.28.0",
"@esbuild/linux-ppc64": "0.28.0",
"@esbuild/linux-riscv64": "0.28.0",
"@esbuild/linux-s390x": "0.28.0",
"@esbuild/linux-x64": "0.28.0",
"@esbuild/netbsd-arm64": "0.28.0",
"@esbuild/netbsd-x64": "0.28.0",
"@esbuild/openbsd-arm64": "0.28.0",
"@esbuild/openbsd-x64": "0.28.0",
"@esbuild/openharmony-arm64": "0.28.0",
"@esbuild/sunos-x64": "0.28.0",
"@esbuild/win32-arm64": "0.28.0",
"@esbuild/win32-ia32": "0.28.0",
"@esbuild/win32-x64": "0.28.0"
}
},
"node_modules/escalade": {
+2 -2
View File
@@ -6,9 +6,9 @@
import * as Strings from './LocalizableStrings';
import { ITerminal, IRenderDebouncer } from './Types';
import { TimeBasedDebouncer } from './TimeBasedDebouncer';
import { Disposable, toDisposable } from '../common/Lifecycle';
import { Disposable, toDisposable } from '../common/primitives/Lifecycle';
import { ICoreBrowserService, IRenderService } from './services/Services';
import { IBuffer } from '../common/buffer/Types';
import { IBuffer } from '../common/primitives/buffer/Types';
import { IInstantiationService } from '../common/services/Services';
import { addDisposableListener } from './Dom';
+2 -2
View File
@@ -4,8 +4,8 @@
*/
import { IColorContrastCache } from './Types';
import { IColor } from '../common/Types';
import { TwoKeyMap } from '../common/MultiKeyMap';
import { IColor } from '../common/primitives/Types';
import { TwoKeyMap } from '../common/primitives/MultiKeyMap';
export class ColorContrastCache implements IColorContrastCache {
private _color: TwoKeyMap</* bg */number, /* fg */number, IColor | null> = new TwoKeyMap();
+10 -9
View File
@@ -43,22 +43,23 @@ import { SelectionService } from './services/SelectionService';
import { ICharSizeService, ICharacterJoinerService, ICoreBrowserService, IKeyboardService, ILinkProviderService, IMouseCoordsService, IMouseService, IRenderService, ISelectionService, IThemeService } from './services/Services';
import { ThemeService } from './services/ThemeService';
import { KeyboardService } from './services/KeyboardService';
import { channels, color, rgb } from '../common/Color';
import { channels, color, rgb } from '../common/primitives/Color';
import { CoreTerminal } from '../common/CoreTerminal';
import * as Browser from '../common/Platform';
import { ColorRequestType, IColorEvent, ITerminalOptions, KeyboardResultType, SpecialColorIndex } from '../common/Types';
import { DEFAULT_ATTR_DATA } from '../common/buffer/BufferLine';
import { IBuffer } from '../common/buffer/Types';
import { C0, C1ESCAPED } from '../common/data/EscapeSequences';
import { toRgbString } from '../common/input/XParseColor';
import * as Browser from '../common/primitives/Platform';
import { ColorRequestType, IColorEvent, KeyboardResultType, SpecialColorIndex } from '../common/primitives/Types';
import { ITerminalOptions } from '../common/Types';
import { DEFAULT_ATTR_DATA } from '../common/primitives/buffer/BufferLine';
import { IBuffer } from '../common/primitives/buffer/Types';
import { C0, C1ESCAPED } from '../common/primitives/data/EscapeSequences';
import { toRgbString } from '../common/primitives/input/XParseColor';
import { DecorationService } from '../common/services/DecorationService';
import { IDecorationService } from '../common/services/Services';
import { WindowsOptionsReportType } from '../common/InputHandler';
import { AccessibilityManager } from './AccessibilityManager';
import { Linkifier } from './Linkifier';
import { Emitter, EventUtils, type IEvent } from '../common/Event';
import { Emitter, EventUtils, type IEvent } from '../common/primitives/Event';
import { addDisposableListener } from './Dom';
import { MutableDisposable, toDisposable } from '../common/Lifecycle';
import { MutableDisposable, toDisposable } from '../common/primitives/Lifecycle';
export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
public textarea: HTMLTextAreaElement | undefined;
+2 -2
View File
@@ -5,8 +5,8 @@
* Minimal DOM helpers for xterm.js browser code.
*/
import { IntervalTimer } from '../common/Async';
import { IDisposable } from '../common/Lifecycle';
import { IntervalTimer } from '../common/primitives/Async';
import { IDisposable } from '../common/primitives/Lifecycle';
export function getWindow(e: Node | UIEvent | undefined | null): Window {
const candidateNode = e as Node | undefined | null;
+3 -3
View File
@@ -4,11 +4,11 @@
*/
import { IBufferCellPosition, ILink, ILinkDecorations, ILinkWithState, ILinkifier2, ILinkifierEvent } from './Types';
import { Disposable, dispose, toDisposable } from '../common/Lifecycle';
import { IDisposable } from '../common/Types';
import { Disposable, dispose, toDisposable } from '../common/primitives/Lifecycle';
import { IDisposable } from '../common/primitives/Types';
import { IBufferService } from '../common/services/Services';
import { ILinkProviderService, IMouseCoordsService, IRenderService } from './services/Services';
import { Emitter } from '../common/Event';
import { Emitter } from '../common/primitives/Event';
import { addDisposableListener } from './Dom';
export class Linkifier extends Disposable implements ILinkifier2 {
+2 -2
View File
@@ -8,8 +8,8 @@ import { OscLinkProvider } from './OscLinkProvider';
import { ILink } from './Types';
import { createCellData, MockBufferService, MockOptionsService } from '../common/TestUtils.test';
import { IBufferService, IOscLinkService } from '../common/services/Services';
import { IOscLinkData } from '../common/Types';
import { IBufferLine } from '../common/buffer/Types';
import { IOscLinkData } from '../common/primitives/Types';
import { IBufferLine } from '../common/primitives/buffer/Types';
class TestOscLinkService implements IOscLinkService {
public serviceBrand: any;
+2 -2
View File
@@ -5,8 +5,8 @@
import { IBufferRange, ILink } from './Types';
import { ILinkProvider } from './services/Services';
import { CellData } from '../common/buffer/CellData';
import { IBufferLine } from '../common/buffer/Types';
import { CellData } from '../common/primitives/buffer/CellData';
import { IBufferLine } from '../common/primitives/buffer/Types';
import { IBufferService, IOptionsService, IOscLinkService } from '../common/services/Services';
export class OscLinkProvider implements ILinkProvider {
+3 -3
View File
@@ -6,10 +6,10 @@
import { MockCompositionHelper, MockRenderer, MockViewport, TestTerminal } from './TestUtils.test';
import type { IBrowser } from './Types';
import { assert } from 'chai';
import { DEFAULT_ATTR_DATA } from '../common/buffer/BufferLine';
import { CellData } from '../common/buffer/CellData';
import { DEFAULT_ATTR_DATA } from '../common/primitives/buffer/BufferLine';
import { CellData } from '../common/primitives/buffer/CellData';
import { MockUnicodeService, createCellData } from '../common/TestUtils.test';
import { IMarker } from '../common/buffer/Types';
import { IMarker } from '../common/primitives/buffer/Types';
const INIT_COLS = 80;
const INIT_ROWS = 24;
+10 -9
View File
@@ -7,19 +7,20 @@ import { IDisposable, IMarker, ILinkProvider, IDecorationOptions, IDecoration, I
import { ICharacterJoinerService, ICharSizeService, ICoreBrowserService, IMouseService, IRenderService, ISelectionService, IThemeService } from './services/Services';
import { IRenderDimensions, IRenderer, IRequestRedrawEvent } from './renderer/shared/Types';
import { IColorSet, ITerminal, ILinkifier2, IBrowser, IViewport, ICompositionHelper, CharacterJoinerHandler, IBufferRange, ReadonlyColorSet, IBufferElementProvider } from './Types';
import { IAttributeData, IBuffer, IBufferLine, IBufferSet, ICellData } from '../common/buffer/Types';
import { ICircularList } from '../common/CircularList';
import { XtermListener, ICharset, ITerminalOptions, ColorIndex } from '../common/Types';
import { Buffer } from '../common/buffer/Buffer';
import * as Browser from '../common/Platform';
import { IAttributeData, IBuffer, IBufferLine, IBufferSet, ICellData } from '../common/primitives/buffer/Types';
import { ICircularList } from '../common/primitives/CircularList';
import { XtermListener, ICharset, ColorIndex } from '../common/primitives/Types';
import { ITerminalOptions } from '../common/Types';
import { Buffer } from '../common/primitives/buffer/Buffer';
import * as Browser from '../common/primitives/Platform';
import { CoreBrowserTerminal } from './CoreBrowserTerminal';
import { IUnicodeService, IOptionsService, ICoreService, IMouseStateService } from '../common/services/Services';
import { IFunctionIdentifier, IParams } from '../common/parser/Types';
import { AttributeData } from '../common/buffer/AttributeData';
import { IFunctionIdentifier, IParams } from '../common/primitives/parser/Types';
import { AttributeData } from '../common/primitives/buffer/AttributeData';
import { ISelectionRedrawRequestEvent, ISelectionRequestScrollLinesEvent } from './selection/Types';
import { css } from '../common/Color';
import { css } from '../common/primitives/Color';
import { createRenderDimensions } from './renderer/shared/RendererUtils';
import { Emitter, type IEvent } from '../common/Event';
import { Emitter, type IEvent } from '../common/primitives/Event';
export class TestTerminal extends CoreBrowserTerminal {
public get curAttrData(): IAttributeData { return (this as any)._inputHandler._curAttrData; }
+5 -4
View File
@@ -3,12 +3,13 @@
* @license MIT
*/
import { IColor, ITerminalOptions } from '../common/Types';
import { CharData, IBuffer } from '../common/buffer/Types';
import { IColor } from '../common/primitives/Types';
import { ITerminalOptions } from '../common/Types';
import { CharData, IBuffer } from '../common/primitives/buffer/Types';
import { ICoreTerminal } from '../common/CoreTerminal';
import { IDisposable, IRenderDimensions as IRenderDimensionsApi, Terminal as ITerminalApi } from '@xterm/xterm';
import { channels, css } from '../common/Color';
import type { IEvent } from '../common/Event';
import { channels, css } from '../common/primitives/Color';
import type { IEvent } from '../common/primitives/Event';
/**
* A portion of the public API that are implemented identially internally and simply passed through.
+3 -3
View File
@@ -5,13 +5,13 @@
import { ICoreBrowserService, IRenderService, IThemeService } from './services/Services';
import { ViewportConstants } from './shared/Constants';
import { Disposable, toDisposable } from '../common/Lifecycle';
import { Disposable, toDisposable } from '../common/primitives/Lifecycle';
import { IBufferService, ICoreService, IMouseStateService, IOptionsService } from '../common/services/Services';
import { CoreMouseEventType } from '../common/Types';
import { CoreMouseEventType } from '../common/primitives/Types';
import { scheduleAtNextAnimationFrame } from './Dom';
import { SmoothScrollableElement } from './scrollable/scrollableElement';
import type { IScrollableElementChangeOptions } from './scrollable/scrollableElementOptions';
import { Emitter, EventUtils } from '../common/Event';
import { Emitter, EventUtils } from '../common/primitives/Event';
import { Scrollable, ScrollbarVisibility, type IScrollEvent } from './scrollable/scrollable';
export class Viewport extends Disposable {
@@ -4,7 +4,7 @@
*--------------------------------------------------------------------------------------------*/
import { ICoreBrowserService, IRenderService } from '../services/Services';
import { Disposable, toDisposable } from '../../common/Lifecycle';
import { Disposable, toDisposable } from '../../common/primitives/Lifecycle';
import { IBufferService, IDecorationService, IInternalDecoration } from '../../common/services/Services';
export class BufferDecorationRenderer extends Disposable {
@@ -5,7 +5,7 @@
import { ColorZoneStore, IColorZone, IColorZoneStore } from './ColorZoneStore';
import { ICoreBrowserService, IRenderService, IThemeService } from '../services/Services';
import { Disposable, toDisposable } from '../../common/Lifecycle';
import { Disposable, toDisposable } from '../../common/primitives/Lifecycle';
import { IBufferService, IDecorationService, IOptionsService } from '../../common/services/Services';
const enum Constants {
+1 -1
View File
@@ -5,7 +5,7 @@
import { IRenderService } from '../services/Services';
import { IBufferService, ICoreService, IOptionsService } from '../../common/services/Services';
import { C0 } from '../../common/data/EscapeSequences';
import { C0 } from '../../common/primitives/data/EscapeSequences';
interface IPosition {
start: number;
+1 -1
View File
@@ -3,7 +3,7 @@
* @license MIT
*/
import { C0 } from '../../common/data/EscapeSequences';
import { C0 } from '../../common/primitives/data/EscapeSequences';
import { IBufferService } from '../../common/services/Services';
const enum Direction {
+2 -2
View File
@@ -6,14 +6,14 @@
import * as Strings from '../LocalizableStrings';
import { CoreBrowserTerminal as TerminalCore } from '../CoreBrowserTerminal';
import { IBufferRange, ITerminal } from '../Types';
import { Disposable } from '../../common/Lifecycle';
import { Disposable } from '../../common/primitives/Lifecycle';
import { ITerminalOptions } from '../../common/Types';
import { AddonManager } from '../../common/public/AddonManager';
import { BufferNamespaceApi } from '../../common/public/BufferNamespaceApi';
import { ParserApi } from '../../common/public/ParserApi';
import { UnicodeApi } from '../../common/public/UnicodeApi';
import { IBufferNamespace as IBufferNamespaceApi, IDecoration, IDecorationOptions, IDisposable, ILinkProvider, ILocalizableStrings, IMarker, IModes, IParser, IRenderDimensions, ITerminalAddon, Terminal as ITerminalApi, ITerminalInitOnlyOptions, IUnicodeHandling } from '@xterm/xterm';
import type { IEvent } from '../../common/Event';
import type { IEvent } from '../../common/primitives/Event';
/**
* The set of options that only have an effect when set in the Terminal constructor.
+3 -3
View File
@@ -12,10 +12,10 @@ import { TextBlinkStateManager } from '../shared/TextBlinkStateManager';
import { IRenderDimensions, IRenderer, IRequestRedrawEvent, ISelectionRenderModel } from '../shared/Types';
import { ICharSizeService, ICoreBrowserService, IThemeService } from '../../services/Services';
import { ILinkifier2, ILinkifierEvent, ITerminal, ReadonlyColorSet } from '../../Types';
import { color } from '../../../common/Color';
import { Disposable, toDisposable } from '../../../common/Lifecycle';
import { color } from '../../../common/primitives/Color';
import { Disposable, toDisposable } from '../../../common/primitives/Lifecycle';
import { IBufferService, ICoreService, IInstantiationService, IOptionsService } from '../../../common/services/Services';
import { Emitter } from '../../../common/Event';
import { Emitter } from '../../../common/primitives/Event';
import { addDisposableListener } from '../../Dom';
@@ -6,11 +6,11 @@
import jsdom = require('jsdom');
import { assert } from 'chai';
import { DomRendererRowFactory } from './DomRendererRowFactory';
import { NULL_CELL_CODE, NULL_CELL_WIDTH, NULL_CELL_CHAR, DEFAULT_ATTR, FgFlags, BgFlags, Attributes, UnderlineStyle } from '../../../common/buffer/Constants';
import { BufferLine, DEFAULT_ATTR_DATA } from '../../../common/buffer/BufferLine';
import { BufferLineStringCache } from '../../../common/buffer/BufferLineStringCache';
import { IBufferLine } from '../../../common/buffer/Types';
import { CellData } from '../../../common/buffer/CellData';
import { NULL_CELL_CODE, NULL_CELL_WIDTH, NULL_CELL_CHAR, DEFAULT_ATTR, FgFlags, BgFlags, Attributes, UnderlineStyle } from '../../../common/primitives/buffer/Constants';
import { BufferLine, DEFAULT_ATTR_DATA } from '../../../common/primitives/buffer/BufferLine';
import { BufferLineStringCache } from '../../../common/primitives/buffer/BufferLineStringCache';
import { IBufferLine } from '../../../common/primitives/buffer/Types';
import { CellData } from '../../../common/primitives/buffer/CellData';
import { MockCoreService, MockDecorationService, MockOptionsService, createCellData, NULL_CELL_DATA } from '../../../common/TestUtils.test';
import { MockCharacterJoinerService, MockCoreBrowserService, MockThemeService } from '../../TestUtils.test';
import { TestWidthCache } from './WidthCache.test';
@@ -3,17 +3,17 @@
* @license MIT
*/
import { IColor } from '../../../common/Types';
import { IBufferLine, ICellData } from '../../../common/buffer/Types';
import { IColor } from '../../../common/primitives/Types';
import { IBufferLine, ICellData } from '../../../common/primitives/buffer/Types';
import { INVERTED_DEFAULT_COLOR } from '../shared/Constants';
import { WHITESPACE_CELL_CHAR, Attributes } from '../../../common/buffer/Constants';
import { CellData } from '../../../common/buffer/CellData';
import { WHITESPACE_CELL_CHAR, Attributes } from '../../../common/primitives/buffer/Constants';
import { CellData } from '../../../common/primitives/buffer/CellData';
import { ICoreService, IDecorationService, IOptionsService } from '../../../common/services/Services';
import { channels, color } from '../../../common/Color';
import { channels, color } from '../../../common/primitives/Color';
import { ICharacterJoinerService, ICoreBrowserService, IThemeService } from '../../services/Services';
import { JoinedCellData } from '../../services/CharacterJoinerService';
import { treatGlyphAsBackgroundColor } from '../shared/RendererUtils';
import { AttributeData } from '../../../common/buffer/AttributeData';
import { AttributeData } from '../../../common/primitives/buffer/AttributeData';
import { WidthCache } from './WidthCache';
import { IColorContrastCache } from '../../Types';
+1 -1
View File
@@ -4,7 +4,7 @@
*/
import { throwIfFalsy } from '../shared/RendererUtils';
import { IDisposable } from '../../../common/Types';
import { IDisposable } from '../../../common/primitives/Types';
import { FontWeight } from '../../../common/services/Services';
@@ -7,7 +7,7 @@ import { assert } from 'chai';
import { TextBlinkStateManager } from './TextBlinkStateManager';
import { MockOptionsService } from '../../../common/TestUtils.test';
import type { ICoreBrowserService } from '../../services/Services';
import { Emitter } from '../../../common/Event';
import { Emitter } from '../../../common/primitives/Event';
class FakeWindow {
public nextId = 1;
@@ -4,7 +4,7 @@
*/
import { ICoreBrowserService } from '../../services/Services';
import { Disposable, toDisposable } from '../../../common/Lifecycle';
import { Disposable, toDisposable } from '../../../common/primitives/Lifecycle';
import { IOptionsService } from '../../../common/services/Services';
export class TextBlinkStateManager extends Disposable {
+2 -2
View File
@@ -5,8 +5,8 @@
import { Terminal } from '@xterm/xterm';
import { ITerminal } from '../../Types';
import { IDisposable } from '../../../common/Types';
import type { IEvent } from '../../../common/Event';
import { IDisposable } from '../../../common/primitives/Types';
import type { IEvent } from '../../../common/primitives/Event';
export interface IDimensions {
width: number;
+1 -1
View File
@@ -11,7 +11,7 @@ import { ScrollbarArrow, IScrollbarArrowOptions } from './scrollbarArrow';
import { ScrollbarState } from './scrollbarState';
import { ScrollbarVisibilityController } from './scrollbarVisibilityController';
import { Widget } from './widget';
import * as platform from '../../common/Platform';
import * as platform from '../../common/primitives/Platform';
import { INewScrollPosition, Scrollable, ScrollbarVisibility } from './scrollable';
/**
@@ -4,7 +4,7 @@
*--------------------------------------------------------------------------------------------*/
import * as dom from '../Dom';
import { DisposableStore, IDisposable, toDisposable } from '../../common/Lifecycle';
import { DisposableStore, IDisposable, toDisposable } from '../../common/primitives/Lifecycle';
type PointerMoveCallback = (event: PointerEvent) => void;
type OnStopCallback = () => void;
+1 -1
View File
@@ -3,7 +3,7 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as platform from '../../common/Platform';
import * as platform from '../../common/primitives/Platform';
interface IWindowChainElement {
readonly window: WeakRef<Window>;
+2 -2
View File
@@ -3,8 +3,8 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { Emitter, IEvent } from '../../common/Event';
import { Disposable, IDisposable } from '../../common/Lifecycle';
import { Emitter, IEvent } from '../../common/primitives/Event';
import { Disposable, IDisposable } from '../../common/primitives/Lifecycle';
export const enum ScrollbarVisibility {
AUTO = 1,
+4 -4
View File
@@ -11,10 +11,10 @@ import { HorizontalScrollbar } from './horizontalScrollbar';
import { IScrollableElementChangeOptions, IScrollableElementCreationOptions, IScrollableElementResolvedOptions } from './scrollableElementOptions';
import { VerticalScrollbar } from './verticalScrollbar';
import { Widget } from './widget';
import { TimeoutTimer } from '../../common/Async';
import { Emitter, IEvent } from '../../common/Event';
import { IDisposable, dispose } from '../../common/Lifecycle';
import * as platform from '../../common/Platform';
import { TimeoutTimer } from '../../common/primitives/Async';
import { Emitter, IEvent } from '../../common/primitives/Event';
import { IDisposable, dispose } from '../../common/primitives/Lifecycle';
import * as platform from '../../common/primitives/Platform';
import { INewScrollDimensions, INewScrollPosition, IScrollDimensions, IScrollPosition, IScrollEvent, Scrollable, ScrollbarVisibility } from './scrollable';
// import 'vs/css!./media/scrollbars';
+1 -1
View File
@@ -5,7 +5,7 @@
import { GlobalPointerMoveMonitor } from './globalPointerMoveMonitor';
import { Widget } from './widget';
import { TimeoutTimer } from '../../common/Async';
import { TimeoutTimer } from '../../common/primitives/Async';
import * as dom from '../Dom';
export interface IScrollbarArrowOptions {
@@ -4,8 +4,8 @@
*--------------------------------------------------------------------------------------------*/
import { FastDomNode } from './fastDomNode';
import { TimeoutTimer } from '../../common/Async';
import { Disposable } from '../../common/Lifecycle';
import { TimeoutTimer } from '../../common/primitives/Async';
import { Disposable } from '../../common/primitives/Lifecycle';
import { ScrollbarVisibility } from './scrollable';
export class ScrollbarVisibilityController extends Disposable {
+1 -1
View File
@@ -4,7 +4,7 @@
*--------------------------------------------------------------------------------------------*/
import * as DomUtils from '../Dom';
import { Disposable, IDisposable, toDisposable } from '../../common/Lifecycle';
import { Disposable, IDisposable, toDisposable } from '../../common/primitives/Lifecycle';
const mainWindow = (typeof window === 'object' ? window : globalThis) as Window & typeof globalThis;
+1 -1
View File
@@ -5,7 +5,7 @@
import * as dom from '../Dom';
import { IMouseEvent, StandardMouseEvent } from './mouseEvent';
import { Disposable } from '../../common/Lifecycle';
import { Disposable } from '../../common/primitives/Lifecycle';
export abstract class Widget extends Disposable {
+2 -2
View File
@@ -5,8 +5,8 @@
import { IOptionsService } from '../../common/services/Services';
import { ICharSizeService } from './Services';
import { Disposable } from '../../common/Lifecycle';
import { Emitter } from '../../common/Event';
import { Disposable } from '../../common/primitives/Lifecycle';
import { Emitter } from '../../common/primitives/Event';
export class CharSizeService extends Disposable implements ICharSizeService {
public serviceBrand: undefined;
@@ -6,10 +6,10 @@
import { assert } from 'chai';
import { ICharacterJoinerService } from './Services';
import { CharacterJoinerService } from './CharacterJoinerService';
import { BufferLine } from '../../common/buffer/BufferLine';
import { BufferLineStringCache } from '../../common/buffer/BufferLineStringCache';
import { IBufferLine } from '../../common/buffer/Types';
import { CellData } from '../../common/buffer/CellData';
import { BufferLine } from '../../common/primitives/buffer/BufferLine';
import { BufferLineStringCache } from '../../common/primitives/buffer/BufferLineStringCache';
import { IBufferLine } from '../../common/primitives/buffer/Types';
import { CellData } from '../../common/primitives/buffer/CellData';
import { MockBufferService, createCellData } from '../../common/TestUtils.test';
const TEST_STRING_CACHE = new BufferLineStringCache();
@@ -3,11 +3,11 @@
* @license MIT
*/
import { CharData, IBufferLine, ICellData } from '../../common/buffer/Types';
import { CharData, IBufferLine, ICellData } from '../../common/primitives/buffer/Types';
import { ICharacterJoiner } from '../Types';
import { AttributeData } from '../../common/buffer/AttributeData';
import { WHITESPACE_CELL_CHAR, Content } from '../../common/buffer/Constants';
import { CellData } from '../../common/buffer/CellData';
import { AttributeData } from '../../common/primitives/buffer/AttributeData';
import { WHITESPACE_CELL_CHAR, Content } from '../../common/primitives/buffer/Constants';
import { CellData } from '../../common/primitives/buffer/CellData';
import { IBufferService } from '../../common/services/Services';
import { ICharacterJoinerService } from './Services';
+2 -2
View File
@@ -4,9 +4,9 @@
*/
import { ICoreBrowserService } from './Services';
import { Emitter, EventUtils } from '../../common/Event';
import { Emitter, EventUtils } from '../../common/primitives/Event';
import { addDisposableListener } from '../Dom';
import { Disposable, MutableDisposable, toDisposable } from '../../common/Lifecycle';
import { Disposable, MutableDisposable, toDisposable } from '../../common/primitives/Lifecycle';
export class CoreBrowserService extends Disposable implements ICoreBrowserService {
public serviceBrand: undefined;
+5 -5
View File
@@ -4,12 +4,12 @@
*/
import { IKeyboardService } from './Services';
import { evaluateKeyboardEvent } from '../../common/input/Keyboard';
import { KittyKeyboard, KittyKeyboardEventType, KittyKeyboardFlags } from '../../common/input/KittyKeyboard';
import { Win32InputMode } from '../../common/input/Win32InputMode';
import { isMac } from '../../common/Platform';
import { evaluateKeyboardEvent } from '../../common/primitives/input/Keyboard';
import { KittyKeyboard, KittyKeyboardEventType, KittyKeyboardFlags } from '../../common/primitives/input/KittyKeyboard';
import { Win32InputMode } from '../../common/primitives/input/Win32InputMode';
import { isMac } from '../../common/primitives/Platform';
import { ICoreService, IOptionsService } from '../../common/services/Services';
import { IKeyboardResult } from '../../common/Types';
import { IKeyboardResult } from '../../common/primitives/Types';
export class KeyboardService implements IKeyboardService {
public serviceBrand: undefined;
+2 -2
View File
@@ -1,6 +1,6 @@
import { ILinkProvider, ILinkProviderService } from './Services';
import { Disposable, toDisposable } from '../../common/Lifecycle';
import { IDisposable } from '../../common/Types';
import { Disposable, toDisposable } from '../../common/primitives/Lifecycle';
import { IDisposable } from '../../common/primitives/Types';
export class LinkProviderService extends Disposable implements ILinkProviderService {
declare public serviceBrand: undefined;
+1 -94
View File
@@ -5,7 +5,7 @@
import { assert } from 'chai';
import { AltMouseCursorController, MouseEventCssClasses, MouseService } from './MouseService';
import { MouseStateService } from '../../common/services/MouseStateService';
import { CoreMouseAction, CoreMouseButton } from '../../common/Types';
import { CoreMouseAction, CoreMouseButton } from '../../common/primitives/Types';
import { IBufferService, ICoreService, ILogService, IOptionsService } from '../../common/services/Services';
import { OptionsService } from '../../common/services/OptionsService';
import { MockCoreBrowserService, MockRenderService, MockSelectionService } from '../TestUtils.test';
@@ -351,96 +351,3 @@ describe('MouseService mouseEventsRequireAlt', () => {
assert.isFalse(element.classList.contains(MouseEventCssClasses.ENABLE_MOUSE_EVENTS));
});
});
describe('MouseService multi-window', () => {
interface IRecordingDocument {
doc: Document;
added: string[];
removed: string[];
listeners: { [type: string]: EventListener[] };
}
function createRecordingDocument(): IRecordingDocument {
const added: string[] = [];
const removed: string[] = [];
const listeners: { [type: string]: EventListener[] } = {};
const doc = {
addEventListener: (type: string, listener: EventListener) => {
added.push(type);
(listeners[type] ??= []).push(listener);
},
removeEventListener: (type: string) => removed.push(type)
} as any;
return { doc, added, removed, listeners };
}
it('should manage protocol mouseup/mousemove listeners on the element\'s current document, not the document the terminal was opened with', () => {
const mouseStateService = new MouseStateService();
const optionsService = new OptionsService({});
const mouseService = new MouseService(
new MockRenderService(),
{
getMouseReportCoords: () => ({ col: 0, row: 0, x: 0, y: 0 })
} as any,
mouseStateService,
{
triggerDataEvent: () => {},
triggerBinaryEvent: () => {},
decPrivateModes: { applicationCursorKeys: false }
} as any,
bufferService,
optionsService,
new TestSelectionService(),
logService,
new MockCoreBrowserService()
);
// Simulate a terminal that was opened with one document but whose element now lives in
// another document (eg. it was moved to a child window)
const openDocument = createRecordingDocument();
const childDocument = createRecordingDocument();
const elementListeners: { [type: string]: EventListener[] } = {};
const element = {
classList: {
add: () => {},
remove: () => {},
contains: () => false
},
addEventListener: (type: string, listener: EventListener) => {
(elementListeners[type] ??= []).push(listener);
},
removeEventListener: () => {},
ownerDocument: childDocument.doc
} as any;
mouseService.bindMouse({
element,
screenElement: createTestMouseTargetElement(),
document: openDocument.doc
}, disposable => disposable, () => {});
mouseStateService.activeProtocol = 'ANY';
elementListeners['mousedown'][0]({
type: 'mousedown',
button: 0,
buttons: 1,
altKey: false,
ctrlKey: false,
shiftKey: false,
preventDefault: () => {}
} as any);
assert.deepEqual(childDocument.added, ['mouseup', 'mousemove']);
assert.deepEqual(openDocument.added, []);
childDocument.listeners['mouseup'][0]({
type: 'mouseup',
button: 0,
buttons: 0,
altKey: false,
ctrlKey: false,
shiftKey: false
} as any);
assert.deepEqual(childDocument.removed, ['mouseup', 'mousemove']);
assert.deepEqual(openDocument.removed, []);
});
});
+29 -20
View File
@@ -5,9 +5,9 @@
import { addDisposableListener } from '../Dom';
import { IBufferService, IMouseStateService, ICoreService, ILogService, IOptionsService } from '../../common/services/Services';
import { CoreMouseAction, CoreMouseButton, CoreMouseEventType, ICoreMouseEvent, IDisposable } from '../../common/Types';
import { C0 } from '../../common/data/EscapeSequences';
import { DisposableStore, MutableDisposable } from '../../common/Lifecycle';
import { CoreMouseAction, CoreMouseButton, CoreMouseEventType, ICoreMouseEvent, IDisposable } from '../../common/primitives/Types';
import { C0 } from '../../common/primitives/data/EscapeSequences';
import { DisposableStore, MutableDisposable, toDisposable } from '../../common/primitives/Lifecycle';
import { ICoreBrowserService, IMouseCoordsService, IMouseService, IMouseServiceTarget, IRenderService, ISelectionService } from './Services';
import { Gesture, EventType as GestureEventType, IGestureEvent } from '../scrollable/touch';
@@ -21,8 +21,6 @@ interface IMouseBindContext {
readonly target: IMouseServiceTarget;
readonly focus: () => void;
readonly requestedEvents: RequestedMouseEvents;
readonly mouseupListener: MutableDisposable<IDisposable>;
readonly mousedragListener: MutableDisposable<IDisposable>;
}
export class MouseService implements IMouseService {
@@ -63,11 +61,7 @@ export class MouseService implements IMouseService {
mousedrag: null,
mousemove: null
};
const mouseupListener = new MutableDisposable<IDisposable>();
const mousedragListener = new MutableDisposable<IDisposable>();
register(mouseupListener);
register(mousedragListener);
const ctx: IMouseBindContext = { target, focus, requestedEvents, mouseupListener, mousedragListener };
const ctx: IMouseBindContext = { target, focus, requestedEvents };
const eventListeners: Record<'mouseup' | 'wheel' | 'mousedrag' | 'mousemove', EventListener> = {
mouseup: (ev: Event) => this._handleMouseUp(ctx, ev as MouseEvent),
wheel: (ev: Event) => this._handleWheel(ctx, ev as WheelEvent),
@@ -91,6 +85,16 @@ export class MouseService implements IMouseService {
// force initial onProtocolChange so we dont miss early mouse requests
this._mouseStateService.activeProtocol = this._mouseStateService.activeProtocol;
// Ensure document-level listeners are removed on dispose
register(toDisposable(() => {
if (requestedEvents.mouseup) {
document.removeEventListener('mouseup', requestedEvents.mouseup);
}
if (requestedEvents.mousedrag) {
document.removeEventListener('mousemove', requestedEvents.mousedrag);
}
}));
/**
* "Always on" event listeners.
*/
@@ -195,8 +199,12 @@ export class MouseService implements IMouseService {
this._sendEvent(ctx, ev);
if (!ev.buttons) {
// if no other button is held remove global handlers
ctx.mouseupListener.clear();
ctx.mousedragListener.clear();
if (ctx.requestedEvents.mouseup) {
ctx.target.document.removeEventListener('mouseup', ctx.requestedEvents.mouseup);
}
if (ctx.requestedEvents.mousedrag) {
ctx.target.document.removeEventListener('mousemove', ctx.requestedEvents.mousedrag);
}
}
}
@@ -238,14 +246,11 @@ export class MouseService implements IMouseService {
// of the terminal element.
// Note: Other emulators also do this for 'mousedown' while a button
// is held, we currently limit 'mousedown' to the terminal only.
// Use the element's current document in case it moved to another window after open.
const { element, document: targetDocument } = ctx.target;
const listenerDocument = element.ownerDocument ?? targetDocument;
if (ctx.requestedEvents.mouseup) {
ctx.mouseupListener.value = addDisposableListener(listenerDocument, 'mouseup', ctx.requestedEvents.mouseup);
ctx.target.document.addEventListener('mouseup', ctx.requestedEvents.mouseup);
}
if (ctx.requestedEvents.mousedrag) {
ctx.mousedragListener.value = addDisposableListener(listenerDocument, 'mousemove', ctx.requestedEvents.mousedrag);
ctx.target.document.addEventListener('mousemove', ctx.requestedEvents.mousedrag);
}
}
@@ -393,7 +398,7 @@ export class MouseService implements IMouseService {
}
private _handleProtocolChange(ctx: IMouseBindContext, eventListeners: Record<'mouseup' | 'wheel' | 'mousedrag' | 'mousemove', EventListener>, events: CoreMouseEventType): void {
const { element } = ctx.target;
const { element, document } = ctx.target;
const { requestedEvents } = ctx;
// apply global changes on events
if (events) {
@@ -428,14 +433,18 @@ export class MouseService implements IMouseService {
}
if (!(events & CoreMouseEventType.UP)) {
ctx.mouseupListener.clear();
if (requestedEvents.mouseup) {
document.removeEventListener('mouseup', requestedEvents.mouseup);
}
requestedEvents.mouseup = null;
} else {
requestedEvents.mouseup ??= eventListeners.mouseup;
}
if (!(events & CoreMouseEventType.DRAG)) {
ctx.mousedragListener.clear();
if (requestedEvents.mousedrag) {
document.removeEventListener('mousemove', requestedEvents.mousedrag);
}
requestedEvents.mousedrag = null;
} else {
requestedEvents.mousedrag ??= eventListeners.mousedrag;
+3 -3
View File
@@ -7,10 +7,10 @@ import { RenderDebouncer } from '../RenderDebouncer';
import { IRenderDebouncerWithCallback } from '../Types';
import { IRenderDimensions, IRenderer } from '../renderer/shared/Types';
import { ICharSizeService, ICoreBrowserService, IRenderService, IThemeService } from './Services';
import { Disposable, MutableDisposable, toDisposable } from '../../common/Lifecycle';
import { DebouncedIdleTask } from '../../common/TaskQueue';
import { Disposable, MutableDisposable, toDisposable } from '../../common/primitives/Lifecycle';
import { DebouncedIdleTask } from '../../common/primitives/TaskQueue';
import { IBufferService, ICoreService, IDecorationService, ILogService, IOptionsService } from '../../common/services/Services';
import { Emitter } from '../../common/Event';
import { Emitter } from '../../common/primitives/Event';
interface ISelectionState {
start: [number, number] | undefined;
@@ -6,13 +6,13 @@
import { assert } from 'chai';
import { SelectionService, SelectionMode } from './SelectionService';
import { SelectionModel } from '../selection/SelectionModel';
import { IBuffer, IBufferLine } from '../../common/buffer/Types';
import { IBuffer, IBufferLine } from '../../common/primitives/buffer/Types';
import { MockBufferService, MockOptionsService, MockCoreService, MockMouseStateService, createCellData } from '../../common/TestUtils.test';
import { BufferLine } from '../../common/buffer/BufferLine';
import { BufferLineStringCache } from '../../common/buffer/BufferLineStringCache';
import { BufferLine } from '../../common/primitives/buffer/BufferLine';
import { BufferLineStringCache } from '../../common/primitives/buffer/BufferLineStringCache';
import { IBufferService, IOptionsService } from '../../common/services/Services';
import { MockCoreBrowserService, MockMouseService, MockRenderService } from '../TestUtils.test';
import { CellData } from '../../common/buffer/CellData';
import { CellData } from '../../common/primitives/buffer/CellData';
import { IRenderService } from './Services';
const TEST_STRING_CACHE = new BufferLineStringCache();
+7 -7
View File
@@ -9,14 +9,14 @@ import { moveToCellSequence } from '../input/MoveToCell';
import { SelectionModel } from '../selection/SelectionModel';
import { ISelectionRedrawRequestEvent, ISelectionRequestScrollLinesEvent } from '../selection/Types';
import { ICoreBrowserService, IMouseCoordsService, IRenderService, ISelectionService } from './Services';
import { Disposable, MutableDisposable, toDisposable } from '../../common/Lifecycle';
import * as Browser from '../../common/Platform';
import { IDisposable } from '../../common/Types';
import { IBuffer, IBufferLine, ICellData } from '../../common/buffer/Types';
import { getRangeLength } from '../../common/buffer/BufferRange';
import { CellData } from '../../common/buffer/CellData';
import { Disposable, MutableDisposable, toDisposable } from '../../common/primitives/Lifecycle';
import * as Browser from '../../common/primitives/Platform';
import { IDisposable } from '../../common/primitives/Types';
import { IBuffer, IBufferLine, ICellData } from '../../common/primitives/buffer/Types';
import { getRangeLength } from '../../common/primitives/buffer/BufferRange';
import { CellData } from '../../common/primitives/buffer/CellData';
import { IBufferService, ICoreService, IMouseStateService, IOptionsService } from '../../common/services/Services';
import { Emitter } from '../../common/Event';
import { Emitter } from '../../common/primitives/Event';
const enum Constants {
/**
+2 -2
View File
@@ -7,8 +7,8 @@ import { IRenderDimensions, IRenderer } from '../renderer/shared/Types';
import { IColorSet, ILink, ReadonlyColorSet } from '../Types';
import { ISelectionRedrawRequestEvent as ISelectionRequestRedrawEvent, ISelectionRequestScrollLinesEvent } from '../selection/Types';
import { createDecorator } from '../../common/services/ServiceRegistry';
import { AllColorIndex, IDisposable, IKeyboardResult } from '../../common/Types';
import type { IEvent } from '../../common/Event';
import { AllColorIndex, IDisposable, IKeyboardResult } from '../../common/primitives/Types';
import type { IEvent } from '../../common/primitives/Event';
export const ICharSizeService = createDecorator<ICharSizeService>('CharSizeService');
export interface ICharSizeService {
+4 -4
View File
@@ -6,11 +6,11 @@
import { ColorContrastCache } from '../ColorContrastCache';
import { IThemeService } from './Services';
import { DEFAULT_ANSI_COLORS, IColorContrastCache, IColorSet, ReadonlyColorSet } from '../Types';
import { color, css, NULL_COLOR } from '../../common/Color';
import { Disposable } from '../../common/Lifecycle';
import { color, css, NULL_COLOR } from '../../common/primitives/Color';
import { Disposable } from '../../common/primitives/Lifecycle';
import { IOptionsService, ITheme } from '../../common/services/Services';
import { AllColorIndex, IColor, SpecialColorIndex } from '../../common/Types';
import { Emitter } from '../../common/Event';
import { AllColorIndex, IColor, SpecialColorIndex } from '../../common/primitives/Types';
import { Emitter } from '../../common/primitives/Event';
interface IRestoreColorSet {
foreground: IColor;
+8 -7
View File
@@ -26,20 +26,21 @@ import { InstantiationService } from './services/InstantiationService';
import { LogService } from './services/LogService';
import { BufferService, BufferServiceConstants } from './services/BufferService';
import { OptionsService } from './services/OptionsService';
import { IDisposable, IScrollEvent, ITerminalOptions, IParams } from './Types';
import { IAttributeData, IBufferSet } from './buffer/Types';
import { IDisposable, IParams } from './primitives/Types';
import { IScrollEvent, ITerminalOptions } from './Types';
import { IAttributeData, IBufferSet } from './primitives/buffer/Types';
import { CoreService } from './services/CoreService';
import { MouseStateService } from './services/MouseStateService';
import { UnicodeV6 } from './input/UnicodeV6';
import { UnicodeV6 } from './primitives/input/UnicodeV6';
import { UnicodeService } from './services/UnicodeService';
import { CharsetService } from './services/CharsetService';
import { updateWindowsModeWrappedState } from './WindowsMode';
import { IFunctionIdentifier } from './parser/Types';
import { IFunctionIdentifier } from './primitives/parser/Types';
import { InputHandler } from './InputHandler';
import { WriteBuffer } from './input/WriteBuffer';
import { WriteBuffer } from './primitives/input/WriteBuffer';
import { OscLinkService } from './services/OscLinkService';
import { Emitter, EventUtils, type IEvent } from './Event';
import { Disposable, MutableDisposable, toDisposable } from './Lifecycle';
import { Emitter, EventUtils, type IEvent } from './primitives/Event';
import { Disposable, MutableDisposable, toDisposable } from './primitives/Lifecycle';
// Only trigger this warning a single time per session
let hasWriteSyncWarnHappened = false;
+8 -8
View File
@@ -5,13 +5,13 @@
import { assert } from 'chai';
import { InputHandler } from './InputHandler';
import { IColorEvent, ColorRequestType, SpecialColorIndex } from './Types';
import { IAttributeData, IBufferLine } from './buffer/Types';
import { DEFAULT_ATTR_DATA } from './buffer/BufferLine';
import { CellData } from './buffer/CellData';
import { Attributes, BgFlags, UnderlineStyle } from './buffer/Constants';
import { AttributeData, ExtendedAttrs } from './buffer/AttributeData';
import { Params } from './parser/Params';
import { IColorEvent, ColorRequestType, SpecialColorIndex } from './primitives/Types';
import { IAttributeData, IBufferLine } from './primitives/buffer/Types';
import { DEFAULT_ATTR_DATA } from './primitives/buffer/BufferLine';
import { CellData } from './primitives/buffer/CellData';
import { Attributes, BgFlags, UnderlineStyle } from './primitives/buffer/Constants';
import { AttributeData, ExtendedAttrs } from './primitives/buffer/AttributeData';
import { Params } from './primitives/parser/Params';
import { MockCoreService, MockBufferService, MockOptionsService, MockLogService, MockMouseStateService, MockCharsetService, MockUnicodeService, MockOscLinkService, extendedAttributes } from './TestUtils.test';
import { IBufferService, ICoreService, type IOscLinkService } from './services/Services';
import { DEFAULT_OPTIONS } from './services/OptionsService';
@@ -19,7 +19,7 @@ import { BufferService } from './services/BufferService';
import { CharsetService } from './services/CharsetService';
import { CoreService } from './services/CoreService';
import { OscLinkService } from './services/OscLinkService';
import { CHARSETS } from './data/Charsets';
import { CHARSETS } from './primitives/data/Charsets';
function getCursor(bufferService: IBufferService): number[] {
+19 -18
View File
@@ -4,26 +4,27 @@
* @license MIT
*/
import { IInputHandler, IDisposable, IWindowOptions, IColorEvent, IParseStack, ColorIndex, ColorRequestType, SpecialColorIndex } from './Types';
import { IAttributeData, IBuffer } from './buffer/Types';
import { C0, C1 } from './data/EscapeSequences';
import { CHARSETS, DEFAULT_CHARSET } from './data/Charsets';
import { EscapeSequenceParser } from './parser/EscapeSequenceParser';
import { Disposable } from './Lifecycle';
import { StringToUtf32, stringFromCodePoint, Utf8ToUtf32 } from './input/TextDecoder';
import { BufferLine, DEFAULT_ATTR_DATA } from './buffer/BufferLine';
import { IParsingState, IEscapeSequenceParser, IParams, IFunctionIdentifier } from './parser/Types';
import { NULL_CELL_CODE, NULL_CELL_WIDTH, Attributes, FgFlags, BgFlags, Content, UnderlineStyle } from './buffer/Constants';
import { CellData } from './buffer/CellData';
import { AttributeData } from './buffer/AttributeData';
import { IDisposable, IColorEvent, ColorIndex, ColorRequestType, SpecialColorIndex } from './primitives/Types';
import { IInputHandler, IWindowOptions, IParseStack } from './Types';
import { IAttributeData, IBuffer } from './primitives/buffer/Types';
import { C0, C1 } from './primitives/data/EscapeSequences';
import { CHARSETS, DEFAULT_CHARSET } from './primitives/data/Charsets';
import { EscapeSequenceParser } from './primitives/parser/EscapeSequenceParser';
import { Disposable } from './primitives/Lifecycle';
import { StringToUtf32, stringFromCodePoint, Utf8ToUtf32 } from './primitives/input/TextDecoder';
import { BufferLine, DEFAULT_ATTR_DATA } from './primitives/buffer/BufferLine';
import { IParsingState, IEscapeSequenceParser, IParams, IFunctionIdentifier } from './primitives/parser/Types';
import { NULL_CELL_CODE, NULL_CELL_WIDTH, Attributes, FgFlags, BgFlags, Content, UnderlineStyle } from './primitives/buffer/Constants';
import { CellData } from './primitives/buffer/CellData';
import { AttributeData } from './primitives/buffer/AttributeData';
import { ICoreService, IBufferService, IOptionsService, ILogService, IMouseStateService, ICharsetService, IUnicodeService, LogLevelEnum, IOscLinkService } from './services/Services';
import { UnicodeService } from './services/UnicodeService';
import { OscHandler } from './parser/OscParser';
import { DcsHandler } from './parser/DcsParser';
import { ApcHandler } from './parser/ApcParser';
import { parseColor } from './input/XParseColor';
import { Emitter } from './Event';
import { XTERM_VERSION } from './Version';
import { OscHandler } from './primitives/parser/OscParser';
import { DcsHandler } from './primitives/parser/DcsParser';
import { ApcHandler } from './primitives/parser/ApcParser';
import { parseColor } from './primitives/input/XParseColor';
import { Emitter } from './primitives/Event';
import { XTERM_VERSION } from './primitives/Version';
/**
* Map collect to glevel. Used in `selectCharset`.
+8 -7
View File
@@ -6,14 +6,15 @@
import { IBufferService, ICoreService, ILogService, IOptionsService, ITerminalOptions, IMouseStateService, ICharsetService, UnicodeCharProperties, UnicodeCharWidth, IUnicodeService, IUnicodeVersionProvider, LogLevelEnum, IDecorationService, IInternalDecoration, IOscLinkService, type IBufferResizeEvent } from './services/Services';
import { UnicodeService } from './services/UnicodeService';
import { DEFAULT_OPTIONS } from './services/OptionsService';
import { IAttributeData, IBuffer, IBufferLine, IBufferSet, IExtendedAttrs } from './buffer/Types';
import { BufferSet } from './buffer/BufferSet';
import { IDecPrivateModes, ICoreMouseEvent, CoreMouseEventType, ICharset, IModes, IOscLinkData, IDisposable } from './Types';
import { UnicodeV6 } from './input/UnicodeV6';
import { IAttributeData, IBuffer, IBufferLine, IBufferSet, IExtendedAttrs } from './primitives/buffer/Types';
import { BufferSet } from './primitives/buffer/BufferSet';
import { ICoreMouseEvent, CoreMouseEventType, ICharset, IOscLinkData, IDisposable } from './primitives/Types';
import { IDecPrivateModes, IModes } from './Types';
import { UnicodeV6 } from './primitives/input/UnicodeV6';
import { IDecorationOptions, IDecoration } from '@xterm/xterm';
import { Emitter, type IEvent } from './Event';
import { CellData } from './buffer/CellData';
import { DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH } from './buffer/Constants';
import { Emitter, type IEvent } from './primitives/Event';
import { CellData } from './primitives/buffer/CellData';
import { DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH } from './primitives/buffer/Constants';
export function createCellData(attr: number, char: string, width: number): CellData {
return CellData.fromCharData([attr, char, width, char.length === 0 ? 0 : char.charCodeAt(0)]);
+2 -226
View File
@@ -4,36 +4,8 @@
*/
import { IFunctionIdentifier, ITerminalOptions as IPublicTerminalOptions } from '@xterm/xterm';
import type { IEvent } from './Event';
/** sequence params serialized to js arrays */
export type ParamsArray = (number | number[])[];
/** Interface of Params storage class. */
export interface IParams {
/** from ctor */
maxLength: number;
maxSubParamsLength: number;
/** param values and its length */
params: Int32Array;
length: number;
/** methods */
clone(): IParams;
toArray(): ParamsArray;
reset(): void;
resetZdm(): void;
addParam(value: number): void;
addSubParam(value: number): void;
hasSubParams(idx: number): boolean;
getSubParams(idx: number): Int32Array | null;
getSubParamsAll(): {[idx: number]: Int32Array};
}
export interface IDisposable {
dispose(): void;
}
import type { IEvent } from './primitives/Event';
import type { CursorStyle, IDisposable, IParams } from './primitives/Types';
// TODO: The options that are not in the public API should be reviewed
export interface ITerminalOptions extends IPublicTerminalOptions {
@@ -42,66 +14,10 @@ export interface ITerminalOptions extends IPublicTerminalOptions {
termName?: string;
}
export type CursorStyle = 'block' | 'underline' | 'bar';
export type CursorInactiveStyle = 'outline' | 'block' | 'bar' | 'underline' | 'none';
export type XtermListener = (...args: any[]) => void;
/**
* A keyboard event interface which does not depend on the DOM, KeyboardEvent implicitly extends
* this event.
*/
export interface IKeyboardEvent {
altKey: boolean;
ctrlKey: boolean;
shiftKey: boolean;
metaKey: boolean;
/** @deprecated See KeyboardEvent.keyCode */
keyCode: number;
key: string;
type: string;
code: string;
}
export interface IScrollEvent {
position: number;
}
export const enum KeyboardResultType {
SEND_KEY,
SELECT_ALL,
PAGE_UP,
PAGE_DOWN
}
export interface IKeyboardResult {
type: KeyboardResultType;
cancel: boolean;
key: string | undefined;
}
export interface ICharset {
[key: string]: string | undefined;
}
export interface IColor {
readonly css: string;
readonly rgba: number; // 32-bit int with rgba in each byte
}
export type IColorRGB = [red: number, green: number, blue: number];
/**
* Tracks the current hyperlink. Since these are treated as extended attirbutes, these get passed on
* to the linkifier when anything is printed. Doing it this way ensures that even when the cursor
* moves around unexpectedly the link is tracked, as opposed to using a start position and
* finalizing it at the end.
*/
export interface IOscLinkData {
id?: string;
uri: string;
}
export interface IModes {
insertMode: boolean;
}
@@ -138,110 +54,6 @@ export interface IKittyKeyboardState {
altStack: number[];
}
export interface IRowRange {
start: number;
end: number;
}
/**
* Interface for mouse events in the core.
*/
export const enum CoreMouseButton {
LEFT = 0,
MIDDLE = 1,
RIGHT = 2,
NONE = 3,
WHEEL = 4,
// additional buttons 1..8
// untested!
AUX1 = 8,
AUX2 = 9,
AUX3 = 10,
AUX4 = 11,
AUX5 = 12,
AUX6 = 13,
AUX7 = 14,
AUX8 = 15
}
export const enum CoreMouseAction {
UP = 0, // buttons, wheel
DOWN = 1, // buttons, wheel
LEFT = 2, // wheel only
RIGHT = 3, // wheel only
MOVE = 32 // buttons only
}
export interface ICoreMouseEvent {
/** column (zero based). */
col: number;
/** row (zero based). */
row: number;
/** xy pixel positions. */
x: number;
y: number;
/**
* Button the action occurred. Due to restrictions of the tracking protocols
* it is not possible to report multiple buttons at once.
* Wheel is treated as a button.
* There are invalid combinations of buttons and actions possible
* (like move + wheel), those are silently ignored by the MouseStateService.
*/
button: CoreMouseButton;
action: CoreMouseAction;
/**
* Modifier states.
* Protocols will add/ignore those based on specific restrictions.
*/
ctrl?: boolean;
alt?: boolean;
shift?: boolean;
}
/**
* CoreMouseEventType
* To be reported to the browser component which events a mouse
* protocol wants to be catched and forwarded as an ICoreMouseEvent
* to MouseStateService.
*/
export const enum CoreMouseEventType {
NONE = 0,
/** any mousedown event */
DOWN = 1,
/** any mouseup event */
UP = 2,
/** any mousemove event while a button is held */
DRAG = 4,
/** any mousemove event without a button */
MOVE = 8,
/** any wheel event */
WHEEL = 16
}
/**
* Mouse protocol interface.
* A mouse protocol can be registered and activated at the MouseStateService.
* `events` should contain a list of needed events as a hint for the browser component
* to install/remove the appropriate event handlers.
* `restrict` applies further protocol specific restrictions like not allowed
* modifiers or filtering invalid event types.
*/
export interface ICoreMouseProtocol {
events: CoreMouseEventType;
restrict: (e: ICoreMouseEvent) => boolean;
}
/**
* CoreMouseEncoding
* The tracking encoding can be registered and activated at the MouseStateService.
* If a ICoreMouseEvent passes all procotol restrictions it will be encoded
* with the active encoding and sent out.
* Note: Returning an empty string will supress sending a mouse report,
* which can be used to skip creating falsey reports in limited encodings
* (DEFAULT only supports up to 223 1-based as coord value).
*/
export type CoreMouseEncoding = (event: ICoreMouseEvent) => string;
/**
* windowOptions
*/
@@ -270,42 +82,6 @@ export interface IWindowOptions {
setWinLines?: boolean;
}
// color events from common, used for OSC 4/10/11/12 and 104/110/111/112
export const enum ColorRequestType {
REPORT = 0,
SET = 1,
RESTORE = 2
}
// IntRange from https://stackoverflow.com/a/39495173
type Enumerate<N extends number, Acc extends number[] = []> = Acc['length'] extends N
? Acc[number]
: Enumerate<N, [...Acc, Acc['length']]>;
type IntRange<F extends number, T extends number> = Exclude<Enumerate<T>, Enumerate<F>>;
export type ColorIndex = IntRange<0, 256>; // number from 0 to 255
export type AllColorIndex = ColorIndex | SpecialColorIndex;
export const enum SpecialColorIndex {
FOREGROUND = 256,
BACKGROUND = 257,
CURSOR = 258
}
export interface IColorReportRequest {
type: ColorRequestType.REPORT;
index: AllColorIndex;
}
export interface IColorSetRequest {
type: ColorRequestType.SET;
index: AllColorIndex;
color: IColorRGB;
}
export interface IColorRestoreRequest {
type: ColorRequestType.RESTORE;
index?: AllColorIndex;
}
export type IColorEvent = (IColorReportRequest | IColorSetRequest | IColorRestoreRequest)[];
/**
* Calls the parser and handles actions generated by the parser.
*/
+1 -1
View File
@@ -4,7 +4,7 @@
*/
import { assert } from 'chai';
import { DEFAULT_ATTR_DATA } from './buffer/BufferLine';
import { DEFAULT_ATTR_DATA } from './primitives/buffer/BufferLine';
import { updateWindowsModeWrappedState } from './WindowsMode';
import { BufferService } from './services/BufferService';
import { OptionsService } from './services/OptionsService';
+1 -1
View File
@@ -3,7 +3,7 @@
* @license MIT
*/
import { CHAR_DATA_CODE_INDEX, NULL_CELL_CODE, WHITESPACE_CELL_CODE } from './buffer/Constants';
import { CHAR_DATA_CODE_INDEX, NULL_CELL_CODE, WHITESPACE_CELL_CODE } from './primitives/buffer/Constants';
import { IBufferService } from './services/Services';
export function updateWindowsModeWrappedState(bufferService: IBufferService): void {
@@ -6,9 +6,9 @@
* Simplified from VS Code's lifecycle.ts - no tracking/leak detection.
*/
export interface IDisposable {
dispose(): void;
}
import type { IDisposable } from './Types';
export type { IDisposable };
export function toDisposable(fn: () => void): IDisposable {
return { dispose: fn };

Some files were not shown because too many files have changed in this diff Show More