@xterm/xterm 6.1.0-beta.22 → 6.1.0-beta.221

package/src/common/parser/Types.ts

@@ -32,6 +32,7 @@ export interface IParams {
   clone(): IParams;
   toArray(): ParamsArray;
   reset(): void;
+  resetZdm(): void;
   addParam(value: number): void;
   addSubParam(value: number): void;
   hasSubParams(idx: number): boolean;
@@ -107,7 +108,7 @@ export type EscFallbackHandlerType = (identifier: number) => void;
 /**
  * EXECUTE handler types.
  */
-export type ExecuteHandlerType = () => boolean;
+export type ExecuteHandlerType = (ident?: number) => boolean;
 export type ExecuteFallbackHandlerType = (ident: number) => void;
 
 /**
@@ -134,6 +135,29 @@ export interface IOscHandler {
 }
 export type OscFallbackHandlerType = (ident: number, action: 'START' | 'PUT' | 'END', payload?: any) => void;
 
+/**
+ * APC handler types.
+ */
+export interface IApcHandler {
+  /**
+   * Announces start of this APC command.
+   * Prepare needed data structures here.
+   */
+  start(): void;
+  /**
+   * Incoming data chunk.
+   */
+  put(data: Uint32Array, start: number, end: number): void;
+  /**
+   * End of APC command. `success` indicates whether the
+   * command finished normally or got aborted, thus final
+   * execution of the command should depend on `success`.
+   * To save memory also cleanup data structures here.
+   */
+  end(success: boolean): boolean | Promise<boolean>;
+}
+export type ApcFallbackHandlerType = (ident: number, action: 'START' | 'PUT' | 'END', payload?: any) => void;
+
 /**
  * PRINT handler types.
  */
@@ -196,6 +220,10 @@ export interface IEscapeSequenceParser extends IDisposable {
   clearOscHandler(ident: number): void;
   setOscHandlerFallback(handler: OscFallbackHandlerType): void;
 
+  registerApcHandler(id: IFunctionIdentifier, handler: IApcHandler): IDisposable;
+  clearApcHandler(id: IFunctionIdentifier): void;
+  setApcHandlerFallback(handler: ApcFallbackHandlerType): void;
+
   setErrorHandler(handler: (state: IParsingState) => IParsingState): void;
   clearErrorHandler(): void;
 }
@@ -223,6 +251,11 @@ export interface IDcsParser extends ISubParser<IDcsHandler, DcsFallbackHandlerTy
   unhook(success: boolean, promiseResult?: boolean): void | Promise<boolean>;
 }
 
+export interface IApcParser extends ISubParser<IApcHandler, ApcFallbackHandlerType> {
+  start(ident: number): void;
+  end(success: boolean, promiseResult?: boolean): void | Promise<boolean>;
+}
+
 /**
  * Interface to denote a specific ESC, CSI or DCS handler slot.
  * The values are used to create an integer respresentation during handler
@@ -252,7 +285,8 @@ export const enum ParserStackType {
   CSI,
   ESC,
   OSC,
-  DCS
+  DCS,
+  APC
 }
 
 // aggregate of resumable handler lists

package/src/common/public/BufferLineApiView.ts

@@ -18,10 +18,10 @@ export class BufferLineApiView implements IBufferLineApi {
     }
 
     if (cell) {
-      this._line.loadCell(x, cell as ICellData);
+      this._line.loadCell(x, cell as unknown as ICellData);
       return cell;
     }
-    return this._line.loadCell(x, new CellData());
+    return this._line.loadCell(x, new CellData()) as unknown as IBufferCellApi;
   }
   public translateToString(trimRight?: boolean, startColumn?: number, endColumn?: number): string {
     return this._line.translateToString(trimRight, startColumn, endColumn);

package/src/common/public/BufferNamespaceApi.ts

@@ -6,8 +6,8 @@
 import { IBuffer as IBufferApi, IBufferNamespace as IBufferNamespaceApi } from '@xterm/xterm';
 import { BufferApiView } from 'common/public/BufferApiView';
 import { ICoreTerminal } from 'common/Types';
-import { Disposable } from 'vs/base/common/lifecycle';
-import { Emitter } from 'vs/base/common/event';
+import { Disposable } from 'common/Lifecycle';
+import { Emitter } from 'common/Event';
 
 export class BufferNamespaceApi extends Disposable implements IBufferNamespaceApi {
   private _normal: BufferApiView;

package/src/common/public/ParserApi.ts

@@ -34,4 +34,7 @@ export class ParserApi implements IParser {
   public addOscHandler(ident: number, callback: (data: string) => boolean | Promise<boolean>): IDisposable {
     return this.registerOscHandler(ident, callback);
   }
+  public registerApcHandler(id: IFunctionIdentifier, callback: (data: string) => boolean | Promise<boolean>): IDisposable {
+    return this._core.registerApcHandler(id, callback);
+  }
 }

package/src/common/services/BufferService.ts

@@ -3,15 +3,17 @@
  * @license MIT
  */
 
