custom-electron-titlebar 3.2.6 → 3.2.10

package/lib/vs/base/common/skipList.js

@@ -1,234 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.SkipList = void 0;
-
-class Node {
-  constructor(level, key, value) {
-    this.level = level;
-    this.key = key;
-    this.value = value;
-    this.forward = [];
-  }
-
-}
-
-const NIL = undefined;
-
-class SkipList {
-  /**
-   *
-   * @param capacity Capacity at which the list performs best
-   */
-  constructor(comparator, capacity = 2 ** 16) {
-    this.comparator = comparator;
-    this[Symbol.toStringTag] = 'SkipList';
-    this._level = 0;
-    this._size = 0;
-    this._maxLevel = Math.max(1, Math.log2(capacity) | 0);
-    this._header = new Node(this._maxLevel, NIL, NIL);
-  }
-
-  get size() {
-    return this._size;
-  }
-
-  clear() {
-    this._header = new Node(this._maxLevel, NIL, NIL);
-  }
-
-  has(key) {
-    return Boolean(SkipList._search(this, key, this.comparator));
-  }
-
-  get(key) {
-    var _a;
-
-    return (_a = SkipList._search(this, key, this.comparator)) === null || _a === void 0 ? void 0 : _a.value;
-  }
-
-  set(key, value) {
-    if (SkipList._insert(this, key, value, this.comparator)) {
-      this._size += 1;
-    }
-
-    return this;
-  }
-
-  delete(key) {
-    const didDelete = SkipList._delete(this, key, this.comparator);
-
-    if (didDelete) {
-      this._size -= 1;
-    }
-
-    return didDelete;
-  } // --- iteration
-
-
-  forEach(callbackfn, thisArg) {
-    let node = this._header.forward[0];
-
-    while (node) {
-      callbackfn.call(thisArg, node.value, node.key, this);
-      node = node.forward[0];
-    }
-  }
-
-  [Symbol.iterator]() {
-    return this.entries();
-  }
-
-  *entries() {
-    let node = this._header.forward[0];
-
-    while (node) {
-      yield [node.key, node.value];
-      node = node.forward[0];
-    }
-  }
-
-  *keys() {
-    let node = this._header.forward[0];
-
-    while (node) {
-      yield node.key;
-      node = node.forward[0];
-    }
-  }
-
-  *values() {
-    let node = this._header.forward[0];
-
-    while (node) {
-      yield node.value;
-      node = node.forward[0];
-    }
-  }
-
-  toString() {
-    // debug string...
-    let result = '[SkipList]:';
-    let node = this._header.forward[0];
-
-    while (node) {
-      result += `node(${node.key}, ${node.value}, lvl:${node.level})`;
-      node = node.forward[0];
-    }
-
-    return result;
-  } // from https://www.epaperpress.com/sortsearch/download/skiplist.pdf
-
-
-  static _search(list, searchKey, comparator) {
-    let x = list._header;
-
-    for (let i = list._level - 1; i >= 0; i--) {
-      while (x.forward[i] && comparator(x.forward[i].key, searchKey) < 0) {
-        x = x.forward[i];
-      }
-    }
-
-    x = x.forward[0];
-
-    if (x && comparator(x.key, searchKey) === 0) {
-      return x;
-    }
-
-    return undefined;
-  }
-
-  static _insert(list, searchKey, value, comparator) {
-    let update = [];
-    let x = list._header;
-
-    for (let i = list._level - 1; i >= 0; i--) {
-      while (x.forward[i] && comparator(x.forward[i].key, searchKey) < 0) {
-        x = x.forward[i];
-      }
-
-      update[i] = x;
-    }
-
-    x = x.forward[0];
-
-    if (x && comparator(x.key, searchKey) === 0) {
-      // update
-      x.value = value;
-      return false;
-    } else {
-      // insert
-      let lvl = SkipList._randomLevel(list);
-
-      if (lvl > list._level) {
-        for (let i = list._level; i < lvl; i++) {
-          update[i] = list._header;
-        }
-
-        list._level = lvl;
-      }
-
-      x = new Node(lvl, searchKey, value);
-
-      for (let i = 0; i < lvl; i++) {
-        x.forward[i] = update[i].forward[i];
-        update[i].forward[i] = x;
-      }
-
-      return true;
-    }
-  }
-
-  static _randomLevel(list, p = 0.5) {
-    let lvl = 1;
-
-    while (Math.random() < p && lvl < list._maxLevel) {
-      lvl += 1;
-    }
-
-    return lvl;
-  }
-
-  static _delete(list, searchKey, comparator) {
-    let update = [];
-    let x = list._header;
-
-    for (let i = list._level - 1; i >= 0; i--) {
-      while (x.forward[i] && comparator(x.forward[i].key, searchKey) < 0) {
-        x = x.forward[i];
-      }
-
-      update[i] = x;
-    }
-
-    x = x.forward[0];
-
-    if (!x || comparator(x.key, searchKey) !== 0) {
-      // not found
-      return false;
-    }
-
-    for (let i = 0; i < list._level; i++) {
-      if (update[i].forward[i] !== x) {
-        break;
-      }
-
-      update[i].forward[i] = x.forward[i];
-    }
-
-    while (list._level > 0 && list._header.forward[list._level - 1] === NIL) {
-      list._level -= 1;
-    }
-
-    return true;
-  }
-
-}
-
-exports.SkipList = SkipList;

