custom-electron-titlebar 3.2.6 → 3.2.10

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

@@ -1,359 +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.StringSHA1 = exports.Hasher = exports.stringHash = exports.doHash = exports.hash = void 0;
-
-const strings = require("./strings");
-/**
- * Return a hash value for an object.
- */
-
-
-function hash(obj) {
-  return doHash(obj, 0);
-}
-
-exports.hash = hash;
-
-function doHash(obj, hashVal) {
-  switch (typeof obj) {
-    case 'object':
-      if (obj === null) {
-        return numberHash(349, hashVal);
-      } else if (Array.isArray(obj)) {
-        return arrayHash(obj, hashVal);
-      }
-
-      return objectHash(obj, hashVal);
-
-    case 'string':
-      return stringHash(obj, hashVal);
-
-    case 'boolean':
-      return booleanHash(obj, hashVal);
-
-    case 'number':
-      return numberHash(obj, hashVal);
-
-    case 'undefined':
-      return numberHash(937, hashVal);
-
-    default:
-      return numberHash(617, hashVal);
-  }
-}
-
-exports.doHash = doHash;
-
-function numberHash(val, initialHashVal) {
-  return (initialHashVal << 5) - initialHashVal + val | 0; // hashVal * 31 + ch, keep as int32
-}
-
-function booleanHash(b, initialHashVal) {
-  return numberHash(b ? 433 : 863, initialHashVal);
-}
-
-function stringHash(s, hashVal) {
-  hashVal = numberHash(149417, hashVal);
-
-  for (let i = 0, length = s.length; i < length; i++) {
-    hashVal = numberHash(s.charCodeAt(i), hashVal);
-  }
-
-  return hashVal;
-}
-
-exports.stringHash = stringHash;
-
-function arrayHash(arr, initialHashVal) {
-  initialHashVal = numberHash(104579, initialHashVal);
-  return arr.reduce((hashVal, item) => doHash(item, hashVal), initialHashVal);
-}
-
-function objectHash(obj, initialHashVal) {
-  initialHashVal = numberHash(181387, initialHashVal);
-  return Object.keys(obj).sort().reduce((hashVal, key) => {
-    hashVal = stringHash(key, hashVal);
-    return doHash(obj[key], hashVal);
-  }, initialHashVal);
-}
-
-class Hasher {
-  constructor() {
-    this._value = 0;
-  }
-
-  get value() {
-    return this._value;
-  }
-
-  hash(obj) {
-    this._value = doHash(obj, this._value);
-    return this._value;
-  }
-
-}
-
-exports.Hasher = Hasher;
-
-function leftRotate(value, bits, totalBits = 32) {
-  // delta + bits = totalBits
-  const delta = totalBits - bits; // All ones, expect `delta` zeros aligned to the right
-
-  const mask = ~((1 << delta) - 1); // Join (value left-shifted `bits` bits) with (masked value right-shifted `delta` bits)
-
-  return (value << bits | (mask & value) >>> delta) >>> 0;
-}
-
-function fill(dest, index = 0, count = dest.byteLength, value = 0) {
-  for (let i = 0; i < count; i++) {
-    dest[index + i] = value;
-  }
-}
-
-function leftPad(value, length, char = '0') {
-  while (value.length < length) {
-    value = char + value;
-  }
-
-  return value;
-}
-
-function toHexString(value, bitsize = 32) {
-  return leftPad((value >>> 0).toString(16), bitsize / 4);
-}
-/**
- * A SHA1 implementation that works with strings and does not allocate.
- */
-
-
-class StringSHA1 {
-  constructor() {
-    this._h0 = 0x67452301;
-    this._h1 = 0xEFCDAB89;
-    this._h2 = 0x98BADCFE;
-    this._h3 = 0x10325476;
-    this._h4 = 0xC3D2E1F0;
-    this._buff = new Uint8Array(64
-    /* BLOCK_SIZE */
-    + 3
-    /* to fit any utf-8 */
-    );
-    this._buffDV = new DataView(this._buff.buffer);
-    this._buffLen = 0;
-    this._totalLen = 0;
-    this._leftoverHighSurrogate = 0;
-    this._finished = false;
-  }
-
-  update(str) {
-    const strLen = str.length;
-
-    if (strLen === 0) {
-      return;
-    }
-
-    const buff = this._buff;
-    let buffLen = this._buffLen;
-    let leftoverHighSurrogate = this._leftoverHighSurrogate;
-    let charCode;
-    let offset;
-
-    if (leftoverHighSurrogate !== 0) {
-      charCode = leftoverHighSurrogate;
-      offset = -1;
-      leftoverHighSurrogate = 0;
-    } else {
-      charCode = str.charCodeAt(0);
-      offset = 0;
-    }
-
-    while (true) {
-      let codePoint = charCode;
-
-      if (strings.isHighSurrogate(charCode)) {
-        if (offset + 1 < strLen) {
-          const nextCharCode = str.charCodeAt(offset + 1);
-
-          if (strings.isLowSurrogate(nextCharCode)) {
-            offset++;
-            codePoint = strings.computeCodePoint(charCode, nextCharCode);
-          } else {
-            // illegal => unicode replacement character
-            codePoint = 65533
-            /* UNICODE_REPLACEMENT */
-            ;
-          }
-        } else {
-          // last character is a surrogate pair
-          leftoverHighSurrogate = charCode;
-          break;
-        }
-      } else if (strings.isLowSurrogate(charCode)) {
-        // illegal => unicode replacement character
-        codePoint = 65533
-        /* UNICODE_REPLACEMENT */
-        ;
-      }
-
-      buffLen = this._push(buff, buffLen, codePoint);
-      offset++;
-
-      if (offset < strLen) {
-        charCode = str.charCodeAt(offset);
-      } else {
-        break;
-      }
-    }
-
-    this._buffLen = buffLen;
-    this._leftoverHighSurrogate = leftoverHighSurrogate;
-  }
-
-  _push(buff, buffLen, codePoint) {
-    if (codePoint < 0x0080) {
-      buff[buffLen++] = codePoint;
-    } else if (codePoint < 0x0800) {
-      buff[buffLen++] = 0b11000000 | (codePoint & 0b00000000000000000000011111000000) >>> 6;
-      buff[buffLen++] = 0b10000000 | (codePoint & 0b00000000000000000000000000111111) >>> 0;
-    } else if (codePoint < 0x10000) {
-      buff[buffLen++] = 0b11100000 | (codePoint & 0b00000000000000001111000000000000) >>> 12;
-      buff[buffLen++] = 0b10000000 | (codePoint & 0b00000000000000000000111111000000) >>> 6;
-      buff[buffLen++] = 0b10000000 | (codePoint & 0b00000000000000000000000000111111) >>> 0;
-    } else {
-      buff[buffLen++] = 0b11110000 | (codePoint & 0b00000000000111000000000000000000) >>> 18;
-      buff[buffLen++] = 0b10000000 | (codePoint & 0b00000000000000111111000000000000) >>> 12;
-      buff[buffLen++] = 0b10000000 | (codePoint & 0b00000000000000000000111111000000) >>> 6;
-      buff[buffLen++] = 0b10000000 | (codePoint & 0b00000000000000000000000000111111) >>> 0;
-    }
-
-    if (buffLen >= 64
-    /* BLOCK_SIZE */
-    ) {
-        this._step();
-
-        buffLen -= 64
-        /* BLOCK_SIZE */
-        ;
-        this._totalLen += 64
-        /* BLOCK_SIZE */
-        ; // take last 3 in case of UTF8 overflow
-
-        buff[0] = buff[64
-        /* BLOCK_SIZE */
-        + 0];
-        buff[1] = buff[64
-        /* BLOCK_SIZE */
-        + 1];
-        buff[2] = buff[64
-        /* BLOCK_SIZE */
-        + 2];
-      }
-
-    return buffLen;
-  }
-
-  digest() {
-    if (!this._finished) {
-      this._finished = true;
-
-      if (this._leftoverHighSurrogate) {
-        // illegal => unicode replacement character
-        this._leftoverHighSurrogate = 0;
-        this._buffLen = this._push(this._buff, this._buffLen, 65533
-        /* UNICODE_REPLACEMENT */
-        );
-      }
-
-      this._totalLen += this._buffLen;
-
-      this._wrapUp();
-    }
-
-    return toHexString(this._h0) + toHexString(this._h1) + toHexString(this._h2) + toHexString(this._h3) + toHexString(this._h4);
-  }
-
-  _wrapUp() {
-    this._buff[this._buffLen++] = 0x80;
-    fill(this._buff, this._buffLen);
-
-    if (this._buffLen > 56) {
-      this._step();
-
-      fill(this._buff);
-    } // this will fit because the mantissa can cover up to 52 bits
-
-
-    const ml = 8 * this._totalLen;
-
-    this._buffDV.setUint32(56, Math.floor(ml / 4294967296), false);
-
-    this._buffDV.setUint32(60, ml % 4294967296, false);
-
-    this._step();
-  }
-
-  _step() {
-    const bigBlock32 = StringSHA1._bigBlock32;
-    const data = this._buffDV;
-
-    for (let j = 0; j < 64
-    /* 16*4 */
-    ; j += 4) {
-      bigBlock32.setUint32(j, data.getUint32(j, false), false);
-    }
-
-    for (let j = 64; j < 320
-    /* 80*4 */
-    ; j += 4) {
-      bigBlock32.setUint32(j, leftRotate(bigBlock32.getUint32(j - 12, false) ^ bigBlock32.getUint32(j - 32, false) ^ bigBlock32.getUint32(j - 56, false) ^ bigBlock32.getUint32(j - 64, false), 1), false);
-    }
-
-    let a = this._h0;
-    let b = this._h1;
-    let c = this._h2;
-    let d = this._h3;
-    let e = this._h4;
-    let f, k;
-    let temp;
-
-    for (let j = 0; j < 80; j++) {
-      if (j < 20) {
-        f = b & c | ~b & d;
-        k = 0x5A827999;
-      } else if (j < 40) {
-        f = b ^ c ^ d;
-        k = 0x6ED9EBA1;
-      } else if (j < 60) {
-        f = b & c | b & d | c & d;
-        k = 0x8F1BBCDC;
-      } else {
-        f = b ^ c ^ d;
-        k = 0xCA62C1D6;
-      }
-
-      temp = leftRotate(a, 5) + f + e + k + bigBlock32.getUint32(j * 4, false) & 0xffffffff;
-      e = d;
-      d = c;
-      c = leftRotate(b, 30);
-      b = a;
-      a = temp;
-    }
-
-    this._h0 = this._h0 + a & 0xffffffff;
-    this._h1 = this._h1 + b & 0xffffffff;
-    this._h2 = this._h2 + c & 0xffffffff;
-    this._h3 = this._h3 + d & 0xffffffff;
-    this._h4 = this._h4 + e & 0xffffffff;
-  }
-
-}
-
-exports.StringSHA1 = StringSHA1;
-StringSHA1._bigBlock32 = new DataView(new ArrayBuffer(320)); // 80 * 4 = 320

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