-import { Disposable } from 'vs/base/common/lifecycle';
+import { Disposable } from 'common/Lifecycle';
 import { IAttributeData, IBufferLine } from 'common/Types';
 import { BufferSet } from 'common/buffer/BufferSet';
 import { IBuffer, IBufferSet } from 'common/buffer/Types';
-import { IBufferService, IOptionsService, type IBufferResizeEvent } from 'common/services/Services';
-import { Emitter } from 'vs/base/common/event';
+import { IBufferService, ILogService, IOptionsService, type IBufferResizeEvent } from 'common/services/Services';
+import { Emitter } from 'common/Event';
 
-export const MINIMUM_COLS = 2; // Less than 2 can mess with wide chars
-export const MINIMUM_ROWS = 1;
+export const enum BufferServiceConstants {
+  MINIMUM_COLS = 2, // Less than 2 can mess with wide chars
+  MINIMUM_ROWS = 1
+}
 
 export class BufferService extends Disposable implements IBufferService {
   public serviceBrand: any;
@@ -32,11 +34,14 @@ export class BufferService extends Disposable implements IBufferService {
   /** An IBufferline to clone/copy from for new blank lines */
   private _cachedBlankLine: IBufferLine | undefined;
 
-  constructor(@IOptionsService optionsService: IOptionsService) {
+  constructor(
+    @IOptionsService optionsService: IOptionsService,
+    @ILogService logService: ILogService
+  ) {
     super();
-    this.cols = Math.max(optionsService.rawOptions.cols || 0, MINIMUM_COLS);
-    this.rows = Math.max(optionsService.rawOptions.rows || 0, MINIMUM_ROWS);
-    this.buffers = this._register(new BufferSet(optionsService, this));
+    this.cols = Math.max(optionsService.rawOptions.cols || 0, BufferServiceConstants.MINIMUM_COLS);
+    this.rows = Math.max(optionsService.rawOptions.rows || 0, BufferServiceConstants.MINIMUM_ROWS);
+    this.buffers = this._register(new BufferSet(optionsService, this, logService));
     this._register(this.buffers.onBufferActivate(e => {
       this._onScroll.fire(e.activeBuffer.ydisp);
     }));

package/src/common/services/CharsetService.ts

@@ -14,6 +14,10 @@ export class CharsetService implements ICharsetService {
 
   private _charsets: (ICharset | undefined)[] = [];
 
+  public get charsets(): (ICharset | undefined)[] {
+    return this._charsets;
+  }
+
   public reset(): void {
     this.charset = undefined;
     this._charsets = [];

package/src/common/services/CoreService.ts

@@ -4,10 +4,10 @@
  */
 
 import { clone } from 'common/Clone';
-import { Disposable } from 'vs/base/common/lifecycle';
-import { IDecPrivateModes, IModes } from 'common/Types';
+import { Disposable } from 'common/Lifecycle';
+import { IDecPrivateModes, IKittyKeyboardState, IModes } from 'common/Types';
 import { IBufferService, ICoreService, ILogService, IOptionsService } from 'common/services/Services';
-import { Emitter } from 'vs/base/common/event';
+import { Emitter } from 'common/Event';
 
 const DEFAULT_MODES: IModes = Object.freeze({
   insertMode: false
@@ -17,22 +17,33 @@ const DEFAULT_DEC_PRIVATE_MODES: IDecPrivateModes = Object.freeze({
   applicationCursorKeys: false,
   applicationKeypad: false,
   bracketedPasteMode: false,
+  colorSchemeUpdates: false,
   cursorBlink: undefined,
   cursorStyle: undefined,
   origin: false,
   reverseWraparound: false,
   sendFocus: false,
   synchronizedOutput: false,
+  win32InputMode: false,
   wraparound: true // defaults: xterm - true, vt100 - false
 });
 
+const DEFAULT_KITTY_KEYBOARD_STATE = (): IKittyKeyboardState => ({
+  flags: 0,
+  mainFlags: 0,
+  altFlags: 0,
+  mainStack: [],
+  altStack: []
+});
+
 export class CoreService extends Disposable implements ICoreService {
   public serviceBrand: any;
 
-  public isCursorInitialized: boolean = false;
+  public isCursorInitialized: boolean;
   public isCursorHidden: boolean = false;
   public modes: IModes;
   public decPrivateModes: IDecPrivateModes;
+  public kittyKeyboard: IKittyKeyboardState;
 
   private readonly _onData = this._register(new Emitter<string>());
   public readonly onData = this._onData.event;
@@ -49,13 +60,16 @@ export class CoreService extends Disposable implements ICoreService {
     @IOptionsService private readonly _optionsService: IOptionsService
   ) {
     super();
+    this.isCursorInitialized = _optionsService.rawOptions.showCursorImmediately ?? false;
     this.modes = clone(DEFAULT_MODES);
     this.decPrivateModes = clone(DEFAULT_DEC_PRIVATE_MODES);
+    this.kittyKeyboard = DEFAULT_KITTY_KEYBOARD_STATE();
   }
 
   public reset(): void {
     this.modes = clone(DEFAULT_MODES);
     this.decPrivateModes = clone(DEFAULT_DEC_PRIVATE_MODES);
+    this.kittyKeyboard = DEFAULT_KITTY_KEYBOARD_STATE();
   }
 
   public triggerDataEvent(data: string, wasUserInput: boolean = false): void {

package/src/common/services/DecorationService.ts

@@ -3,13 +3,15 @@
  * @license MIT
  */
 
+import type { IDeleteEvent, IInsertEvent } from 'common/CircularList';
+import { MicrotaskTimer } from 'common/Async';
 import { css } from 'common/Color';
-import { Disposable, DisposableStore, toDisposable } from 'vs/base/common/lifecycle';
-import { IDecorationService, IInternalDecoration } from 'common/services/Services';
+import { Disposable, DisposableStore, MutableDisposable, toDisposable } from 'common/Lifecycle';
+import { IBufferService, IDecorationService, IInternalDecoration, ILogService } from 'common/services/Services';
 import { SortedList } from 'common/SortedList';
-import { IColor } from 'common/Types';
+import { IColor, ICircularList } from 'common/Types';
 import { IDecoration, IDecorationOptions, IMarker } from '@xterm/xterm';
-import { Emitter } from 'vs/base/common/event';
+import { Emitter } from 'common/Event';
 
 // Work variables to avoid garbage collection
 let $xmin = 0;
@@ -23,7 +25,9 @@ export class DecorationService extends Disposable implements IDecorationService
    * while marker line values do change, they should all change by the same amount so this should
    * never become out of order.
    */
-  private readonly _decorations: SortedList<IInternalDecoration> = new SortedList(e => e?.marker.line);
+  private readonly _decorations: SortedList<IInternalDecoration>;
+
+  private readonly _lineCache = this._register(new DecorationLineCache());
 
   private readonly _onDecorationRegistered = this._register(new Emitter<IInternalDecoration>());
   public readonly onDecorationRegistered = this._onDecorationRegistered.event;
@@ -32,10 +36,19 @@ export class DecorationService extends Disposable implements IDecorationService
 
   public get decorations(): IterableIterator<IInternalDecoration> { return this._decorations.values(); }
 
-  constructor() {
+  constructor(
+    @ILogService private readonly _logService: ILogService,
+    @IBufferService private readonly _bufferService: IBufferService
+  ) {
     super();
 
+    this._decorations = new SortedList(e => e?.marker.line, this._logService);
+
     this._register(toDisposable(() => this.reset()));
+    this._register(this._bufferService.buffers.onBufferActivate(() => {
+      this._lineCache.attachToBufferLines(this._bufferService.buffer.lines);
+    }));
+    this._lineCache.attachToBufferLines(this._bufferService.buffer.lines);
   }
 
   public registerDecoration(options: IDecorationOptions): IDecoration | undefined {
@@ -49,12 +62,14 @@ export class DecorationService extends Disposable implements IDecorationService
         listener.dispose();
         if (decoration) {
           if (this._decorations.delete(decoration)) {
+            this._lineCache.remove(decoration);
             this._onDecorationRemoved.fire(decoration);
           }
           markerDispose.dispose();
         }
       });
       this._decorations.insert(decoration);
+      this._lineCache.add(decoration);
       this._onDecorationRegistered.fire(decoration);
     }
     return decoration;
@@ -65,12 +80,17 @@ export class DecorationService extends Disposable implements IDecorationService
       d.dispose();
     }
     this._decorations.clear();
+    this._lineCache.clear();
   }
 
   public *getDecorationsAtCell(x: number, line: number, layer?: 'bottom' | 'top'): IterableIterator<IInternalDecoration> {
+    const bucket = this._lineCache.getDecorationsOnLine(line);
+    if (!bucket) {
+      return;
+    }
     let xmin = 0;
     let xmax = 0;
-    for (const d of this._decorations.getKeyIterator(line)) {
+    for (const d of bucket) {
       xmin = d.options.x ?? 0;
       xmax = xmin + (d.options.width ?? 1);
       if (x >= xmin && x < xmax && (!layer || (d.options.layer ?? 'bottom') === layer)) {
@@ -80,20 +100,249 @@ export class DecorationService extends Disposable implements IDecorationService
   }
 
   public forEachDecorationAtCell(x: number, line: number, layer: 'bottom' | 'top' | undefined, callback: (decoration: IInternalDecoration) => void): void {
-    this._decorations.forEachByKey(line, d => {
+    const bucket = this._lineCache.getDecorationsOnLine(line);
+    if (!bucket) {
+      return;
+    }
+    for (const d of bucket) {
       $xmin = d.options.x ?? 0;
       $xmax = $xmin + (d.options.width ?? 1);
       if (x >= $xmin && x < $xmax && (!layer || (d.options.layer ?? 'bottom') === layer)) {
         callback(d);
       }
+    }
+  }
+}
+
+/**
+ * Per-logical-line index of decorations for fast cell lookup.
+ *
+ * Keys are marker.line coordinates (logical buffer lines), not CircularList ring slots.
+ * Multi-line decorations appear in every line bucket they span. The index is kept aligned
+ * with marker.line updates via buffer line trim/insert/delete events.
+ */
+export class DecorationLineCache extends Disposable {
+  private readonly _decorationsByLine: Map<number, IInternalDecoration[]> = new Map();
+  private readonly _decorations = new Set<IInternalDecoration>();
+  private readonly _bufferLineListeners = this._register(new MutableDisposable<DisposableStore>());
+  private readonly _lineIndexSyncTimer = this._register(new MicrotaskTimer());
+  private _lineIndexSyncCallbacks: (() => void)[] = [];
+
+  public clear(): void {
+    this._lineIndexSyncCallbacks.length = 0;
+    this._lineIndexSyncTimer.cancel();
+    this._decorationsByLine.clear();
+    this._decorations.clear();
+  }
+
+  public add(decoration: IInternalDecoration): void {
+    this._decorations.add(decoration);
+    this._addToLineBuckets(decoration);
+  }
+
+  public remove(decoration: IInternalDecoration): void {
+    this._decorations.delete(decoration);
+    this._removeFromLineBuckets(decoration);
+  }
+
+  public getDecorationsOnLine(line: number): ReadonlyArray<IInternalDecoration> | undefined {
+    return this._decorationsByLine.get(line);
+  }
+
+  public attachToBufferLines(lines: ICircularList<unknown>): void {
+    const store = new DisposableStore();
+    this._bufferLineListeners.value = store;
+    store.add(lines.onTrim(amount => this._handleBufferLinesTrim(amount)));
+    store.add(lines.onInsert(event => this._handleBufferLinesInsert(event)));
+    store.add(lines.onDelete(event => this._handleBufferLinesDelete(event)));
+  }
+
+  private _getDecorationHeight(decoration: IInternalDecoration): number {
+    return decoration.options.height ?? 1;
+  }
+
+  private _addToLineBuckets(decoration: IInternalDecoration): void {
+    const start = decoration.marker.line;
+    if (start < 0) {
+      return;
+    }
+    decoration._indexedStartLine = start;
+    const height = this._getDecorationHeight(decoration);
+    for (let line = start; line < start + height; line++) {
+      let bucket = this._decorationsByLine.get(line);
+      if (!bucket) {
+        bucket = [];
+        this._decorationsByLine.set(line, bucket);
+      }
+      bucket.push(decoration);
+    }
+  }
+
+  private _removeFromLineBuckets(decoration: IInternalDecoration): void {
+    const start = decoration._indexedStartLine;
+    const height = this._getDecorationHeight(decoration);
+    for (let line = start; line < start + height; line++) {
+      const bucket = this._decorationsByLine.get(line);
+      if (!bucket) {
+        continue;
+      }
+      const index = bucket.indexOf(decoration);
+      if (index !== -1) {
+        bucket.splice(index, 1);
+      }
+      if (bucket.length === 0) {
+        this._decorationsByLine.delete(line);
+      }
+    }
+  }
+
+  private _reindexDecoration(decoration: IInternalDecoration): void {
+    this._removeFromLineBuckets(decoration);
+    if (!decoration.marker.isDisposed && decoration.marker.line >= 0) {
+      this._addToLineBuckets(decoration);
+    }
+  }
+
+  /** Re-index after marker line updates (buffer listeners may run before markers). */
+  private _scheduleLineIndexSync(callback: () => void): void {
+    this._lineIndexSyncCallbacks.push(callback);
+    this._lineIndexSyncTimer.set(() => {
+      const callbacks = this._lineIndexSyncCallbacks;
+      this._lineIndexSyncCallbacks = [];
+      for (const cb of callbacks) {
+        cb();
+      }
     });
   }
+
+  private _handleBufferLinesTrim(amount: number): void {
+    if (amount <= 0) {
+      return;
+    }
+    const newMap = new Map<number, IInternalDecoration[]>();
+    for (const [line, bucket] of this._decorationsByLine) {
+      const newLine = line - amount;
+      if (newLine < 0) {
+        continue;
+      }
+      const existing = newMap.get(newLine);
+      if (existing) {
+        existing.push(...bucket);
+      } else {
+        newMap.set(newLine, bucket.slice());
+      }
+    }
+    this._decorationsByLine.clear();
+    for (const [line, bucket] of newMap) {
+      this._decorationsByLine.set(line, bucket);
+    }
+    for (const d of this._decorations) {
+      if (!d.marker.isDisposed) {
+        d._indexedStartLine -= amount;
+      }
+    }
+  }
+
+  private _handleBufferLinesInsert(event: IInsertEvent): void {
+    this._scheduleLineIndexSync(() => this._applyBufferLinesInsert(event));
+  }
+
+  private _handleBufferLinesDelete(event: IDeleteEvent): void {
+    this._scheduleLineIndexSync(() => this._applyBufferLinesDelete(event));
+  }
+
+  private _mergeLineBucket(newMap: Map<number, IInternalDecoration[]>, line: number, bucket: IInternalDecoration[]): void {
+    const existing = newMap.get(line);
+    if (existing) {
+      existing.push(...bucket);
+    } else {
+      newMap.set(line, bucket.slice());
+    }
+  }
+
+  /**
+   * Shift indexed line keys and sync start lines. O(unique indexed lines), not O(decoration count).
+   * Decorations that span the insert point are re-indexed individually (rare vs single-line hits).
+   */
+  private _applyBufferLinesInsert(event: IInsertEvent): void {
+    const { index, amount } = event;
+    const spanCrossers: IInternalDecoration[] = [];
+    for (const d of this._decorations) {
+      if (d.marker.isDisposed) {
+        continue;
+      }
+      const start = d._indexedStartLine;
+      if (start < index && start + this._getDecorationHeight(d) > index) {
+        spanCrossers.push(d);
+        this._removeFromLineBuckets(d);
+      }
+    }
+    const newMap = new Map<number, IInternalDecoration[]>();
+    for (const [line, bucket] of this._decorationsByLine) {
+      const newLine = line >= index ? line + amount : line;
+      this._mergeLineBucket(newMap, newLine, bucket);
+    }
+    this._decorationsByLine.clear();
+    for (const [line, bucket] of newMap) {
+      this._decorationsByLine.set(line, bucket);
+    }
+    for (const d of this._decorations) {
+      if (d.marker.isDisposed) {
+        continue;
+      }
+      if (d._indexedStartLine >= index) {
+        d._indexedStartLine = d.marker.line;
+      }
+    }
+    for (const d of spanCrossers) {
+      this._addToLineBuckets(d);
+    }
+  }
+
+  /**
+   * Drop deleted line keys, shift keys below, sync start lines. Full re-index only when a
+   * multi-line decoration spans across the deleted range but survives.
+   */
+  private _applyBufferLinesDelete(event: IDeleteEvent): void {
+    const deleteEnd = event.index + event.amount;
+    const newMap = new Map<number, IInternalDecoration[]>();
+    for (const [line, bucket] of this._decorationsByLine) {
+      if (line >= event.index && line < deleteEnd) {
+        continue;
+      }
+      const newLine = line >= deleteEnd ? line - event.amount : line;
+      this._mergeLineBucket(newMap, newLine, bucket);
+    }
+    this._decorationsByLine.clear();
+    for (const [line, bucket] of newMap) {
+      this._decorationsByLine.set(line, bucket);
+    }
+    const toReindex: IInternalDecoration[] = [];
+    for (const d of this._decorations) {
+      if (d.marker.isDisposed) {
+        continue;
+      }
+      const start = d._indexedStartLine;
+      const height = this._getDecorationHeight(d);
+      if (start >= deleteEnd) {
+        d._indexedStartLine = d.marker.line;
+      } else if (start < event.index && start + height > deleteEnd) {
+        toReindex.push(d);
+      }
+    }
+    for (const d of toReindex) {
+      this._reindexDecoration(d);
+    }
+  }
 }
 
 class Decoration extends DisposableStore implements IInternalDecoration {
   public readonly marker: IMarker;
   public element: HTMLElement | undefined;
 
+  /** Start line used for line-index removal when marker.line is cleared on dispose. */
+  public _indexedStartLine: number;
+
   public readonly onRenderEmitter = this.add(new Emitter<HTMLElement>());
   public readonly onRender = this.onRenderEmitter.event;
   private readonly _onDispose = this.add(new Emitter<void>());
@@ -128,6 +377,7 @@ class Decoration extends DisposableStore implements IInternalDecoration {
   ) {
     super();
     this.marker = options.marker;
+    this._indexedStartLine = options.marker.line;
     if (this.options.overviewRulerOptions && !this.options.overviewRulerOptions.position) {
       this.options.overviewRulerOptions.position = 'full';
     }

package/src/common/services/LogService.ts

@@ -3,7 +3,7 @@
  * @license MIT
  */
 
-import { Disposable } from 'vs/base/common/lifecycle';
+import { Disposable } from 'common/Lifecycle';
 import { ILogService, IOptionsService, LogLevelEnum } from 'common/services/Services';
 
 type LogType = (message?: any, ...optionalParams: any[]) => void;
@@ -43,9 +43,6 @@ export class LogService extends Disposable implements ILogService {
     super();
     this._updateLogLevel();
     this._register(this._optionsService.onSpecificOptionChange('logLevel', () => this._updateLogLevel()));
-
-    // For trace logging, assume the latest created log service is valid
-    traceLogger = this;
   }
 
   private _updateLogLevel(): void {
@@ -95,30 +92,3 @@ export class LogService extends Disposable implements ILogService {
     }
   }
 }
-
-let traceLogger: ILogService;
-export function setTraceLogger(logger: ILogService): void {
-  traceLogger = logger;
-}
-
-/**
- * A decorator that can be used to automatically log trace calls to the decorated function.
- */
-export function traceCall(_target: any, key: string, descriptor: any): any {
-  if (typeof descriptor.value !== 'function') {
-    throw new Error('not supported');
-  }
-  const fnKey = 'value';
-  const fn = descriptor.value;
-  descriptor[fnKey] = function (...args: any[]) {
-    // Early exit
-    if (traceLogger.logLevel !== LogLevelEnum.TRACE) {
-      return fn.apply(this, args);
-    }
-
-    traceLogger.trace(`GlyphRenderer#${fn.name}(${args.map(e => JSON.stringify(e)).join(', ')})`);
-    const result = fn.apply(this, args);
-    traceLogger.trace(`GlyphRenderer#${fn.name} return`, result);
-    return result;
-  };
-}