@easyv/biz-components 0.0.52-beta.0 → 0.0.52-beta.1

package/dist/node_modules/.pnpm/monaco-editor@0.52.2/node_modules/monaco-editor/esm/vs/editor/contrib/folding/browser/foldingRanges.es.js

@@ -0,0 +1,347 @@
+const foldSourceAbbr = {
+  [
+    0
+    /* FoldSource.provider */
+  ]: " ",
+  [
+    1
+    /* FoldSource.userDefined */
+  ]: "u",
+  [
+    2
+    /* FoldSource.recovered */
+  ]: "r"
+};
+const MAX_FOLDING_REGIONS = 65535;
+const MAX_LINE_NUMBER = 16777215;
+const MASK_INDENT = 4278190080;
+class BitField {
+  constructor(size) {
+    const numWords = Math.ceil(size / 32);
+    this._states = new Uint32Array(numWords);
+  }
+  get(index) {
+    const arrayIndex = index / 32 | 0;
+    const bit = index % 32;
+    return (this._states[arrayIndex] & 1 << bit) !== 0;
+  }
+  set(index, newState) {
+    const arrayIndex = index / 32 | 0;
+    const bit = index % 32;
+    const value = this._states[arrayIndex];
+    if (newState) {
+      this._states[arrayIndex] = value | 1 << bit;
+    } else {
+      this._states[arrayIndex] = value & ~(1 << bit);
+    }
+  }
+}
+class FoldingRegions {
+  constructor(startIndexes, endIndexes, types) {
+    if (startIndexes.length !== endIndexes.length || startIndexes.length > MAX_FOLDING_REGIONS) {
+      throw new Error("invalid startIndexes or endIndexes size");
+    }
+    this._startIndexes = startIndexes;
+    this._endIndexes = endIndexes;
+    this._collapseStates = new BitField(startIndexes.length);
+    this._userDefinedStates = new BitField(startIndexes.length);
+    this._recoveredStates = new BitField(startIndexes.length);
+    this._types = types;
+    this._parentsComputed = false;
+  }
+  ensureParentIndices() {
+    if (!this._parentsComputed) {
+      this._parentsComputed = true;
+      const parentIndexes = [];
+      const isInsideLast = (startLineNumber, endLineNumber) => {
+        const index = parentIndexes[parentIndexes.length - 1];
+        return this.getStartLineNumber(index) <= startLineNumber && this.getEndLineNumber(index) >= endLineNumber;
+      };
+      for (let i = 0, len = this._startIndexes.length; i < len; i++) {
+        const startLineNumber = this._startIndexes[i];
+        const endLineNumber = this._endIndexes[i];
+        if (startLineNumber > MAX_LINE_NUMBER || endLineNumber > MAX_LINE_NUMBER) {
+          throw new Error("startLineNumber or endLineNumber must not exceed " + MAX_LINE_NUMBER);
+        }
+        while (parentIndexes.length > 0 && !isInsideLast(startLineNumber, endLineNumber)) {
+          parentIndexes.pop();
+        }
+        const parentIndex = parentIndexes.length > 0 ? parentIndexes[parentIndexes.length - 1] : -1;
+        parentIndexes.push(i);
+        this._startIndexes[i] = startLineNumber + ((parentIndex & 255) << 24);
+        this._endIndexes[i] = endLineNumber + ((parentIndex & 65280) << 16);
+      }
+    }
+  }
+  get length() {
+    return this._startIndexes.length;
+  }
+  getStartLineNumber(index) {
+    return this._startIndexes[index] & MAX_LINE_NUMBER;
+  }
+  getEndLineNumber(index) {
+    return this._endIndexes[index] & MAX_LINE_NUMBER;
+  }
+  getType(index) {
+    return this._types ? this._types[index] : void 0;
+  }
+  hasTypes() {
+    return !!this._types;
+  }
+  isCollapsed(index) {
+    return this._collapseStates.get(index);
+  }
+  setCollapsed(index, newState) {
+    this._collapseStates.set(index, newState);
+  }
+  isUserDefined(index) {
+    return this._userDefinedStates.get(index);
+  }
+  setUserDefined(index, newState) {
+    return this._userDefinedStates.set(index, newState);
+  }
+  isRecovered(index) {
+    return this._recoveredStates.get(index);
+  }
+  setRecovered(index, newState) {
+    return this._recoveredStates.set(index, newState);
+  }
+  getSource(index) {
+    if (this.isUserDefined(index)) {
+      return 1;
+    } else if (this.isRecovered(index)) {
+      return 2;
+    }
+    return 0;
+  }
+  setSource(index, source) {
+    if (source === 1) {
+      this.setUserDefined(index, true);
+      this.setRecovered(index, false);
+    } else if (source === 2) {
+      this.setUserDefined(index, false);
+      this.setRecovered(index, true);
+    } else {
+      this.setUserDefined(index, false);
+      this.setRecovered(index, false);
+    }
+  }
+  setCollapsedAllOfType(type, newState) {
+    let hasChanged = false;
+    if (this._types) {
+      for (let i = 0; i < this._types.length; i++) {
+        if (this._types[i] === type) {
+          this.setCollapsed(i, newState);
+          hasChanged = true;
+        }
+      }
+    }
+    return hasChanged;
+  }
+  toRegion(index) {
+    return new FoldingRegion(this, index);
+  }
+  getParentIndex(index) {
+    this.ensureParentIndices();
+    const parent = ((this._startIndexes[index] & MASK_INDENT) >>> 24) + ((this._endIndexes[index] & MASK_INDENT) >>> 16);
+    if (parent === MAX_FOLDING_REGIONS) {
+      return -1;
+    }
+    return parent;
+  }
+  contains(index, line) {
+    return this.getStartLineNumber(index) <= line && this.getEndLineNumber(index) >= line;
+  }
+  findIndex(line) {
+    let low = 0, high = this._startIndexes.length;
+    if (high === 0) {
+      return -1;
+    }
+    while (low < high) {
+      const mid = Math.floor((low + high) / 2);
+      if (line < this.getStartLineNumber(mid)) {
+        high = mid;
+      } else {
+        low = mid + 1;
+      }
+    }
+    return low - 1;
+  }
+  findRange(line) {
+    let index = this.findIndex(line);
+    if (index >= 0) {
+      const endLineNumber = this.getEndLineNumber(index);
+      if (endLineNumber >= line) {
+        return index;
+      }
+      index = this.getParentIndex(index);
+      while (index !== -1) {
+        if (this.contains(index, line)) {
+          return index;
+        }
+        index = this.getParentIndex(index);
+      }
+    }
+    return -1;
+  }
+  toString() {
+    const res = [];
+    for (let i = 0; i < this.length; i++) {
+      res[i] = `[${foldSourceAbbr[this.getSource(i)]}${this.isCollapsed(i) ? "+" : "-"}] ${this.getStartLineNumber(i)}/${this.getEndLineNumber(i)}`;
+    }
+    return res.join(", ");
+  }
+  toFoldRange(index) {
+    return {
+      startLineNumber: this._startIndexes[index] & MAX_LINE_NUMBER,
+      endLineNumber: this._endIndexes[index] & MAX_LINE_NUMBER,
+      type: this._types ? this._types[index] : void 0,
+      isCollapsed: this.isCollapsed(index),
+      source: this.getSource(index)
+    };
+  }
+  static fromFoldRanges(ranges) {
+    const rangesLength = ranges.length;
+    const startIndexes = new Uint32Array(rangesLength);
+    const endIndexes = new Uint32Array(rangesLength);
+    let types = [];
+    let gotTypes = false;
+    for (let i = 0; i < rangesLength; i++) {
+      const range = ranges[i];
+      startIndexes[i] = range.startLineNumber;
+      endIndexes[i] = range.endLineNumber;
+      types.push(range.type);
+      if (range.type) {
+        gotTypes = true;
+      }
+    }
+    if (!gotTypes) {
+      types = void 0;
+    }
+    const regions = new FoldingRegions(startIndexes, endIndexes, types);
+    for (let i = 0; i < rangesLength; i++) {
+      if (ranges[i].isCollapsed) {
+        regions.setCollapsed(i, true);
+      }
+      regions.setSource(i, ranges[i].source);
+    }
+    return regions;
+  }
+  /**
+   * Two inputs, each a FoldingRegions or a FoldRange[], are merged.
+   * Each input must be pre-sorted on startLineNumber.
+   * The first list is assumed to always include all regions currently defined by range providers.
+   * The second list only contains the previously collapsed and all manual ranges.
+   * If the line position matches, the range of the new range is taken, and the range is no longer manual
+   * When an entry in one list overlaps an entry in the other, the second list's entry "wins" and
+   * overlapping entries in the first list are discarded.
+   * Invalid entries are discarded. An entry is invalid if:
+   * 		the start and end line numbers aren't a valid range of line numbers,
+   * 		it is out of sequence or has the same start line as a preceding entry,
+   * 		it overlaps a preceding entry and is not fully contained by that entry.
+   */
+  static sanitizeAndMerge(rangesA, rangesB, maxLineNumber, selection) {
+    maxLineNumber = maxLineNumber ?? Number.MAX_VALUE;
+    const getIndexedFunction = (r, limit) => {
+      return Array.isArray(r) ? (i) => {
+        return i < limit ? r[i] : void 0;
+      } : (i) => {
+        return i < limit ? r.toFoldRange(i) : void 0;
+      };
+    };
+    const getA = getIndexedFunction(rangesA, rangesA.length);
+    const getB = getIndexedFunction(rangesB, rangesB.length);
+    let indexA = 0;
+    let indexB = 0;
+    let nextA = getA(0);
+    let nextB = getB(0);
+    const stackedRanges = [];
+    let topStackedRange;
+    let prevLineNumber = 0;
+    const resultRanges = [];
+    while (nextA || nextB) {
+      let useRange = void 0;
+      if (nextB && (!nextA || nextA.startLineNumber >= nextB.startLineNumber)) {
+        if (nextA && nextA.startLineNumber === nextB.startLineNumber) {
+          if (nextB.source === 1) {
+            useRange = nextB;
+          } else {
+            useRange = nextA;
+            useRange.isCollapsed = nextB.isCollapsed && (nextA.endLineNumber === nextB.endLineNumber || !(selection == null ? void 0 : selection.startsInside(nextA.startLineNumber + 1, nextA.endLineNumber + 1)));
+            useRange.source = 0;
+          }
+          nextA = getA(++indexA);
+        } else {
+          useRange = nextB;
+          if (nextB.isCollapsed && nextB.source === 0) {
+            useRange.source = 2;
+          }
+        }
+        nextB = getB(++indexB);
+      } else {
+        let scanIndex = indexB;
+        let prescanB = nextB;
+        while (true) {
+          if (!prescanB || prescanB.startLineNumber > nextA.endLineNumber) {
+            useRange = nextA;
+            break;
+          }
+          if (prescanB.source === 1 && prescanB.endLineNumber > nextA.endLineNumber) {
+            break;
+          }
+          prescanB = getB(++scanIndex);
+        }
+        nextA = getA(++indexA);
+      }
+      if (useRange) {
+        while (topStackedRange && topStackedRange.endLineNumber < useRange.startLineNumber) {
+          topStackedRange = stackedRanges.pop();
+        }
+        if (useRange.endLineNumber > useRange.startLineNumber && useRange.startLineNumber > prevLineNumber && useRange.endLineNumber <= maxLineNumber && (!topStackedRange || topStackedRange.endLineNumber >= useRange.endLineNumber)) {
+          resultRanges.push(useRange);
+          prevLineNumber = useRange.startLineNumber;
+          if (topStackedRange) {
+            stackedRanges.push(topStackedRange);
+          }
+          topStackedRange = useRange;
+        }
+      }
+    }
+    return resultRanges;
+  }
+}
+class FoldingRegion {
+  constructor(ranges, index) {
+    this.ranges = ranges;
+    this.index = index;
+  }
+  get startLineNumber() {
+    return this.ranges.getStartLineNumber(this.index);
+  }
+  get endLineNumber() {
+    return this.ranges.getEndLineNumber(this.index);
+  }
+  get regionIndex() {
+    return this.index;
+  }
+  get parentIndex() {
+    return this.ranges.getParentIndex(this.index);
+  }
+  get isCollapsed() {
+    return this.ranges.isCollapsed(this.index);
+  }
+  containedBy(range) {
+    return range.startLineNumber <= this.startLineNumber && range.endLineNumber >= this.endLineNumber;
+  }
+  containsLine(lineNumber) {
+    return this.startLineNumber <= lineNumber && lineNumber <= this.endLineNumber;
+  }
+}
+export {
+  FoldingRegion,
+  FoldingRegions,
+  MAX_FOLDING_REGIONS,
+  MAX_LINE_NUMBER,
+  foldSourceAbbr
+};
+//# sourceMappingURL=foldingRanges.es.js.map