@@ -1,116 +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.HistoryNavigator = void 0;
-
-const navigator_1 = require("./navigator");
-
-class HistoryNavigator {
-  constructor(history = [], limit = 10) {
-    this._initialize(history);
-
-    this._limit = limit;
-
-    this._onChange();
-  }
-
-  getHistory() {
-    return this._elements;
-  }
-
-  add(t) {
-    this._history.delete(t);
-
-    this._history.add(t);
-
-    this._onChange();
-  }
-
-  next() {
-    if (this._currentPosition() !== this._elements.length - 1) {
-      return this._navigator.next();
-    }
-
-    return null;
-  }
-
-  previous() {
-    if (this._currentPosition() !== 0) {
-      return this._navigator.previous();
-    }
-
-    return null;
-  }
-
-  current() {
-    return this._navigator.current();
-  }
-
-  first() {
-    return this._navigator.first();
-  }
-
-  last() {
-    return this._navigator.last();
-  }
-
-  has(t) {
-    return this._history.has(t);
-  }
-
-  clear() {
-    this._initialize([]);
-
-    this._onChange();
-  }
-
-  _onChange() {
-    this._reduceToLimit();
-
-    const elements = this._elements;
-    this._navigator = new navigator_1.ArrayNavigator(elements, 0, elements.length, elements.length);
-  }
-
-  _reduceToLimit() {
-    const data = this._elements;
-
-    if (data.length > this._limit) {
-      this._initialize(data.slice(data.length - this._limit));
-    }
-  }
-
-  _currentPosition() {
-    const currentElement = this._navigator.current();
-
-    if (!currentElement) {
-      return -1;
-    }
-
-    return this._elements.indexOf(currentElement);
-  }
-
-  _initialize(history) {
-    this._history = new Set();
-
-    for (const entry of history) {
-      this._history.add(entry);
-    }
-  }
-
-  get _elements() {
-    const elements = [];
-
-    this._history.forEach(e => elements.push(e));
-
-    return elements;
-  }
-
-}
-
-exports.HistoryNavigator = HistoryNavigator;

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

