UNPKG

@pkerschbaum/code-oss-file-service

Version:

VS Code ([microsoft/vscode](https://github.com/microsoft/vscode)) includes a rich "`FileService`" and "`DiskFileSystemProvider`" abstraction built on top of Node.js core modules (`fs`, `path`) and Electron's `shell` module. This package allows to use that

1,200 lines 39.2 kB
"use strict"; /*--------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) { if (kind === "m") throw new TypeError("Private method is not writable"); if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; }; var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) { if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); }; var _a, _b, _ReadonlyMapView_source; Object.defineProperty(exports, "__esModule", { value: true }); exports.ReadonlyMapView = exports.LRUCache = exports.LinkedMap = exports.Touch = exports.ResourceMap = exports.TernarySearchTree = exports.UriIterator = exports.PathIterator = exports.ConfigKeysIterator = exports.StringIterator = exports.setToString = exports.mapToString = exports.getOrSet = void 0; const arrays_1 = require("../../base/common/arrays"); const strings_1 = require("../../base/common/strings"); function getOrSet(map, key, value) { let result = map.get(key); if (result === undefined) { result = value; map.set(key, result); } return result; } exports.getOrSet = getOrSet; function mapToString(map) { const entries = []; map.forEach((value, key) => { entries.push(`${key} => ${value}`); }); return `Map(${map.size}) {${entries.join(', ')}}`; } exports.mapToString = mapToString; function setToString(set) { const entries = []; set.forEach(value => { entries.push(value); }); return `Set(${set.size}) {${entries.join(', ')}}`; } exports.setToString = setToString; class StringIterator { constructor() { this._value = ''; this._pos = 0; } reset(key) { this._value = key; this._pos = 0; return this; } next() { this._pos += 1; return this; } hasNext() { return this._pos < this._value.length - 1; } cmp(a) { const aCode = a.charCodeAt(0); const thisCode = this._value.charCodeAt(this._pos); return aCode - thisCode; } value() { return this._value[this._pos]; } } exports.StringIterator = StringIterator; class ConfigKeysIterator { constructor(_caseSensitive = true) { this._caseSensitive = _caseSensitive; } reset(key) { this._value = key; this._from = 0; this._to = 0; return this.next(); } hasNext() { return this._to < this._value.length; } next() { // this._data = key.split(/[\\/]/).filter(s => !!s); this._from = this._to; let justSeps = true; for (; this._to < this._value.length; this._to++) { const ch = this._value.charCodeAt(this._to); if (ch === 46 /* Period */) { if (justSeps) { this._from++; } else { break; } } else { justSeps = false; } } return this; } cmp(a) { return this._caseSensitive ? (0, strings_1.compareSubstring)(a, this._value, 0, a.length, this._from, this._to) : (0, strings_1.compareSubstringIgnoreCase)(a, this._value, 0, a.length, this._from, this._to); } value() { return this._value.substring(this._from, this._to); } } exports.ConfigKeysIterator = ConfigKeysIterator; class PathIterator { constructor(_splitOnBackslash = true, _caseSensitive = true) { this._splitOnBackslash = _splitOnBackslash; this._caseSensitive = _caseSensitive; } reset(key) { this._from = 0; this._to = 0; this._value = key; this._valueLen = key.length; for (let pos = key.length - 1; pos >= 0; pos--, this._valueLen--) { const ch = this._value.charCodeAt(pos); if (!(ch === 47 /* Slash */ || this._splitOnBackslash && ch === 92 /* Backslash */)) { break; } } return this.next(); } hasNext() { return this._to < this._valueLen; } next() { // this._data = key.split(/[\\/]/).filter(s => !!s); this._from = this._to; let justSeps = true; for (; this._to < this._valueLen; this._to++) { const ch = this._value.charCodeAt(this._to); if (ch === 47 /* Slash */ || this._splitOnBackslash && ch === 92 /* Backslash */) { if (justSeps) { this._from++; } else { break; } } else { justSeps = false; } } return this; } cmp(a) { return this._caseSensitive ? (0, strings_1.compareSubstring)(a, this._value, 0, a.length, this._from, this._to) : (0, strings_1.compareSubstringIgnoreCase)(a, this._value, 0, a.length, this._from, this._to); } value() { return this._value.substring(this._from, this._to); } } exports.PathIterator = PathIterator; var UriIteratorState; (function (UriIteratorState) { UriIteratorState[UriIteratorState["Scheme"] = 1] = "Scheme"; UriIteratorState[UriIteratorState["Authority"] = 2] = "Authority"; UriIteratorState[UriIteratorState["Path"] = 3] = "Path"; UriIteratorState[UriIteratorState["Query"] = 4] = "Query"; UriIteratorState[UriIteratorState["Fragment"] = 5] = "Fragment"; })(UriIteratorState || (UriIteratorState = {})); class UriIterator { constructor(_ignorePathCasing) { this._ignorePathCasing = _ignorePathCasing; this._states = []; this._stateIdx = 0; } reset(key) { this._value = key; this._states = []; if (this._value.scheme) { this._states.push(1 /* Scheme */); } if (this._value.authority) { this._states.push(2 /* Authority */); } if (this._value.path) { this._pathIterator = new PathIterator(false, !this._ignorePathCasing(key)); this._pathIterator.reset(key.path); if (this._pathIterator.value()) { this._states.push(3 /* Path */); } } if (this._value.query) { this._states.push(4 /* Query */); } if (this._value.fragment) { this._states.push(5 /* Fragment */); } this._stateIdx = 0; return this; } next() { if (this._states[this._stateIdx] === 3 /* Path */ && this._pathIterator.hasNext()) { this._pathIterator.next(); } else { this._stateIdx += 1; } return this; } hasNext() { return (this._states[this._stateIdx] === 3 /* Path */ && this._pathIterator.hasNext()) || this._stateIdx < this._states.length - 1; } cmp(a) { if (this._states[this._stateIdx] === 1 /* Scheme */) { return (0, strings_1.compareIgnoreCase)(a, this._value.scheme); } else if (this._states[this._stateIdx] === 2 /* Authority */) { return (0, strings_1.compareIgnoreCase)(a, this._value.authority); } else if (this._states[this._stateIdx] === 3 /* Path */) { return this._pathIterator.cmp(a); } else if (this._states[this._stateIdx] === 4 /* Query */) { return (0, strings_1.compare)(a, this._value.query); } else if (this._states[this._stateIdx] === 5 /* Fragment */) { return (0, strings_1.compare)(a, this._value.fragment); } throw new Error(); } value() { if (this._states[this._stateIdx] === 1 /* Scheme */) { return this._value.scheme; } else if (this._states[this._stateIdx] === 2 /* Authority */) { return this._value.authority; } else if (this._states[this._stateIdx] === 3 /* Path */) { return this._pathIterator.value(); } else if (this._states[this._stateIdx] === 4 /* Query */) { return this._value.query; } else if (this._states[this._stateIdx] === 5 /* Fragment */) { return this._value.fragment; } throw new Error(); } } exports.UriIterator = UriIterator; class TernarySearchTreeNode { constructor() { this.height = 1; } isEmpty() { return !this.left && !this.mid && !this.right && !this.value; } rotateLeft() { const tmp = this.right; this.right = tmp.left; tmp.left = this; this.updateHeight(); tmp.updateHeight(); return tmp; } rotateRight() { const tmp = this.left; this.left = tmp.right; tmp.right = this; this.updateHeight(); tmp.updateHeight(); return tmp; } updateHeight() { this.height = 1 + Math.max(this.heightLeft, this.heightRight); } balanceFactor() { return this.heightRight - this.heightLeft; } get heightLeft() { var _c, _d; return (_d = (_c = this.left) === null || _c === void 0 ? void 0 : _c.height) !== null && _d !== void 0 ? _d : 0; } get heightRight() { var _c, _d; return (_d = (_c = this.right) === null || _c === void 0 ? void 0 : _c.height) !== null && _d !== void 0 ? _d : 0; } } var Dir; (function (Dir) { Dir[Dir["Left"] = -1] = "Left"; Dir[Dir["Mid"] = 0] = "Mid"; Dir[Dir["Right"] = 1] = "Right"; })(Dir || (Dir = {})); class TernarySearchTree { constructor(segments) { this._iter = segments; } static forUris(ignorePathCasing = () => false) { return new TernarySearchTree(new UriIterator(ignorePathCasing)); } static forPaths() { return new TernarySearchTree(new PathIterator()); } static forStrings() { return new TernarySearchTree(new StringIterator()); } static forConfigKeys() { return new TernarySearchTree(new ConfigKeysIterator()); } clear() { this._root = undefined; } fill(values, keys) { if (keys) { const arr = keys.slice(0); (0, arrays_1.shuffle)(arr); for (let k of arr) { this.set(k, values); } } else { const arr = values.slice(0); (0, arrays_1.shuffle)(arr); for (let entry of arr) { this.set(entry[0], entry[1]); } } } set(key, element) { const iter = this._iter.reset(key); let node; if (!this._root) { this._root = new TernarySearchTreeNode(); this._root.segment = iter.value(); } const stack = []; // find insert_node node = this._root; while (true) { const val = iter.cmp(node.segment); if (val > 0) { // left if (!node.left) { node.left = new TernarySearchTreeNode(); node.left.segment = iter.value(); } stack.push([-1 /* Left */, node]); node = node.left; } else if (val < 0) { // right if (!node.right) { node.right = new TernarySearchTreeNode(); node.right.segment = iter.value(); } stack.push([1 /* Right */, node]); node = node.right; } else if (iter.hasNext()) { // mid iter.next(); if (!node.mid) { node.mid = new TernarySearchTreeNode(); node.mid.segment = iter.value(); } stack.push([0 /* Mid */, node]); node = node.mid; } else { break; } } // set value const oldElement = node.value; node.value = element; node.key = key; // balance for (let i = stack.length - 1; i >= 0; i--) { const node = stack[i][1]; node.updateHeight(); const bf = node.balanceFactor(); if (bf < -1 || bf > 1) { // needs rotate const d1 = stack[i][0]; const d2 = stack[i + 1][0]; if (d1 === 1 /* Right */ && d2 === 1 /* Right */) { //right, right -> rotate left stack[i][1] = node.rotateLeft(); } else if (d1 === -1 /* Left */ && d2 === -1 /* Left */) { // left, left -> rotate right stack[i][1] = node.rotateRight(); } else if (d1 === 1 /* Right */ && d2 === -1 /* Left */) { // right, left -> double rotate right, left node.right = stack[i + 1][1] = stack[i + 1][1].rotateRight(); stack[i][1] = node.rotateLeft(); } else if (d1 === -1 /* Left */ && d2 === 1 /* Right */) { // left, right -> double rotate left, right node.left = stack[i + 1][1] = stack[i + 1][1].rotateLeft(); stack[i][1] = node.rotateRight(); } else { throw new Error(); } // patch path to parent if (i > 0) { switch (stack[i - 1][0]) { case -1 /* Left */: stack[i - 1][1].left = stack[i][1]; break; case 1 /* Right */: stack[i - 1][1].right = stack[i][1]; break; case 0 /* Mid */: stack[i - 1][1].mid = stack[i][1]; break; } } else { this._root = stack[0][1]; } } } return oldElement; } get(key) { var _c; return (_c = this._getNode(key)) === null || _c === void 0 ? void 0 : _c.value; } _getNode(key) { const iter = this._iter.reset(key); let node = this._root; while (node) { const val = iter.cmp(node.segment); if (val > 0) { // left node = node.left; } else if (val < 0) { // right node = node.right; } else if (iter.hasNext()) { // mid iter.next(); node = node.mid; } else { break; } } return node; } has(key) { const node = this._getNode(key); return !((node === null || node === void 0 ? void 0 : node.value) === undefined && (node === null || node === void 0 ? void 0 : node.mid) === undefined); } delete(key) { return this._delete(key, false); } deleteSuperstr(key) { return this._delete(key, true); } _delete(key, superStr) { var _c; const iter = this._iter.reset(key); const stack = []; let node = this._root; // find node while (node) { const val = iter.cmp(node.segment); if (val > 0) { // left stack.push([-1 /* Left */, node]); node = node.left; } else if (val < 0) { // right stack.push([1 /* Right */, node]); node = node.right; } else if (iter.hasNext()) { // mid iter.next(); stack.push([0 /* Mid */, node]); node = node.mid; } else { break; } } if (!node) { // node not found return; } if (superStr) { // removing children, reset height node.left = undefined; node.mid = undefined; node.right = undefined; node.height = 1; } else { // removing element node.key = undefined; node.value = undefined; } // BST node removal if (!node.mid && !node.value) { if (node.left && node.right) { // full node const min = this._min(node.right); const { key, value, segment } = min; this._delete(min.key, false); node.key = key; node.value = value; node.segment = segment; } else { // empty or half empty const newChild = (_c = node.left) !== null && _c !== void 0 ? _c : node.right; if (stack.length > 0) { const [dir, parent] = stack[stack.length - 1]; switch (dir) { case -1 /* Left */: parent.left = newChild; break; case 0 /* Mid */: parent.mid = newChild; break; case 1 /* Right */: parent.right = newChild; break; } } else { this._root = newChild; } } } // AVL balance for (let i = stack.length - 1; i >= 0; i--) { const node = stack[i][1]; node.updateHeight(); const bf = node.balanceFactor(); if (bf > 1) { // right heavy if (node.right.balanceFactor() >= 0) { // right, right -> rotate left stack[i][1] = node.rotateLeft(); } else { // right, left -> double rotate node.right = node.right.rotateRight(); stack[i][1] = node.rotateLeft(); } } else if (bf < -1) { // left heavy if (node.left.balanceFactor() <= 0) { // left, left -> rotate right stack[i][1] = node.rotateRight(); } else { // left, right -> double rotate node.left = node.left.rotateLeft(); stack[i][1] = node.rotateRight(); } } // patch path to parent if (i > 0) { switch (stack[i - 1][0]) { case -1 /* Left */: stack[i - 1][1].left = stack[i][1]; break; case 1 /* Right */: stack[i - 1][1].right = stack[i][1]; break; case 0 /* Mid */: stack[i - 1][1].mid = stack[i][1]; break; } } else { this._root = stack[0][1]; } } } _min(node) { while (node.left) { node = node.left; } return node; } findSubstr(key) { const iter = this._iter.reset(key); let node = this._root; let candidate = undefined; while (node) { const val = iter.cmp(node.segment); if (val > 0) { // left node = node.left; } else if (val < 0) { // right node = node.right; } else if (iter.hasNext()) { // mid iter.next(); candidate = node.value || candidate; node = node.mid; } else { break; } } return node && node.value || candidate; } findSuperstr(key) { const iter = this._iter.reset(key); let node = this._root; while (node) { const val = iter.cmp(node.segment); if (val > 0) { // left node = node.left; } else if (val < 0) { // right node = node.right; } else if (iter.hasNext()) { // mid iter.next(); node = node.mid; } else { // collect if (!node.mid) { return undefined; } else { return this._entries(node.mid); } } } return undefined; } forEach(callback) { for (const [key, value] of this) { callback(value, key); } } *[Symbol.iterator]() { yield* this._entries(this._root); } *_entries(node) { // DFS if (!node) { return; } if (node.left) { yield* this._entries(node.left); } if (node.value) { yield [node.key, node.value]; } if (node.mid) { yield* this._entries(node.mid); } if (node.right) { yield* this._entries(node.right); } } // for debug/testing _isBalanced() { const nodeIsBalanced = (node) => { if (!node) { return true; } const bf = node.balanceFactor(); if (bf < -1 || bf > 1) { return false; } return nodeIsBalanced(node.left) && nodeIsBalanced(node.right); }; return nodeIsBalanced(this._root); } } exports.TernarySearchTree = TernarySearchTree; class ResourceMapEntry { constructor(uri, value) { this.uri = uri; this.value = value; } } class ResourceMap { constructor(mapOrKeyFn, toKey) { this[_a] = 'ResourceMap'; if (mapOrKeyFn instanceof ResourceMap) { this.map = new Map(mapOrKeyFn.map); this.toKey = toKey !== null && toKey !== void 0 ? toKey : ResourceMap.defaultToKey; } else { this.map = new Map(); this.toKey = mapOrKeyFn !== null && mapOrKeyFn !== void 0 ? mapOrKeyFn : ResourceMap.defaultToKey; } } set(resource, value) { this.map.set(this.toKey(resource), new ResourceMapEntry(resource, value)); return this; } get(resource) { var _c; return (_c = this.map.get(this.toKey(resource))) === null || _c === void 0 ? void 0 : _c.value; } has(resource) { return this.map.has(this.toKey(resource)); } get size() { return this.map.size; } clear() { this.map.clear(); } delete(resource) { return this.map.delete(this.toKey(resource)); } forEach(clb, thisArg) { if (typeof thisArg !== 'undefined') { clb = clb.bind(thisArg); } for (let [_, entry] of this.map) { clb(entry.value, entry.uri, this); } } *values() { for (let entry of this.map.values()) { yield entry.value; } } *keys() { for (let entry of this.map.values()) { yield entry.uri; } } *entries() { for (let entry of this.map.values()) { yield [entry.uri, entry.value]; } } *[(_a = Symbol.toStringTag, Symbol.iterator)]() { for (let [, entry] of this.map) { yield [entry.uri, entry.value]; } } } exports.ResourceMap = ResourceMap; ResourceMap.defaultToKey = (resource) => resource.toString(); var Touch; (function (Touch) { Touch[Touch["None"] = 0] = "None"; Touch[Touch["AsOld"] = 1] = "AsOld"; Touch[Touch["AsNew"] = 2] = "AsNew"; })(Touch = exports.Touch || (exports.Touch = {})); class LinkedMap { constructor() { this[_b] = 'LinkedMap'; this._map = new Map(); this._head = undefined; this._tail = undefined; this._size = 0; this._state = 0; } clear() { this._map.clear(); this._head = undefined; this._tail = undefined; this._size = 0; this._state++; } isEmpty() { return !this._head && !this._tail; } get size() { return this._size; } get first() { var _c; return (_c = this._head) === null || _c === void 0 ? void 0 : _c.value; } get last() { var _c; return (_c = this._tail) === null || _c === void 0 ? void 0 : _c.value; } has(key) { return this._map.has(key); } get(key, touch = 0 /* None */) { const item = this._map.get(key); if (!item) { return undefined; } if (touch !== 0 /* None */) { this.touch(item, touch); } return item.value; } set(key, value, touch = 0 /* None */) { let item = this._map.get(key); if (item) { item.value = value; if (touch !== 0 /* None */) { this.touch(item, touch); } } else { item = { key, value, next: undefined, previous: undefined }; switch (touch) { case 0 /* None */: this.addItemLast(item); break; case 1 /* AsOld */: this.addItemFirst(item); break; case 2 /* AsNew */: this.addItemLast(item); break; default: this.addItemLast(item); break; } this._map.set(key, item); this._size++; } return this; } delete(key) { return !!this.remove(key); } remove(key) { const item = this._map.get(key); if (!item) { return undefined; } this._map.delete(key); this.removeItem(item); this._size--; return item.value; } shift() { if (!this._head && !this._tail) { return undefined; } if (!this._head || !this._tail) { throw new Error('Invalid list'); } const item = this._head; this._map.delete(item.key); this.removeItem(item); this._size--; return item.value; } forEach(callbackfn, thisArg) { const state = this._state; let current = this._head; while (current) { if (thisArg) { callbackfn.bind(thisArg)(current.value, current.key, this); } else { callbackfn(current.value, current.key, this); } if (this._state !== state) { throw new Error(`LinkedMap got modified during iteration.`); } current = current.next; } } keys() { const map = this; const state = this._state; let current = this._head; const iterator = { [Symbol.iterator]() { return iterator; }, next() { if (map._state !== state) { throw new Error(`LinkedMap got modified during iteration.`); } if (current) { const result = { value: current.key, done: false }; current = current.next; return result; } else { return { value: undefined, done: true }; } } }; return iterator; } values() { const map = this; const state = this._state; let current = this._head; const iterator = { [Symbol.iterator]() { return iterator; }, next() { if (map._state !== state) { throw new Error(`LinkedMap got modified during iteration.`); } if (current) { const result = { value: current.value, done: false }; current = current.next; return result; } else { return { value: undefined, done: true }; } } }; return iterator; } entries() { const map = this; const state = this._state; let current = this._head; const iterator = { [Symbol.iterator]() { return iterator; }, next() { if (map._state !== state) { throw new Error(`LinkedMap got modified during iteration.`); } if (current) { const result = { value: [current.key, current.value], done: false }; current = current.next; return result; } else { return { value: undefined, done: true }; } } }; return iterator; } [(_b = Symbol.toStringTag, Symbol.iterator)]() { return this.entries(); } trimOld(newSize) { if (newSize >= this.size) { return; } if (newSize === 0) { this.clear(); return; } let current = this._head; let currentSize = this.size; while (current && currentSize > newSize) { this._map.delete(current.key); current = current.next; currentSize--; } this._head = current; this._size = currentSize; if (current) { current.previous = undefined; } this._state++; } addItemFirst(item) { // First time Insert if (!this._head && !this._tail) { this._tail = item; } else if (!this._head) { throw new Error('Invalid list'); } else { item.next = this._head; this._head.previous = item; } this._head = item; this._state++; } addItemLast(item) { // First time Insert if (!this._head && !this._tail) { this._head = item; } else if (!this._tail) { throw new Error('Invalid list'); } else { item.previous = this._tail; this._tail.next = item; } this._tail = item; this._state++; } removeItem(item) { if (item === this._head && item === this._tail) { this._head = undefined; this._tail = undefined; } else if (item === this._head) { // This can only happen if size === 1 which is handled // by the case above. if (!item.next) { throw new Error('Invalid list'); } item.next.previous = undefined; this._head = item.next; } else if (item === this._tail) { // This can only happen if size === 1 which is handled // by the case above. if (!item.previous) { throw new Error('Invalid list'); } item.previous.next = undefined; this._tail = item.previous; } else { const next = item.next; const previous = item.previous; if (!next || !previous) { throw new Error('Invalid list'); } next.previous = previous; previous.next = next; } item.next = undefined; item.previous = undefined; this._state++; } touch(item, touch) { if (!this._head || !this._tail) { throw new Error('Invalid list'); } if ((touch !== 1 /* AsOld */ && touch !== 2 /* AsNew */)) { return; } if (touch === 1 /* AsOld */) { if (item === this._head) { return; } const next = item.next; const previous = item.previous; // Unlink the item if (item === this._tail) { // previous must be defined since item was not head but is tail // So there are more than on item in the map previous.next = undefined; this._tail = previous; } else { // Both next and previous are not undefined since item was neither head nor tail. next.previous = previous; previous.next = next; } // Insert the node at head item.previous = undefined; item.next = this._head; this._head.previous = item; this._head = item; this._state++; } else if (touch === 2 /* AsNew */) { if (item === this._tail) { return; } const next = item.next; const previous = item.previous; // Unlink the item. if (item === this._head) { // next must be defined since item was not tail but is head // So there are more than on item in the map next.previous = undefined; this._head = next; } else { // Both next and previous are not undefined since item was neither head nor tail. next.previous = previous; previous.next = next; } item.next = undefined; item.previous = this._tail; this._tail.next = item; this._tail = item; this._state++; } } toJSON() { const data = []; this.forEach((value, key) => { data.push([key, value]); }); return data; } fromJSON(data) { this.clear(); for (const [key, value] of data) { this.set(key, value); } } } exports.LinkedMap = LinkedMap; class LRUCache extends LinkedMap { constructor(limit, ratio = 1) { super(); this._limit = limit; this._ratio = Math.min(Math.max(0, ratio), 1); } get limit() { return this._limit; } set limit(limit) { this._limit = limit; this.checkTrim(); } get ratio() { return this._ratio; } set ratio(ratio) { this._ratio = Math.min(Math.max(0, ratio), 1); this.checkTrim(); } get(key, touch = 2 /* AsNew */) { return super.get(key, touch); } peek(key) { return super.get(key, 0 /* None */); } set(key, value) { super.set(key, value, 2 /* AsNew */); this.checkTrim(); return this; } checkTrim() { if (this.size > this._limit) { this.trimOld(Math.round(this._limit * this._ratio)); } } } exports.LRUCache = LRUCache; /** * Wraps the map in type that only implements readonly properties. Useful * in the extension host to prevent the consumer from making any mutations. */ class ReadonlyMapView { constructor(source) { _ReadonlyMapView_source.set(this, void 0); __classPrivateFieldSet(this, _ReadonlyMapView_source, source, "f"); } get size() { return __classPrivateFieldGet(this, _ReadonlyMapView_source, "f").size; } forEach(callbackfn, thisArg) { __classPrivateFieldGet(this, _ReadonlyMapView_source, "f").forEach(callbackfn, thisArg); } get(key) { return __classPrivateFieldGet(this, _ReadonlyMapView_source, "f").get(key); } has(key) { return __classPrivateFieldGet(this, _ReadonlyMapView_source, "f").has(key); } entries() { return __classPrivateFieldGet(this, _ReadonlyMapView_source, "f").entries(); } keys() { return __classPrivateFieldGet(this, _ReadonlyMapView_source, "f").keys(); } values() { return __classPrivateFieldGet(this, _ReadonlyMapView_source, "f").values(); } [(_ReadonlyMapView_source = new WeakMap(), Symbol.iterator)]() { return __classPrivateFieldGet(this, _ReadonlyMapView_source, "f").entries(); } } exports.ReadonlyMapView = ReadonlyMapView; //# sourceMappingURL=map.js.map