Method parse

src/common/InputHandler.ts:425–510

* Parse call with async handler support. * * Whether the stack state got preserved for the next call, is indicated by the return value: * - undefined (void): * all handlers were sync, no stack save, continue normally with next chunk * - Promise\ : * execution stopped a

(data: string | Uint8Array, promiseResult?: boolean)

   * and proper continuation of async parser handlers.
   */
  public parse(data: string | Uint8Array, promiseResult?: boolean): void | Promise<boolean> {
    let result: void | Promise<boolean>;
    let cursorStartX = this._activeBuffer.x;
    let cursorStartY = this._activeBuffer.y;
    let start = 0;
    const wasPaused = this._parseStack.paused;

    if (wasPaused) {
      // assumption: _parseBuffer never mutates between async calls
      if (result = this._parser.parse(this._parseBuffer, this._parseStack.decodedLength, promiseResult)) {
        this._logSlowResolvingAsync(result);
        return result;
      }
      cursorStartX = this._parseStack.cursorStartX;
      cursorStartY = this._parseStack.cursorStartY;
      this._parseStack.paused = false;
      if (data.length > MAX_PARSEBUFFER_LENGTH) {
        start = this._parseStack.position + MAX_PARSEBUFFER_LENGTH;
      }
    }

    // Log debug data, the log level gate is to prevent extra work in this hot path
    if (this._logService.logLevel <= LogLevelEnum.DEBUG) {
      this._logService.debug(`parsing data ${typeof data === 'string' ? ` "${data}"` : ` "${Array.prototype.map.call(data, e => String.fromCharCode(e)).join('')}"`}`);
    }
    if (this._logService.logLevel === LogLevelEnum.TRACE) {
      this._logService.trace(`parsing data (codes)`, typeof data === 'string'
        ? data.split('').map(e => e.charCodeAt(0))
        : data
      );
    }

    // resize input buffer if needed
    if (this._parseBuffer.length < data.length) {
      if (this._parseBuffer.length < MAX_PARSEBUFFER_LENGTH) {
        this._parseBuffer = new Uint32Array(Math.min(data.length, MAX_PARSEBUFFER_LENGTH));
      }
    }

    // Clear the dirty row service so we know which lines changed as a result of parsing
    // Important: do not clear between async calls, otherwise we lost pending update information.
    if (!wasPaused) {
      this._dirtyRowTracker.clearRange();
    }

    // process big data in smaller chunks
    if (data.length > MAX_PARSEBUFFER_LENGTH) {
      for (let i = start; i < data.length; i += MAX_PARSEBUFFER_LENGTH) {
        const end = i + MAX_PARSEBUFFER_LENGTH < data.length ? i + MAX_PARSEBUFFER_LENGTH : data.length;
        const len = (typeof data === 'string')
          ? this._stringDecoder.decode(data.substring(i, end), this._parseBuffer)
          : this._utf8Decoder.decode(data.subarray(i, end), this._parseBuffer);
        if (result = this._parser.parse(this._parseBuffer, len)) {
          this._preserveStack(cursorStartX, cursorStartY, len, i);
          this._logSlowResolvingAsync(result);
          return result;
        }
      }