text: /*---------------------------------------------------------------------------------------------
   *  Copyright (c) Microsoft Corporation. All rights reserved.
   *  Licensed under the MIT License. See License.txt in the project root for license information.
   *--------------------------------------------------------------------------------------------*/
  import { TokenMetadata } from '../modes.js';
  export class LineTokens {
      constructor(tokens, text) {
          this._tokens = tokens;
          this._tokensCount = (this._tokens.length >>> 1);
          this._text = text;
      }
      equals(other) {
          if (other instanceof LineTokens) {
              return this.slicedEquals(other, 0, this._tokensCount);
          }
          return false;
      }
      slicedEquals(other, sliceFromTokenIndex, sliceTokenCount) {
          if (this._text !== other._text) {
              return false;
          }
          if (this._tokensCount !== other._tokensCount) {
              return false;
          }
          const from = (sliceFromTokenIndex << 1);
          const to = from + (sliceTokenCount << 1);
          for (let i = from; i < to; i++) {
              if (this._tokens[i] !== other._tokens[i]) {
                  return false;
              }
          }
          return true;
      }
      getLineContent() {
          return this._text;
      }
      getCount() {
          return this._tokensCount;
      }
      getStartOffset(tokenIndex) {
          if (tokenIndex > 0) {
              return this._tokens[(tokenIndex - 1) << 1];
          }
          return 0;
      }
      getMetadata(tokenIndex) {
          const metadata = this._tokens[(tokenIndex << 1) + 1];
          return metadata;
      }
      getLanguageId(tokenIndex) {
          const metadata = this._tokens[(tokenIndex << 1) + 1];
          return TokenMetadata.getLanguageId(metadata);
      }
      getStandardTokenType(tokenIndex) {
          const metadata = this._tokens[(tokenIndex << 1) + 1];
          return TokenMetadata.getTokenType(metadata);
      }
      getForeground(tokenIndex) {
          const metadata = this._tokens[(tokenIndex << 1) + 1];
          return TokenMetadata.getForeground(metadata);
      }
      getClassName(tokenIndex) {
          const metadata = this._tokens[(tokenIndex << 1) + 1];
          return TokenMetadata.getClassNameFromMetadata(metadata);
      }
      getInlineStyle(tokenIndex, colorMap) {
          const metadata = this._tokens[(tokenIndex << 1) + 1];
          return TokenMetadata.getInlineStyleFromMetadata(metadata, colorMap);
      }
      getEndOffset(tokenIndex) {
          return this._tokens[tokenIndex << 1];
      }
      /**
       * Find the token containing offset `offset`.
       * @param offset The search offset
       * @return The index of the token containing the offset.
       */
      findTokenIndexAtOffset(offset) {
          return LineTokens.findIndexInTokensArray(this._tokens, offset);
      }
      inflate() {
          return this;
      }
      sliceAndInflate(startOffset, endOffset, deltaOffset) {
          return new SlicedLineTokens(this, startOffset, endOffset, deltaOffset);
      }
      static convertToEndOffset(tokens, lineTextLength) {
          const tokenCount = (tokens.length >>> 1);
          const lastTokenIndex = tokenCount - 1;
          for (let tokenIndex = 0; tokenIndex < lastTokenIndex; tokenIndex++) {
              tokens[tokenIndex << 1] = tokens[(tokenIndex + 1) << 1];
          }
          tokens[lastTokenIndex << 1] = lineTextLength;
      }
      static findIndexInTokensArray(tokens, desiredIndex) {
          if (tokens.length <= 2) {
              return 0;
          }
          let low = 0;
          let high = (tokens.length >>> 1) - 1;
          while (low < high) {
              const mid = low + Math.floor((high - low) / 2);
              const endOffset = tokens[(mid << 1)];
              if (endOffset === desiredIndex) {
                  return mid + 1;
              }
              else if (endOffset < desiredIndex) {
                  low = mid + 1;
              }
              else if (endOffset > desiredIndex) {
                  high = mid;
              }
          }
          return low;
      }
  }
  export class SlicedLineTokens {
      constructor(source, startOffset, endOffset, deltaOffset) {
          this._source = source;
          this._startOffset = startOffset;
          this._endOffset = endOffset;
          this._deltaOffset = deltaOffset;
          this._firstTokenIndex = source.findTokenIndexAtOffset(startOffset);
          this._tokensCount = 0;
          for (let i = this._firstTokenIndex, len = source.getCount(); i < len; i++) {
              const tokenStartOffset = source.getStartOffset(i);
              if (tokenStartOffset >= endOffset) {
                  break;
              }
              this._tokensCount++;
          }
      }
      equals(other) {
          if (other instanceof SlicedLineTokens) {
              return (this._startOffset === other._startOffset
                  && this._endOffset === other._endOffset
                  && this._deltaOffset === other._deltaOffset
                  && this._source.slicedEquals(other._source, this._firstTokenIndex, this._tokensCount));
          }
          return false;
      }
      getCount() {
          return this._tokensCount;
      }
      getForeground(tokenIndex) {
          return this._source.getForeground(this._firstTokenIndex + tokenIndex);
      }
      getEndOffset(tokenIndex) {
          const tokenEndOffset = this._source.getEndOffset(this._firstTokenIndex + tokenIndex);
          return Math.min(this._endOffset, tokenEndOffset) - this._startOffset + this._deltaOffset;
      }
      getClassName(tokenIndex) {
          return this._source.getClassName(this._firstTokenIndex + tokenIndex);
      }
      getInlineStyle(tokenIndex, colorMap) {
          return this._source.getInlineStyle(this._firstTokenIndex + tokenIndex, colorMap);
      }
      findTokenIndexAtOffset(offset) {
          return this._source.findTokenIndexAtOffset(offset + this._startOffset - this._deltaOffset) - this._firstTokenIndex;
      }
  }
  