package/lib/vs/base/common/stopwatch.js

@@ -1,45 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.StopWatch = void 0;
-
-const platform_1 = require("./platform");
-
-const hasPerformanceNow = platform_1.globals.performance && typeof platform_1.globals.performance.now === 'function';
-
-class StopWatch {
-  constructor(highResolution) {
-    this._highResolution = hasPerformanceNow && highResolution;
-    this._startTime = this._now();
-    this._stopTime = -1;
-  }
-
-  static create(highResolution = true) {
-    return new StopWatch(highResolution);
-  }
-
-  stop() {
-    this._stopTime = this._now();
-  }
-
-  elapsed() {
-    if (this._stopTime !== -1) {
-      return this._stopTime - this._startTime;
-    }
-
-    return this._now() - this._startTime;
-  }
-
-  _now() {
-    return this._highResolution ? platform_1.globals.performance.now() : new Date().getTime();
-  }
-
-}
-
-exports.StopWatch = StopWatch;

package/lib/vs/base/common/stream.js

@@ -1,418 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.transform = exports.toReadable = exports.toStream = exports.peekStream = exports.consumeStream = exports.peekReadable = exports.consumeReadable = exports.newWriteableStream = exports.isReadableBufferedStream = exports.isReadableStream = void 0;
-
-const lifecycle_1 = require("./lifecycle");
-
-function isReadableStream(obj) {
-  const candidate = obj;
-  return candidate && [candidate.on, candidate.pause, candidate.resume, candidate.destroy].every(fn => typeof fn === 'function');
-}
-
-exports.isReadableStream = isReadableStream;
-
-function isReadableBufferedStream(obj) {
-  const candidate = obj;
-  return candidate && isReadableStream(candidate.stream) && Array.isArray(candidate.buffer) && typeof candidate.ended === 'boolean';
-}
-
-exports.isReadableBufferedStream = isReadableBufferedStream;
-
-function newWriteableStream(reducer, options) {
-  return new WriteableStreamImpl(reducer, options);
-}
-
-exports.newWriteableStream = newWriteableStream;
-
-class WriteableStreamImpl {
-  constructor(reducer, options) {
-    this.reducer = reducer;
-    this.options = options;
-    this.state = {
-      flowing: false,
-      ended: false,
-      destroyed: false
-    };
-    this.buffer = {
-      data: [],
-      error: []
-    };
-    this.listeners = {
-      data: [],
-      error: [],
-      end: []
-    };
-    this.pendingWritePromises = [];
-  }
-
-  pause() {
-    if (this.state.destroyed) {
-      return;
-    }
-
-    this.state.flowing = false;
-  }
-
-  resume() {
-    if (this.state.destroyed) {
-      return;
-    }
-
-    if (!this.state.flowing) {
-      this.state.flowing = true; // emit buffered events
-
-      this.flowData();
-      this.flowErrors();
-      this.flowEnd();
-    }
-  }
-
-  write(data) {
-    var _a;
-
-    if (this.state.destroyed) {
-      return;
-    } // flowing: directly send the data to listeners
-
-
-    if (this.state.flowing) {
-      this.listeners.data.forEach(listener => listener(data));
-    } // not yet flowing: buffer data until flowing
-    else {
-        this.buffer.data.push(data); // highWaterMark: if configured, signal back when buffer reached limits
-
-        if (typeof ((_a = this.options) === null || _a === void 0 ? void 0 : _a.highWaterMark) === 'number' && this.buffer.data.length > this.options.highWaterMark) {
-          return new Promise(resolve => this.pendingWritePromises.push(resolve));
-        }
-      }
-  }
-
-  error(error) {
-    if (this.state.destroyed) {
-      return;
-    } // flowing: directly send the error to listeners
-
-
-    if (this.state.flowing) {
-      this.listeners.error.forEach(listener => listener(error));
-    } // not yet flowing: buffer errors until flowing
-    else {
-        this.buffer.error.push(error);
-      }
-  }
-
-  end(result) {
-    if (this.state.destroyed) {
-      return;
-    } // end with data or error if provided
-
-
-    if (result instanceof Error) {
-      this.error(result);
-    } else if (result) {
-      this.write(result);
-    } // flowing: send end event to listeners
-
-
-    if (this.state.flowing) {
-      this.listeners.end.forEach(listener => listener());
-      this.destroy();
-    } // not yet flowing: remember state
-    else {
-        this.state.ended = true;
-      }
-  }
-
-  on(event, callback) {
-    if (this.state.destroyed) {
-      return;
-    }
-
-    switch (event) {
-      case 'data':
-        this.listeners.data.push(callback); // switch into flowing mode as soon as the first 'data'
-        // listener is added and we are not yet in flowing mode
-
-        this.resume();
-        break;
-
-      case 'end':
-        this.listeners.end.push(callback); // emit 'end' event directly if we are flowing
-        // and the end has already been reached
-        //
-        // finish() when it went through
-
-        if (this.state.flowing && this.flowEnd()) {
-          this.destroy();
-        }
-
-        break;
-
-      case 'error':
-        this.listeners.error.push(callback); // emit buffered 'error' events unless done already
-        // now that we know that we have at least one listener
-
-        if (this.state.flowing) {
-          this.flowErrors();
-        }
-
-        break;
-    }
-  }
-
-  removeListener(event, callback) {
-    if (this.state.destroyed) {
-      return;
-    }
-
-    let listeners = undefined;
-
-    switch (event) {
-      case 'data':
-        listeners = this.listeners.data;
-        break;
-
-      case 'end':
-        listeners = this.listeners.end;
-        break;
-
-      case 'error':
-        listeners = this.listeners.error;
-        break;
-    }
-
-    if (listeners) {
-      const index = listeners.indexOf(callback);
-
-      if (index >= 0) {
-        listeners.splice(index, 1);
-      }
-    }
-  }
-
-  flowData() {
-    if (this.buffer.data.length > 0) {
-      const fullDataBuffer = this.reducer(this.buffer.data);
-      this.listeners.data.forEach(listener => listener(fullDataBuffer));
-      this.buffer.data.length = 0; // When the buffer is empty, resolve all pending writers
-
-      const pendingWritePromises = [...this.pendingWritePromises];
-      this.pendingWritePromises.length = 0;
-      pendingWritePromises.forEach(pendingWritePromise => pendingWritePromise());
-    }
-  }
-
-  flowErrors() {
-    if (this.listeners.error.length > 0) {
-      for (const error of this.buffer.error) {
-        this.listeners.error.forEach(listener => listener(error));
-      }
-
-      this.buffer.error.length = 0;
-    }
-  }
-
-  flowEnd() {
-    if (this.state.ended) {
-      this.listeners.end.forEach(listener => listener());
-      return this.listeners.end.length > 0;
-    }
-
-    return false;
-  }
-
-  destroy() {
-    if (!this.state.destroyed) {
-      this.state.destroyed = true;
-      this.state.ended = true;
-      this.buffer.data.length = 0;
-      this.buffer.error.length = 0;
-      this.listeners.data.length = 0;
-      this.listeners.error.length = 0;
-      this.listeners.end.length = 0;
-      this.pendingWritePromises.length = 0;
-    }
-  }
-
-}
-/**
- * Helper to fully read a T readable into a T.
- */
-
-
-function consumeReadable(readable, reducer) {
-  const chunks = [];
-  let chunk;
-
-  while ((chunk = readable.read()) !== null) {
-    chunks.push(chunk);
-  }
-
-  return reducer(chunks);
-}
-
-exports.consumeReadable = consumeReadable;
-/**
- * Helper to read a T readable up to a maximum of chunks. If the limit is
- * reached, will return a readable instead to ensure all data can still
- * be read.
- */
-
-function peekReadable(readable, reducer, maxChunks) {
-  const chunks = [];
-  let chunk = undefined;
-
-  while ((chunk = readable.read()) !== null && chunks.length < maxChunks) {
-    chunks.push(chunk);
-  } // If the last chunk is null, it means we reached the end of
-  // the readable and return all the data at once
-
-
-  if (chunk === null && chunks.length > 0) {
-    return reducer(chunks);
-  } // Otherwise, we still have a chunk, it means we reached the maxChunks
-  // value and as such we return a new Readable that first returns
-  // the existing read chunks and then continues with reading from
-  // the underlying readable.
-
-
-  return {
-    read: () => {
-      // First consume chunks from our array
-      if (chunks.length > 0) {
-        return chunks.shift();
-      } // Then ensure to return our last read chunk
-
-
-      if (typeof chunk !== 'undefined') {
-        const lastReadChunk = chunk; // explicitly use undefined here to indicate that we consumed
-        // the chunk, which could have either been null or valued.
-
-        chunk = undefined;
-        return lastReadChunk;
-      } // Finally delegate back to the Readable
-
-
-      return readable.read();
-    }
-  };
-}
-
-exports.peekReadable = peekReadable;
-/**
- * Helper to fully read a T stream into a T.
- */
-
-function consumeStream(stream, reducer) {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    stream.on('data', data => chunks.push(data));
-    stream.on('error', error => reject(error));
-    stream.on('end', () => resolve(reducer(chunks)));
-  });
-}
-
-exports.consumeStream = consumeStream;
-/**
- * Helper to peek up to `maxChunks` into a stream. The return type signals if
- * the stream has ended or not. If not, caller needs to add a `data` listener
- * to continue reading.
- */
-
-function peekStream(stream, maxChunks) {
-  return new Promise((resolve, reject) => {
-    const streamListeners = new lifecycle_1.DisposableStore(); // Data Listener
-
-    const buffer = [];
-
-    const dataListener = chunk => {
-      // Add to buffer
-      buffer.push(chunk); // We reached maxChunks and thus need to return
-
-      if (buffer.length > maxChunks) {
-        // Dispose any listeners and ensure to pause the
-        // stream so that it can be consumed again by caller
-        streamListeners.dispose();
-        stream.pause();
-        return resolve({
-          stream,
-          buffer,
-          ended: false
-        });
-      }
-    };
-
-    streamListeners.add(lifecycle_1.toDisposable(() => stream.removeListener('data', dataListener)));
-    stream.on('data', dataListener); // Error Listener
-
-    const errorListener = error => {
-      return reject(error);
-    };
-
-    streamListeners.add(lifecycle_1.toDisposable(() => stream.removeListener('error', errorListener)));
-    stream.on('error', errorListener);
-
-    const endListener = () => {
-      return resolve({
-        stream,
-        buffer,
-        ended: true
-      });
-    };
-
-    streamListeners.add(lifecycle_1.toDisposable(() => stream.removeListener('end', endListener)));
-    stream.on('end', endListener);
-  });
-}
-
-exports.peekStream = peekStream;
-/**
- * Helper to create a readable stream from an existing T.
- */
-
-function toStream(t, reducer) {
-  const stream = newWriteableStream(reducer);
-  stream.end(t);
-  return stream;
-}
-
-exports.toStream = toStream;
-/**
- * Helper to convert a T into a Readable<T>.
- */
-
-function toReadable(t) {
-  let consumed = false;
-  return {
-    read: () => {
-      if (consumed) {
-        return null;
-      }
-
-      consumed = true;
-      return t;
-    }
-  };
-}
-
-exports.toReadable = toReadable;
-/**
- * Helper to transform a readable stream into another stream.
- */
-
-function transform(stream, transformer, reducer) {
-  const target = newWriteableStream(reducer);
-  stream.on('data', data => target.write(transformer.data(data)));
-  stream.on('end', () => target.end());
-  stream.on('error', error => target.error(transformer.error ? transformer.error(error) : error));
-  return target;
-}
-
-exports.transform = transform;