custom-electron-titlebar 3.2.6 → 3.2.10

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

@@ -1,250 +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.newWriteableBufferStream = exports.streamToBufferReadableStream = exports.bufferToStream = exports.bufferedStreamToBuffer = exports.streamToBuffer = exports.bufferToReadable = exports.readableToBuffer = exports.writeUInt8 = exports.readUInt8 = exports.writeUInt32LE = exports.readUInt32LE = exports.writeUInt32BE = exports.readUInt32BE = exports.writeUInt16LE = exports.readUInt16LE = exports.VSBuffer = void 0;
-
-const strings = require("./strings");
-
-const streams = require("./stream");
-
-const hasBuffer = typeof Buffer !== 'undefined';
-const hasTextEncoder = typeof TextEncoder !== 'undefined';
-const hasTextDecoder = typeof TextDecoder !== 'undefined';
-let textEncoder;
-let textDecoder;
-
-class VSBuffer {
-  constructor(buffer) {
-    this.buffer = buffer;
-    this.byteLength = this.buffer.byteLength;
-  }
-
-  static alloc(byteLength) {
-    if (hasBuffer) {
-      return new VSBuffer(Buffer.allocUnsafe(byteLength));
-    } else {
-      return new VSBuffer(new Uint8Array(byteLength));
-    }
-  }
-
-  static wrap(actual) {
-    if (hasBuffer && !Buffer.isBuffer(actual)) {
-      // https://nodejs.org/dist/latest-v10.x/docs/api/buffer.html#buffer_class_method_buffer_from_arraybuffer_byteoffset_length
-      // Create a zero-copy Buffer wrapper around the ArrayBuffer pointed to by the Uint8Array
-      actual = Buffer.from(actual.buffer, actual.byteOffset, actual.byteLength);
-    }
-
-    return new VSBuffer(actual);
-  }
-
-  static fromString(source) {
-    if (hasBuffer) {
-      return new VSBuffer(Buffer.from(source));
-    } else if (hasTextEncoder) {
-      if (!textEncoder) {
-        textEncoder = new TextEncoder();
-      }
-
-      return new VSBuffer(textEncoder.encode(source));
-    } else {
-      return new VSBuffer(strings.encodeUTF8(source));
-    }
-  }
-
-  static concat(buffers, totalLength) {
-    if (typeof totalLength === 'undefined') {
-      totalLength = 0;
-
-      for (let i = 0, len = buffers.length; i < len; i++) {
-        totalLength += buffers[i].byteLength;
-      }
-    }
-
-    const ret = VSBuffer.alloc(totalLength);
-    let offset = 0;
-
-    for (let i = 0, len = buffers.length; i < len; i++) {
-      const element = buffers[i];
-      ret.set(element, offset);
-      offset += element.byteLength;
-    }
-
-    return ret;
-  }
-
-  toString() {
-    if (hasBuffer) {
-      return this.buffer.toString();
-    } else if (hasTextDecoder) {
-      if (!textDecoder) {
-        textDecoder = new TextDecoder();
-      }
-
-      return textDecoder.decode(this.buffer);
-    } else {
-      return strings.decodeUTF8(this.buffer);
-    }
-  }
-
-  slice(start, end) {
-    // IMPORTANT: use subarray instead of slice because TypedArray#slice
-    // creates shallow copy and NodeBuffer#slice doesn't. The use of subarray
-    // ensures the same, performant, behaviour.
-    return new VSBuffer(this.buffer.subarray(start
-    /*bad lib.d.ts*/
-    , end));
-  }
-
-  set(array, offset) {
-    if (array instanceof VSBuffer) {
-      this.buffer.set(array.buffer, offset);
-    } else {
-      this.buffer.set(array, offset);
-    }
-  }
-
-  readUInt32BE(offset) {
-    return readUInt32BE(this.buffer, offset);
-  }
-
-  writeUInt32BE(value, offset) {
-    writeUInt32BE(this.buffer, value, offset);
-  }
-
-  readUInt32LE(offset) {
-    return readUInt32LE(this.buffer, offset);
-  }
-
-  writeUInt32LE(value, offset) {
-    writeUInt32LE(this.buffer, value, offset);
-  }
-
-  readUInt8(offset) {
-    return readUInt8(this.buffer, offset);
-  }
-
-  writeUInt8(value, offset) {
-    writeUInt8(this.buffer, value, offset);
-  }
-
-}
-
-exports.VSBuffer = VSBuffer;
-
-function readUInt16LE(source, offset) {
-  return source[offset + 0] << 0 >>> 0 | source[offset + 1] << 8 >>> 0;
-}
-
-exports.readUInt16LE = readUInt16LE;
-
-function writeUInt16LE(destination, value, offset) {
-  destination[offset + 0] = value & 0b11111111;
-  value = value >>> 8;
-  destination[offset + 1] = value & 0b11111111;
-}
-
-exports.writeUInt16LE = writeUInt16LE;
-
-function readUInt32BE(source, offset) {
-  return source[offset] * 2 ** 24 + source[offset + 1] * 2 ** 16 + source[offset + 2] * 2 ** 8 + source[offset + 3];
-}
-
-exports.readUInt32BE = readUInt32BE;
-
-function writeUInt32BE(destination, value, offset) {
-  destination[offset + 3] = value;
-  value = value >>> 8;
-  destination[offset + 2] = value;
-  value = value >>> 8;
-  destination[offset + 1] = value;
-  value = value >>> 8;
-  destination[offset] = value;
-}
-
-exports.writeUInt32BE = writeUInt32BE;
-
-function readUInt32LE(source, offset) {
-  return source[offset + 0] << 0 >>> 0 | source[offset + 1] << 8 >>> 0 | source[offset + 2] << 16 >>> 0 | source[offset + 3] << 24 >>> 0;
-}
-
-exports.readUInt32LE = readUInt32LE;
-
-function writeUInt32LE(destination, value, offset) {
-  destination[offset + 0] = value & 0b11111111;
-  value = value >>> 8;
-  destination[offset + 1] = value & 0b11111111;
-  value = value >>> 8;
-  destination[offset + 2] = value & 0b11111111;
-  value = value >>> 8;
-  destination[offset + 3] = value & 0b11111111;
-}
-
-exports.writeUInt32LE = writeUInt32LE;
-
-function readUInt8(source, offset) {
-  return source[offset];
-}
-
-exports.readUInt8 = readUInt8;
-
-function writeUInt8(destination, value, offset) {
-  destination[offset] = value;
-}
-
-exports.writeUInt8 = writeUInt8;
-
-function readableToBuffer(readable) {
-  return streams.consumeReadable(readable, chunks => VSBuffer.concat(chunks));
-}
-
-exports.readableToBuffer = readableToBuffer;
-
-function bufferToReadable(buffer) {
-  return streams.toReadable(buffer);
-}
-
-exports.bufferToReadable = bufferToReadable;
-
-function streamToBuffer(stream) {
-  return streams.consumeStream(stream, chunks => VSBuffer.concat(chunks));
-}
-
-exports.streamToBuffer = streamToBuffer;
-
-async function bufferedStreamToBuffer(bufferedStream) {
-  if (bufferedStream.ended) {
-    return VSBuffer.concat(bufferedStream.buffer);
-  }
-
-  return VSBuffer.concat([// Include already read chunks...
-  ...bufferedStream.buffer, // ...and all additional chunks
-  await streamToBuffer(bufferedStream.stream)]);
-}
-
-exports.bufferedStreamToBuffer = bufferedStreamToBuffer;
-
-function bufferToStream(buffer) {
-  return streams.toStream(buffer, chunks => VSBuffer.concat(chunks));
-}
-
-exports.bufferToStream = bufferToStream;
-
-function streamToBufferReadableStream(stream) {
-  return streams.transform(stream, {
-    data: data => typeof data === 'string' ? VSBuffer.fromString(data) : VSBuffer.wrap(data)
-  }, chunks => VSBuffer.concat(chunks));
-}
-
-exports.streamToBufferReadableStream = streamToBufferReadableStream;
-
-function newWriteableBufferStream(options) {
-  return streams.newWriteableStream(chunks => VSBuffer.concat(chunks), options);
-}
-
-exports.newWriteableBufferStream = newWriteableBufferStream;

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