@@ -1,162 +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.parseHrefAndDimensions = exports.removeMarkdownEscapes = exports.markedStringsEquals = exports.isMarkdownString = exports.isEmptyMarkdownString = exports.MarkdownString = void 0;
-
-const arrays_1 = require("./arrays");
-
-const codicons_1 = require("./codicons");
-
-const errors_1 = require("./errors");
-
-class MarkdownString {
-  constructor(_value = '', isTrustedOrOptions = false) {
-    var _a, _b;
-
-    this._value = _value;
-
-    if (typeof this._value !== 'string') {
-      throw errors_1.illegalArgument('value');
-    }
-
-    if (typeof isTrustedOrOptions === 'boolean') {
-      this._isTrusted = isTrustedOrOptions;
-      this._supportThemeIcons = false;
-    } else {
-      this._isTrusted = (_a = isTrustedOrOptions.isTrusted) !== null && _a !== void 0 ? _a : false;
-      this._supportThemeIcons = (_b = isTrustedOrOptions.supportThemeIcons) !== null && _b !== void 0 ? _b : false;
-    }
-  }
-
-  get value() {
-    return this._value;
-  }
-
-  get isTrusted() {
-    return this._isTrusted;
-  }
-
-  get supportThemeIcons() {
-    return this._supportThemeIcons;
-  }
-
-  appendText(value) {
-    // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash
-    this._value += (this._supportThemeIcons ? codicons_1.escapeCodicons(value) : value).replace(/[\\`*_{}[\]()#+\-.!]/g, '\\$&').replace(/\n/g, '\n\n');
-    return this;
-  }
-
-  appendMarkdown(value) {
-    this._value += value;
-    return this;
-  }
-
-  appendCodeblock(langId, code) {
-    this._value += '\n```';
-    this._value += langId;
-    this._value += '\n';
-    this._value += code;
-    this._value += '\n```\n';
-    return this;
-  }
-
-}
-
-exports.MarkdownString = MarkdownString;
-
-function isEmptyMarkdownString(oneOrMany) {
-  if (isMarkdownString(oneOrMany)) {
-    return !oneOrMany.value;
-  } else if (Array.isArray(oneOrMany)) {
-    return oneOrMany.every(isEmptyMarkdownString);
-  } else {
-    return true;
-  }
-}
-
-exports.isEmptyMarkdownString = isEmptyMarkdownString;
-
-function isMarkdownString(thing) {
-  if (thing instanceof MarkdownString) {
-    return true;
-  } else if (thing && typeof thing === 'object') {
-    return typeof thing.value === 'string' && (typeof thing.isTrusted === 'boolean' || thing.isTrusted === undefined) && (typeof thing.supportThemeIcons === 'boolean' || thing.supportThemeIcons === undefined);
-  }
-
-  return false;
-}
-
-exports.isMarkdownString = isMarkdownString;
-
-function markedStringsEquals(a, b) {
-  if (!a && !b) {
-    return true;
-  } else if (!a || !b) {
-    return false;
-  } else if (Array.isArray(a) && Array.isArray(b)) {
-    return arrays_1.equals(a, b, markdownStringEqual);
-  } else if (isMarkdownString(a) && isMarkdownString(b)) {
-    return markdownStringEqual(a, b);
-  } else {
-    return false;
-  }
-}
-
-exports.markedStringsEquals = markedStringsEquals;
-
-function markdownStringEqual(a, b) {
-  if (a === b) {
-    return true;
-  } else if (!a || !b) {
-    return false;
-  } else {
-    return a.value === b.value && a.isTrusted === b.isTrusted && a.supportThemeIcons === b.supportThemeIcons;
-  }
-}
-
-function removeMarkdownEscapes(text) {
-  if (!text) {
-    return text;
-  }
-
-  return text.replace(/\\([\\`*_{}[\]()#+\-.!])/g, '$1');
-}
-
-exports.removeMarkdownEscapes = removeMarkdownEscapes;
-
-function parseHrefAndDimensions(href) {
-  const dimensions = [];
-  const splitted = href.split('|').map(s => s.trim());
-  href = splitted[0];
-  const parameters = splitted[1];
-
-  if (parameters) {
-    const heightFromParams = /height=(\d+)/.exec(parameters);
-    const widthFromParams = /width=(\d+)/.exec(parameters);
-    const height = heightFromParams ? heightFromParams[1] : '';
-    const width = widthFromParams ? widthFromParams[1] : '';
-    const widthIsFinite = isFinite(parseInt(width));
-    const heightIsFinite = isFinite(parseInt(height));
-
-    if (widthIsFinite) {
-      dimensions.push(`width="${width}"`);
-    }
-
-    if (heightIsFinite) {
-      dimensions.push(`height="${height}"`);
-    }
-  }
-
-  return {
-    href,
-    dimensions
-  };
-}
-
-exports.parseHrefAndDimensions = parseHrefAndDimensions;

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

@@ -1,25 +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.defaultGenerator = exports.IdGenerator = void 0;
-
-class IdGenerator {
-  constructor(prefix) {
-    this._prefix = prefix;
-    this._lastId = 0;
-  }
-
-  nextId() {
-    return this._prefix + ++this._lastId;
-  }
-
-}
-
-exports.IdGenerator = IdGenerator;
-exports.defaultGenerator = new IdGenerator('id#');