package/dist/node_modules/.pnpm/monaco-editor@0.52.2/node_modules/monaco-editor/esm/vs/editor/contrib/folding/browser/foldingRanges.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"foldingRanges.es.js","sources":["../../../../../../../../../../../../../../node_modules/.pnpm/monaco-editor@0.52.2/node_modules/monaco-editor/esm/vs/editor/contrib/folding/browser/foldingRanges.js"],"sourcesContent":["/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport const foldSourceAbbr = {\n    [0 /* FoldSource.provider */]: ' ',\n    [1 /* FoldSource.userDefined */]: 'u',\n    [2 /* FoldSource.recovered */]: 'r',\n};\nexport const MAX_FOLDING_REGIONS = 0xFFFF;\nexport const MAX_LINE_NUMBER = 0xFFFFFF;\nconst MASK_INDENT = 0xFF000000;\nclass BitField {\n    constructor(size) {\n        const numWords = Math.ceil(size / 32);\n        this._states = new Uint32Array(numWords);\n    }\n    get(index) {\n        const arrayIndex = (index / 32) | 0;\n        const bit = index % 32;\n        return (this._states[arrayIndex] & (1 << bit)) !== 0;\n    }\n    set(index, newState) {\n        const arrayIndex = (index / 32) | 0;\n        const bit = index % 32;\n        const value = this._states[arrayIndex];\n        if (newState) {\n            this._states[arrayIndex] = value | (1 << bit);\n        }\n        else {\n            this._states[arrayIndex] = value & ~(1 << bit);\n        }\n    }\n}\nexport class FoldingRegions {\n    constructor(startIndexes, endIndexes, types) {\n        if (startIndexes.length !== endIndexes.length || startIndexes.length > MAX_FOLDING_REGIONS) {\n            throw new Error('invalid startIndexes or endIndexes size');\n        }\n        this._startIndexes = startIndexes;\n        this._endIndexes = endIndexes;\n        this._collapseStates = new BitField(startIndexes.length);\n        this._userDefinedStates = new BitField(startIndexes.length);\n        this._recoveredStates = new BitField(startIndexes.length);\n        this._types = types;\n        this._parentsComputed = false;\n    }\n    ensureParentIndices() {\n        if (!this._parentsComputed) {\n            this._parentsComputed = true;\n            const parentIndexes = [];\n            const isInsideLast = (startLineNumber, endLineNumber) => {\n                const index = parentIndexes[parentIndexes.length - 1];\n                return this.getStartLineNumber(index) <= startLineNumber && this.getEndLineNumber(index) >= endLineNumber;\n            };\n            for (let i = 0, len = this._startIndexes.length; i < len; i++) {\n                const startLineNumber = this._startIndexes[i];\n                const endLineNumber = this._endIndexes[i];\n                if (startLineNumber > MAX_LINE_NUMBER || endLineNumber > MAX_LINE_NUMBER) {\n                    throw new Error('startLineNumber or endLineNumber must not exceed ' + MAX_LINE_NUMBER);\n                }\n                while (parentIndexes.length > 0 && !isInsideLast(startLineNumber, endLineNumber)) {\n                    parentIndexes.pop();\n                }\n                const parentIndex = parentIndexes.length > 0 ? parentIndexes[parentIndexes.length - 1] : -1;\n                parentIndexes.push(i);\n                this._startIndexes[i] = startLineNumber + ((parentIndex & 0xFF) << 24);\n                this._endIndexes[i] = endLineNumber + ((parentIndex & 0xFF00) << 16);\n            }\n        }\n    }\n    get length() {\n        return this._startIndexes.length;\n    }\n    getStartLineNumber(index) {\n        return this._startIndexes[index] & MAX_LINE_NUMBER;\n    }\n    getEndLineNumber(index) {\n        return this._endIndexes[index] & MAX_LINE_NUMBER;\n    }\n    getType(index) {\n        return this._types ? this._types[index] : undefined;\n    }\n    hasTypes() {\n        return !!this._types;\n    }\n    isCollapsed(index) {\n        return this._collapseStates.get(index);\n    }\n    setCollapsed(index, newState) {\n        this._collapseStates.set(index, newState);\n    }\n    isUserDefined(index) {\n        return this._userDefinedStates.get(index);\n    }\n    setUserDefined(index, newState) {\n        return this._userDefinedStates.set(index, newState);\n    }\n    isRecovered(index) {\n        return this._recoveredStates.get(index);\n    }\n    setRecovered(index, newState) {\n        return this._recoveredStates.set(index, newState);\n    }\n    getSource(index) {\n        if (this.isUserDefined(index)) {\n            return 1 /* FoldSource.userDefined */;\n        }\n        else if (this.isRecovered(index)) {\n            return 2 /* FoldSource.recovered */;\n        }\n        return 0 /* FoldSource.provider */;\n    }\n    setSource(index, source) {\n        if (source === 1 /* FoldSource.userDefined */) {\n            this.setUserDefined(index, true);\n            this.setRecovered(index, false);\n        }\n        else if (source === 2 /* FoldSource.recovered */) {\n            this.setUserDefined(index, false);\n            this.setRecovered(index, true);\n        }\n        else {\n            this.setUserDefined(index, false);\n            this.setRecovered(index, false);\n        }\n    }\n    setCollapsedAllOfType(type, newState) {\n        let hasChanged = false;\n        if (this._types) {\n            for (let i = 0; i < this._types.length; i++) {\n                if (this._types[i] === type) {\n                    this.setCollapsed(i, newState);\n                    hasChanged = true;\n                }\n            }\n        }\n        return hasChanged;\n    }\n    toRegion(index) {\n        return new FoldingRegion(this, index);\n    }\n    getParentIndex(index) {\n        this.ensureParentIndices();\n        const parent = ((this._startIndexes[index] & MASK_INDENT) >>> 24) + ((this._endIndexes[index] & MASK_INDENT) >>> 16);\n        if (parent === MAX_FOLDING_REGIONS) {\n            return -1;\n        }\n        return parent;\n    }\n    contains(index, line) {\n        return this.getStartLineNumber(index) <= line && this.getEndLineNumber(index) >= line;\n    }\n    findIndex(line) {\n        let low = 0, high = this._startIndexes.length;\n        if (high === 0) {\n            return -1; // no children\n        }\n        while (low < high) {\n            const mid = Math.floor((low + high) / 2);\n            if (line < this.getStartLineNumber(mid)) {\n                high = mid;\n            }\n            else {\n                low = mid + 1;\n            }\n        }\n        return low - 1;\n    }\n    findRange(line) {\n        let index = this.findIndex(line);\n        if (index >= 0) {\n            const endLineNumber = this.getEndLineNumber(index);\n            if (endLineNumber >= line) {\n                return index;\n            }\n            index = this.getParentIndex(index);\n            while (index !== -1) {\n                if (this.contains(index, line)) {\n                    return index;\n                }\n                index = this.getParentIndex(index);\n            }\n        }\n        return -1;\n    }\n    toString() {\n        const res = [];\n        for (let i = 0; i < this.length; i++) {\n            res[i] = `[${foldSourceAbbr[this.getSource(i)]}${this.isCollapsed(i) ? '+' : '-'}] ${this.getStartLineNumber(i)}/${this.getEndLineNumber(i)}`;\n        }\n        return res.join(', ');\n    }\n    toFoldRange(index) {\n        return {\n            startLineNumber: this._startIndexes[index] & MAX_LINE_NUMBER,\n            endLineNumber: this._endIndexes[index] & MAX_LINE_NUMBER,\n            type: this._types ? this._types[index] : undefined,\n            isCollapsed: this.isCollapsed(index),\n            source: this.getSource(index)\n        };\n    }\n    static fromFoldRanges(ranges) {\n        const rangesLength = ranges.length;\n        const startIndexes = new Uint32Array(rangesLength);\n        const endIndexes = new Uint32Array(rangesLength);\n        let types = [];\n        let gotTypes = false;\n        for (let i = 0; i < rangesLength; i++) {\n            const range = ranges[i];\n            startIndexes[i] = range.startLineNumber;\n            endIndexes[i] = range.endLineNumber;\n            types.push(range.type);\n            if (range.type) {\n                gotTypes = true;\n            }\n        }\n        if (!gotTypes) {\n            types = undefined;\n        }\n        const regions = new FoldingRegions(startIndexes, endIndexes, types);\n        for (let i = 0; i < rangesLength; i++) {\n            if (ranges[i].isCollapsed) {\n                regions.setCollapsed(i, true);\n            }\n            regions.setSource(i, ranges[i].source);\n        }\n        return regions;\n    }\n    /**\n     * Two inputs, each a FoldingRegions or a FoldRange[], are merged.\n     * Each input must be pre-sorted on startLineNumber.\n     * The first list is assumed to always include all regions currently defined by range providers.\n     * The second list only contains the previously collapsed and all manual ranges.\n     * If the line position matches, the range of the new range is taken, and the range is no longer manual\n     * When an entry in one list overlaps an entry in the other, the second list's entry \"wins\" and\n     * overlapping entries in the first list are discarded.\n     * Invalid entries are discarded. An entry is invalid if:\n     * \t\tthe start and end line numbers aren't a valid range of line numbers,\n     * \t\tit is out of sequence or has the same start line as a preceding entry,\n     * \t\tit overlaps a preceding entry and is not fully contained by that entry.\n     */\n    static sanitizeAndMerge(rangesA, rangesB, maxLineNumber, selection) {\n        maxLineNumber = maxLineNumber ?? Number.MAX_VALUE;\n        const getIndexedFunction = (r, limit) => {\n            return Array.isArray(r)\n                ? ((i) => { return (i < limit) ? r[i] : undefined; })\n                : ((i) => { return (i < limit) ? r.toFoldRange(i) : undefined; });\n        };\n        const getA = getIndexedFunction(rangesA, rangesA.length);\n        const getB = getIndexedFunction(rangesB, rangesB.length);\n        let indexA = 0;\n        let indexB = 0;\n        let nextA = getA(0);\n        let nextB = getB(0);\n        const stackedRanges = [];\n        let topStackedRange;\n        let prevLineNumber = 0;\n        const resultRanges = [];\n        while (nextA || nextB) {\n            let useRange = undefined;\n            if (nextB && (!nextA || nextA.startLineNumber >= nextB.startLineNumber)) {\n                if (nextA && nextA.startLineNumber === nextB.startLineNumber) {\n                    if (nextB.source === 1 /* FoldSource.userDefined */) {\n                        // a user defined range (possibly unfolded)\n                        useRange = nextB;\n                    }\n                    else {\n                        // a previously folded range or a (possibly unfolded) recovered range\n                        useRange = nextA;\n                        // stays collapsed if the range still has the same number of lines or the selection is not in the range or after it\n                        useRange.isCollapsed = nextB.isCollapsed && (nextA.endLineNumber === nextB.endLineNumber || !selection?.startsInside(nextA.startLineNumber + 1, nextA.endLineNumber + 1));\n                        useRange.source = 0 /* FoldSource.provider */;\n                    }\n                    nextA = getA(++indexA); // not necessary, just for speed\n                }\n                else {\n                    useRange = nextB;\n                    if (nextB.isCollapsed && nextB.source === 0 /* FoldSource.provider */) {\n                        // a previously collapsed range\n                        useRange.source = 2 /* FoldSource.recovered */;\n                    }\n                }\n                nextB = getB(++indexB);\n            }\n            else {\n                // nextA is next. The user folded B set takes precedence and we sometimes need to look\n                // ahead in it to check for an upcoming conflict.\n                let scanIndex = indexB;\n                let prescanB = nextB;\n                while (true) {\n                    if (!prescanB || prescanB.startLineNumber > nextA.endLineNumber) {\n                        useRange = nextA;\n                        break; // no conflict, use this nextA\n                    }\n                    if (prescanB.source === 1 /* FoldSource.userDefined */ && prescanB.endLineNumber > nextA.endLineNumber) {\n                        // we found a user folded range, it wins\n                        break; // without setting nextResult, so this nextA gets skipped\n                    }\n                    prescanB = getB(++scanIndex);\n                }\n                nextA = getA(++indexA);\n            }\n            if (useRange) {\n                while (topStackedRange\n                    && topStackedRange.endLineNumber < useRange.startLineNumber) {\n                    topStackedRange = stackedRanges.pop();\n                }\n                if (useRange.endLineNumber > useRange.startLineNumber\n                    && useRange.startLineNumber > prevLineNumber\n                    && useRange.endLineNumber <= maxLineNumber\n                    && (!topStackedRange\n                        || topStackedRange.endLineNumber >= useRange.endLineNumber)) {\n                    resultRanges.push(useRange);\n                    prevLineNumber = useRange.startLineNumber;\n                    if (topStackedRange) {\n                        stackedRanges.push(topStackedRange);\n                    }\n                    topStackedRange = useRange;\n                }\n            }\n        }\n        return resultRanges;\n    }\n}\nexport class FoldingRegion {\n    constructor(ranges, index) {\n        this.ranges = ranges;\n        this.index = index;\n    }\n    get startLineNumber() {\n        return this.ranges.getStartLineNumber(this.index);\n    }\n    get endLineNumber() {\n        return this.ranges.getEndLineNumber(this.index);\n    }\n    get regionIndex() {\n        return this.index;\n    }\n    get parentIndex() {\n        return this.ranges.getParentIndex(this.index);\n    }\n    get isCollapsed() {\n        return this.ranges.isCollapsed(this.index);\n    }\n    containedBy(range) {\n        return range.startLineNumber <= this.startLineNumber && range.endLineNumber >= this.endLineNumber;\n    }\n    containsLine(lineNumber) {\n        return this.startLineNumber <= lineNumber && lineNumber <= this.endLineNumber;\n    }\n}\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/monaco-editor@0.52.2/node_modules/monaco-editor/esm/vs/editor/contrib/folding/browser/hiddenRangeModel.es.js

@@ -0,0 +1,124 @@
+import { findFirstIdxMonotonousOrArrLen } from "../../../../base/common/arraysFind.es.js";
+import { Emitter } from "../../../../base/common/event.es.js";
+import { Range } from "../../../common/core/range.es.js";
+import { countEOL } from "../../../common/core/eolCounter.es.js";
+class HiddenRangeModel {
+  get onDidChange() {
+    return this._updateEventEmitter.event;
+  }
+  get hiddenRanges() {
+    return this._hiddenRanges;
+  }
+  constructor(model) {
+    this._updateEventEmitter = new Emitter();
+    this._hasLineChanges = false;
+    this._foldingModel = model;
+    this._foldingModelListener = model.onDidChange((_) => this.updateHiddenRanges());
+    this._hiddenRanges = [];
+    if (model.regions.length) {
+      this.updateHiddenRanges();
+    }
+  }
+  notifyChangeModelContent(e) {
+    if (this._hiddenRanges.length && !this._hasLineChanges) {
+      this._hasLineChanges = e.changes.some((change) => {
+        return change.range.endLineNumber !== change.range.startLineNumber || countEOL(change.text)[0] !== 0;
+      });
+    }
+  }
+  updateHiddenRanges() {
+    let updateHiddenAreas = false;
+    const newHiddenAreas = [];
+    let i = 0;
+    let k = 0;
+    let lastCollapsedStart = Number.MAX_VALUE;
+    let lastCollapsedEnd = -1;
+    const ranges = this._foldingModel.regions;
+    for (; i < ranges.length; i++) {
+      if (!ranges.isCollapsed(i)) {
+        continue;
+      }
+      const startLineNumber = ranges.getStartLineNumber(i) + 1;
+      const endLineNumber = ranges.getEndLineNumber(i);
+      if (lastCollapsedStart <= startLineNumber && endLineNumber <= lastCollapsedEnd) {
+        continue;
+      }
+      if (!updateHiddenAreas && k < this._hiddenRanges.length && this._hiddenRanges[k].startLineNumber === startLineNumber && this._hiddenRanges[k].endLineNumber === endLineNumber) {
+        newHiddenAreas.push(this._hiddenRanges[k]);
+        k++;
+      } else {
+        updateHiddenAreas = true;
+        newHiddenAreas.push(new Range(startLineNumber, 1, endLineNumber, 1));
+      }
+      lastCollapsedStart = startLineNumber;
+      lastCollapsedEnd = endLineNumber;
+    }
+    if (this._hasLineChanges || updateHiddenAreas || k < this._hiddenRanges.length) {
+      this.applyHiddenRanges(newHiddenAreas);
+    }
+  }
+  applyHiddenRanges(newHiddenAreas) {
+    this._hiddenRanges = newHiddenAreas;
+    this._hasLineChanges = false;
+    this._updateEventEmitter.fire(newHiddenAreas);
+  }
+  hasRanges() {
+    return this._hiddenRanges.length > 0;
+  }
+  isHidden(line) {
+    return findRange(this._hiddenRanges, line) !== null;
+  }
+  adjustSelections(selections) {
+    let hasChanges = false;
+    const editorModel = this._foldingModel.textModel;
+    let lastRange = null;
+    const adjustLine = (line) => {
+      if (!lastRange || !isInside(line, lastRange)) {
+        lastRange = findRange(this._hiddenRanges, line);
+      }
+      if (lastRange) {
+        return lastRange.startLineNumber - 1;
+      }
+      return null;
+    };
+    for (let i = 0, len = selections.length; i < len; i++) {
+      let selection = selections[i];
+      const adjustedStartLine = adjustLine(selection.startLineNumber);
+      if (adjustedStartLine) {
+        selection = selection.setStartPosition(adjustedStartLine, editorModel.getLineMaxColumn(adjustedStartLine));
+        hasChanges = true;
+      }
+      const adjustedEndLine = adjustLine(selection.endLineNumber);
+      if (adjustedEndLine) {
+        selection = selection.setEndPosition(adjustedEndLine, editorModel.getLineMaxColumn(adjustedEndLine));
+        hasChanges = true;
+      }
+      selections[i] = selection;
+    }
+    return hasChanges;
+  }
+  dispose() {
+    if (this.hiddenRanges.length > 0) {
+      this._hiddenRanges = [];
+      this._updateEventEmitter.fire(this._hiddenRanges);
+    }
+    if (this._foldingModelListener) {
+      this._foldingModelListener.dispose();
+      this._foldingModelListener = null;
+    }
+  }
+}
+function isInside(line, range) {
+  return line >= range.startLineNumber && line <= range.endLineNumber;
+}
+function findRange(ranges, line) {
+  const i = findFirstIdxMonotonousOrArrLen(ranges, (r) => line < r.startLineNumber) - 1;
+  if (i >= 0 && ranges[i].endLineNumber >= line) {
+    return ranges[i];
+  }
+  return null;
+}
+export {
+  HiddenRangeModel
+};
+//# sourceMappingURL=hiddenRangeModel.es.js.map

package/dist/node_modules/.pnpm/monaco-editor@0.52.2/node_modules/monaco-editor/esm/vs/editor/contrib/folding/browser/hiddenRangeModel.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hiddenRangeModel.es.js","sources":["../../../../../../../../../../../../../../node_modules/.pnpm/monaco-editor@0.52.2/node_modules/monaco-editor/esm/vs/editor/contrib/folding/browser/hiddenRangeModel.js"],"sourcesContent":["/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { findFirstIdxMonotonousOrArrLen } from '../../../../base/common/arraysFind.js';\nimport { Emitter } from '../../../../base/common/event.js';\nimport { Range } from '../../../common/core/range.js';\nimport { countEOL } from '../../../common/core/eolCounter.js';\nexport class HiddenRangeModel {\n    get onDidChange() { return this._updateEventEmitter.event; }\n    get hiddenRanges() { return this._hiddenRanges; }\n    constructor(model) {\n        this._updateEventEmitter = new Emitter();\n        this._hasLineChanges = false;\n        this._foldingModel = model;\n        this._foldingModelListener = model.onDidChange(_ => this.updateHiddenRanges());\n        this._hiddenRanges = [];\n        if (model.regions.length) {\n            this.updateHiddenRanges();\n        }\n    }\n    notifyChangeModelContent(e) {\n        if (this._hiddenRanges.length && !this._hasLineChanges) {\n            this._hasLineChanges = e.changes.some(change => {\n                return change.range.endLineNumber !== change.range.startLineNumber || countEOL(change.text)[0] !== 0;\n            });\n        }\n    }\n    updateHiddenRanges() {\n        let updateHiddenAreas = false;\n        const newHiddenAreas = [];\n        let i = 0; // index into hidden\n        let k = 0;\n        let lastCollapsedStart = Number.MAX_VALUE;\n        let lastCollapsedEnd = -1;\n        const ranges = this._foldingModel.regions;\n        for (; i < ranges.length; i++) {\n            if (!ranges.isCollapsed(i)) {\n                continue;\n            }\n            const startLineNumber = ranges.getStartLineNumber(i) + 1; // the first line is not hidden\n            const endLineNumber = ranges.getEndLineNumber(i);\n            if (lastCollapsedStart <= startLineNumber && endLineNumber <= lastCollapsedEnd) {\n                // ignore ranges contained in collapsed regions\n                continue;\n            }\n            if (!updateHiddenAreas && k < this._hiddenRanges.length && this._hiddenRanges[k].startLineNumber === startLineNumber && this._hiddenRanges[k].endLineNumber === endLineNumber) {\n                // reuse the old ranges\n                newHiddenAreas.push(this._hiddenRanges[k]);\n                k++;\n            }\n            else {\n                updateHiddenAreas = true;\n                newHiddenAreas.push(new Range(startLineNumber, 1, endLineNumber, 1));\n            }\n            lastCollapsedStart = startLineNumber;\n            lastCollapsedEnd = endLineNumber;\n        }\n        if (this._hasLineChanges || updateHiddenAreas || k < this._hiddenRanges.length) {\n            this.applyHiddenRanges(newHiddenAreas);\n        }\n    }\n    applyHiddenRanges(newHiddenAreas) {\n        this._hiddenRanges = newHiddenAreas;\n        this._hasLineChanges = false;\n        this._updateEventEmitter.fire(newHiddenAreas);\n    }\n    hasRanges() {\n        return this._hiddenRanges.length > 0;\n    }\n    isHidden(line) {\n        return findRange(this._hiddenRanges, line) !== null;\n    }\n    adjustSelections(selections) {\n        let hasChanges = false;\n        const editorModel = this._foldingModel.textModel;\n        let lastRange = null;\n        const adjustLine = (line) => {\n            if (!lastRange || !isInside(line, lastRange)) {\n                lastRange = findRange(this._hiddenRanges, line);\n            }\n            if (lastRange) {\n                return lastRange.startLineNumber - 1;\n            }\n            return null;\n        };\n        for (let i = 0, len = selections.length; i < len; i++) {\n            let selection = selections[i];\n            const adjustedStartLine = adjustLine(selection.startLineNumber);\n            if (adjustedStartLine) {\n                selection = selection.setStartPosition(adjustedStartLine, editorModel.getLineMaxColumn(adjustedStartLine));\n                hasChanges = true;\n            }\n            const adjustedEndLine = adjustLine(selection.endLineNumber);\n            if (adjustedEndLine) {\n                selection = selection.setEndPosition(adjustedEndLine, editorModel.getLineMaxColumn(adjustedEndLine));\n                hasChanges = true;\n            }\n            selections[i] = selection;\n        }\n        return hasChanges;\n    }\n    dispose() {\n        if (this.hiddenRanges.length > 0) {\n            this._hiddenRanges = [];\n            this._updateEventEmitter.fire(this._hiddenRanges);\n        }\n        if (this._foldingModelListener) {\n            this._foldingModelListener.dispose();\n            this._foldingModelListener = null;\n        }\n    }\n}\nfunction isInside(line, range) {\n    return line >= range.startLineNumber && line <= range.endLineNumber;\n}\nfunction findRange(ranges, line) {\n    const i = findFirstIdxMonotonousOrArrLen(ranges, r => line < r.startLineNumber) - 1;\n    if (i >= 0 && ranges[i].endLineNumber >= line) {\n        return ranges[i];\n    }\n    return null;\n}\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}