@@ -1,40 +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.Cache = void 0;
-
-const cancellation_1 = require("./cancellation");
-
-class Cache {
-  constructor(task) {
-    this.task = task;
-    this.result = null;
-  }
-
-  get() {
-    if (this.result) {
-      return this.result;
-    }
-
-    const cts = new cancellation_1.CancellationTokenSource();
-    const promise = this.task(cts.token);
-    this.result = {
-      promise,
-      dispose: () => {
-        this.result = null;
-        cts.cancel();
-        cts.dispose();
-      }
-    };
-    return this.result;
-  }
-
-}
-
-exports.Cache = Cache;

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

@@ -1,146 +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.CancellationTokenSource = exports.CancellationToken = void 0;
-
-const event_1 = require("./event");
-
-const shortcutEvent = Object.freeze(function (callback, context) {
-  const handle = setTimeout(callback.bind(context), 0);
-  return {
-    dispose() {
-      clearTimeout(handle);
-    }
-
-  };
-});
-var CancellationToken;
-
-(function (CancellationToken) {
-  function isCancellationToken(thing) {
-    if (thing === CancellationToken.None || thing === CancellationToken.Cancelled) {
-      return true;
-    }
-
-    if (thing instanceof MutableToken) {
-      return true;
-    }
-
-    if (!thing || typeof thing !== 'object') {
-      return false;
-    }
-
-    return typeof thing.isCancellationRequested === 'boolean' && typeof thing.onCancellationRequested === 'function';
-  }
-
-  CancellationToken.isCancellationToken = isCancellationToken;
-  CancellationToken.None = Object.freeze({
-    isCancellationRequested: false,
-    onCancellationRequested: event_1.Event.None
-  });
-  CancellationToken.Cancelled = Object.freeze({
-    isCancellationRequested: true,
-    onCancellationRequested: shortcutEvent
-  });
-})(CancellationToken = exports.CancellationToken || (exports.CancellationToken = {}));
-
-class MutableToken {
-  constructor() {
-    this._isCancelled = false;
-    this._emitter = null;
-  }
-
-  cancel() {
-    if (!this._isCancelled) {
-      this._isCancelled = true;
-
-      if (this._emitter) {
-        this._emitter.fire(undefined);
-
-        this.dispose();
-      }
-    }
-  }
-
-  get isCancellationRequested() {
-    return this._isCancelled;
-  }
-
-  get onCancellationRequested() {
-    if (this._isCancelled) {
-      return shortcutEvent;
-    }
-
-    if (!this._emitter) {
-      this._emitter = new event_1.Emitter();
-    }
-
-    return this._emitter.event;
-  }
-
-  dispose() {
-    if (this._emitter) {
-      this._emitter.dispose();
-
-      this._emitter = null;
-    }
-  }
-
-}
-
-class CancellationTokenSource {
-  constructor(parent) {
-    this._token = undefined;
-    this._parentListener = undefined;
-    this._parentListener = parent && parent.onCancellationRequested(this.cancel, this);
-  }
-
-  get token() {
-    if (!this._token) {
-      // be lazy and create the token only when
-      // actually needed
-      this._token = new MutableToken();
-    }
-
-    return this._token;
-  }
-
-  cancel() {
-    if (!this._token) {
-      // save an object by returning the default
-      // cancelled token when cancellation happens
-      // before someone asks for the token
-      this._token = CancellationToken.Cancelled;
-    } else if (this._token instanceof MutableToken) {
-      // actually cancel
-      this._token.cancel();
-    }
-  }
-
-  dispose(cancel = false) {
-    if (cancel) {
-      this.cancel();
-    }
-
-    if (this._parentListener) {
-      this._parentListener.dispose();
-    }
-
-    if (!this._token) {
-      // ensure to initialize with an empty token if we had none
-      this._token = CancellationToken.None;
-    } else if (this._token instanceof MutableToken) {
-      // actually dispose
-      this._token.dispose();
-    }
-  }
-
-}
-
-exports.CancellationTokenSource = CancellationTokenSource;

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

@@ -1,9 +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
-});

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

@@ -1,136 +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.matchesFuzzyCodiconAware = exports.parseCodicons = exports.codiconStartMarker = void 0;
-
-const filters_1 = require("./filters");
-
-const strings_1 = require("./strings");
-
-exports.codiconStartMarker = '$(';
-
-function parseCodicons(text) {
-  const firstCodiconIndex = text.indexOf(exports.codiconStartMarker);
-
-  if (firstCodiconIndex === -1) {
-    return {
-      text
-    }; // return early if the word does not include an codicon
-  }
-
-  return doParseCodicons(text, firstCodiconIndex);
-}
-
-exports.parseCodicons = parseCodicons;
-
-function doParseCodicons(text, firstCodiconIndex) {
-  const codiconOffsets = [];
-  let textWithoutCodicons = '';
-
-  function appendChars(chars) {
-    if (chars) {
-      textWithoutCodicons += chars;
-
-      for (const _ of chars) {
-        codiconOffsets.push(codiconsOffset); // make sure to fill in codicon offsets
-      }
-    }
-  }
-
-  let currentCodiconStart = -1;
-  let currentCodiconValue = '';
-  let codiconsOffset = 0;
-  let char;
-  let nextChar;
-  let offset = firstCodiconIndex;
-  const length = text.length; // Append all characters until the first codicon
-
-  appendChars(text.substr(0, firstCodiconIndex)); // example: $(file-symlink-file) my cool $(other-codicon) entry
-
-  while (offset < length) {
-    char = text[offset];
-    nextChar = text[offset + 1]; // beginning of codicon: some value $( <--
-
-    if (char === exports.codiconStartMarker[0] && nextChar === exports.codiconStartMarker[1]) {
-      currentCodiconStart = offset; // if we had a previous potential codicon value without
-      // the closing ')', it was actually not an codicon and
-      // so we have to add it to the actual value
-
-      appendChars(currentCodiconValue);
-      currentCodiconValue = exports.codiconStartMarker;
-      offset++; // jump over '('
-    } // end of codicon: some value $(some-codicon) <--
-    else if (char === ')' && currentCodiconStart !== -1) {
-        const currentCodiconLength = offset - currentCodiconStart + 1; // +1 to include the closing ')'
-
-        codiconsOffset += currentCodiconLength;
-        currentCodiconStart = -1;
-        currentCodiconValue = '';
-      } // within codicon
-      else if (currentCodiconStart !== -1) {
-          // Make sure this is a real codicon name
-          if (/^[a-z0-9\-]$/i.test(char)) {
-            currentCodiconValue += char;
-          } else {
-            // This is not a real codicon, treat it as text
-            appendChars(currentCodiconValue);
-            currentCodiconStart = -1;
-            currentCodiconValue = '';
-          }
-        } // any value outside of codicons
-        else {
-            appendChars(char);
-          }
-
-    offset++;
-  } // if we had a previous potential codicon value without
-  // the closing ')', it was actually not an codicon and
-  // so we have to add it to the actual value
-
-
-  appendChars(currentCodiconValue);
-  return {
-    text: textWithoutCodicons,
-    codiconOffsets
-  };
-}
-
-function matchesFuzzyCodiconAware(query, target, enableSeparateSubstringMatching = false) {
-  const {
-    text,
-    codiconOffsets
-  } = target; // Return early if there are no codicon markers in the word to match against
-
-  if (!codiconOffsets || codiconOffsets.length === 0) {
-    return filters_1.matchesFuzzy(query, text, enableSeparateSubstringMatching);
-  } // Trim the word to match against because it could have leading
-  // whitespace now if the word started with an codicon
-
-
-  const wordToMatchAgainstWithoutCodiconsTrimmed = strings_1.ltrim(text, ' ');
-  const leadingWhitespaceOffset = text.length - wordToMatchAgainstWithoutCodiconsTrimmed.length; // match on value without codicons
-
-  const matches = filters_1.matchesFuzzy(query, wordToMatchAgainstWithoutCodiconsTrimmed, enableSeparateSubstringMatching); // Map matches back to offsets with codicons and trimming
-
-  if (matches) {
-    for (const match of matches) {
-      const codiconOffset = codiconOffsets[match.start + leadingWhitespaceOffset]
-      /* codicon offsets at index */
-      + leadingWhitespaceOffset
-      /* overall leading whitespace offset */
-      ;
-      match.start += codiconOffset;
-      match.end += codiconOffset;
-    }
-  }
-
-  return matches;
-}
-
-exports.matchesFuzzyCodiconAware = matchesFuzzyCodiconAware;