custom-electron-titlebar 3.2.6 → 3.2.10

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

@@ -1,272 +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.applyEdits = exports.applyEdit = exports.withFormatting = exports.setProperty = exports.removeProperty = void 0;
-
-const json_1 = require("./json");
-
-const jsonFormatter_1 = require("./jsonFormatter");
-
-const arrays_1 = require("./arrays");
-
-function removeProperty(text, path, formattingOptions) {
-  return setProperty(text, path, undefined, formattingOptions);
-}
-
-exports.removeProperty = removeProperty;
-
-function setProperty(text, originalPath, value, formattingOptions, getInsertionIndex) {
-  const path = originalPath.slice();
-  const errors = [];
-  const root = json_1.parseTree(text, errors);
-  let parent = undefined;
-  let lastSegment = undefined;
-
-  while (path.length > 0) {
-    lastSegment = path.pop();
-    parent = json_1.findNodeAtLocation(root, path);
-
-    if (parent === undefined && value !== undefined) {
-      if (typeof lastSegment === 'string') {
-        value = {
-          [lastSegment]: value
-        };
-      } else {
-        value = [value];
-      }
-    } else {
-      break;
-    }
-  }
-
-  if (!parent) {
-    // empty document
-    if (value === undefined) {
-      // delete
-      throw new Error('Can not delete in empty document');
-    }
-
-    return withFormatting(text, {
-      offset: root ? root.offset : 0,
-      length: root ? root.length : 0,
-      content: JSON.stringify(value)
-    }, formattingOptions);
-  } else if (parent.type === 'object' && typeof lastSegment === 'string' && Array.isArray(parent.children)) {
-    const existing = json_1.findNodeAtLocation(parent, [lastSegment]);
-
-    if (existing !== undefined) {
-      if (value === undefined) {
-        // delete
-        if (!existing.parent) {
-          throw new Error('Malformed AST');
-        }
-
-        const propertyIndex = parent.children.indexOf(existing.parent);
-        let removeBegin;
-        let removeEnd = existing.parent.offset + existing.parent.length;
-
-        if (propertyIndex > 0) {
-          // remove the comma of the previous node
-          const previous = parent.children[propertyIndex - 1];
-          removeBegin = previous.offset + previous.length;
-        } else {
-          removeBegin = parent.offset + 1;
-
-          if (parent.children.length > 1) {
-            // remove the comma of the next node
-            const next = parent.children[1];
-            removeEnd = next.offset;
-          }
-        }
-
-        return withFormatting(text, {
-          offset: removeBegin,
-          length: removeEnd - removeBegin,
-          content: ''
-        }, formattingOptions);
-      } else {
-        // set value of existing property
-        return withFormatting(text, {
-          offset: existing.offset,
-          length: existing.length,
-          content: JSON.stringify(value)
-        }, formattingOptions);
-      }
-    } else {
-      if (value === undefined) {
-        // delete
-        return []; // property does not exist, nothing to do
-      }
-
-      const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
-      const index = getInsertionIndex ? getInsertionIndex(parent.children.map(p => p.children[0].value)) : parent.children.length;
-      let edit;
-
-      if (index > 0) {
-        const previous = parent.children[index - 1];
-        edit = {
-          offset: previous.offset + previous.length,
-          length: 0,
-          content: ',' + newProperty
-        };
-      } else if (parent.children.length === 0) {
-        edit = {
-          offset: parent.offset + 1,
-          length: 0,
-          content: newProperty
-        };
-      } else {
-        edit = {
-          offset: parent.offset + 1,
-          length: 0,
-          content: newProperty + ','
-        };
-      }
-
-      return withFormatting(text, edit, formattingOptions);
-    }
-  } else if (parent.type === 'array' && typeof lastSegment === 'number' && Array.isArray(parent.children)) {
-    if (value !== undefined) {
-      // Insert
-      const newProperty = `${JSON.stringify(value)}`;
-      let edit;
-
-      if (parent.children.length === 0 || lastSegment === 0) {
-        edit = {
-          offset: parent.offset + 1,
-          length: 0,
-          content: parent.children.length === 0 ? newProperty : newProperty + ','
-        };
-      } else {
-        const index = lastSegment === -1 || lastSegment > parent.children.length ? parent.children.length : lastSegment;
-        const previous = parent.children[index - 1];
-        edit = {
-          offset: previous.offset + previous.length,
-          length: 0,
-          content: ',' + newProperty
-        };
-      }
-
-      return withFormatting(text, edit, formattingOptions);
-    } else {
-      //Removal
-      const removalIndex = lastSegment;
-      const toRemove = parent.children[removalIndex];
-      let edit;
-
-      if (parent.children.length === 1) {
-        // only item
-        edit = {
-          offset: parent.offset + 1,
-          length: parent.length - 2,
-          content: ''
-        };
-      } else if (parent.children.length - 1 === removalIndex) {
-        // last item
-        const previous = parent.children[removalIndex - 1];
-        const offset = previous.offset + previous.length;
-        const parentEndOffset = parent.offset + parent.length;
-        edit = {
-          offset,
-          length: parentEndOffset - 2 - offset,
-          content: ''
-        };
-      } else {
-        edit = {
-          offset: toRemove.offset,
-          length: parent.children[removalIndex + 1].offset - toRemove.offset,
-          content: ''
-        };
-      }
-
-      return withFormatting(text, edit, formattingOptions);
-    }
-  } else {
-    throw new Error(`Can not add ${typeof lastSegment !== 'number' ? 'index' : 'property'} to parent of type ${parent.type}`);
-  }
-}
-
-exports.setProperty = setProperty;
-
-function withFormatting(text, edit, formattingOptions) {
-  // apply the edit
-  let newText = applyEdit(text, edit); // format the new text
-
-  let begin = edit.offset;
-  let end = edit.offset + edit.content.length;
-
-  if (edit.length === 0 || edit.content.length === 0) {
-    // insert or remove
-    while (begin > 0 && !jsonFormatter_1.isEOL(newText, begin - 1)) {
-      begin--;
-    }
-
-    while (end < newText.length && !jsonFormatter_1.isEOL(newText, end)) {
-      end++;
-    }
-  }
-
-  const edits = jsonFormatter_1.format(newText, {
-    offset: begin,
-    length: end - begin
-  }, formattingOptions); // apply the formatting edits and track the begin and end offsets of the changes
-
-  for (let i = edits.length - 1; i >= 0; i--) {
-    const curr = edits[i];
-    newText = applyEdit(newText, curr);
-    begin = Math.min(begin, curr.offset);
-    end = Math.max(end, curr.offset + curr.length);
-    end += curr.content.length - curr.length;
-  } // create a single edit with all changes
-
-
-  const editLength = text.length - (newText.length - end) - begin;
-  return [{
-    offset: begin,
-    length: editLength,
-    content: newText.substring(begin, end)
-  }];
-}
-
-exports.withFormatting = withFormatting;
-
-function applyEdit(text, edit) {
-  return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
-}
-
-exports.applyEdit = applyEdit;
-
-function applyEdits(text, edits) {
-  let sortedEdits = arrays_1.mergeSort(edits, (a, b) => {
-    const diff = a.offset - b.offset;
-
-    if (diff === 0) {
-      return a.length - b.length;
-    }
-
-    return diff;
-  });
-  let lastModifiedOffset = text.length;
-
-  for (let i = sortedEdits.length - 1; i >= 0; i--) {
-    let e = sortedEdits[i];
-
-    if (e.offset + e.length <= lastModifiedOffset) {
-      text = applyEdit(text, e);
-    } else {
-      throw new Error('Overlapping edit');
-    }
-
-    lastModifiedOffset = e.offset;
-  }
-
-  return text;
-}
-
-exports.applyEdits = applyEdits;

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

@@ -1,69 +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.getParseErrorMessage = void 0;
-/**
- * Extracted from json.ts to keep json nls free.
- */
-
-const nls_1 = require("../../nls");
-
-function getParseErrorMessage(errorCode) {
-  switch (errorCode) {
-    case 1
-    /* InvalidSymbol */
-    :
-      return nls_1.localize('error.invalidSymbol', 'Invalid symbol');
-
-    case 2
-    /* InvalidNumberFormat */
-    :
-      return nls_1.localize('error.invalidNumberFormat', 'Invalid number format');
-
-    case 3
-    /* PropertyNameExpected */
-    :
-      return nls_1.localize('error.propertyNameExpected', 'Property name expected');
-
-    case 4
-    /* ValueExpected */
-    :
-      return nls_1.localize('error.valueExpected', 'Value expected');
-
-    case 5
-    /* ColonExpected */
-    :
-      return nls_1.localize('error.colonExpected', 'Colon expected');
-
-    case 6
-    /* CommaExpected */
-    :
-      return nls_1.localize('error.commaExpected', 'Comma expected');
-
-    case 7
-    /* CloseBraceExpected */
-    :
-      return nls_1.localize('error.closeBraceExpected', 'Closing brace expected');
-
-    case 8
-    /* CloseBracketExpected */
-    :
-      return nls_1.localize('error.closeBracketExpected', 'Closing bracket expected');
-
-    case 9
-    /* EndOfFileExpected */
-    :
-      return nls_1.localize('error.endOfFileExpected', 'End of file expected');
-
-    default:
-      return '';
-  }
-}
-
-exports.getParseErrorMessage = getParseErrorMessage;

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

@@ -1,316 +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.isEOL = exports.getEOL = exports.format = void 0;
-
-const json_1 = require("./json");
-
-function format(documentText, range, options) {
-  let initialIndentLevel;
-  let formatText;
-  let formatTextStart;
-  let rangeStart;
-  let rangeEnd;
-
-  if (range) {
-    rangeStart = range.offset;
-    rangeEnd = rangeStart + range.length;
-    formatTextStart = rangeStart;
-
-    while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {
-      formatTextStart--;
-    }
-
-    let endOffset = rangeEnd;
-
-    while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {
-      endOffset++;
-    }
-
-    formatText = documentText.substring(formatTextStart, endOffset);
-    initialIndentLevel = computeIndentLevel(formatText, options);
-  } else {
-    formatText = documentText;
-    initialIndentLevel = 0;
-    formatTextStart = 0;
-    rangeStart = 0;
-    rangeEnd = documentText.length;
-  }
-
-  const eol = getEOL(options, documentText);
-  let lineBreak = false;
-  let indentLevel = 0;
-  let indentValue;
-
-  if (options.insertSpaces) {
-    indentValue = repeat(' ', options.tabSize || 4);
-  } else {
-    indentValue = '\t';
-  }
-
-  const scanner = json_1.createScanner(formatText, false);
-  let hasError = false;
-
-  function newLineAndIndent() {
-    return eol + repeat(indentValue, initialIndentLevel + indentLevel);
-  }
-
-  function scanNext() {
-    let token = scanner.scan();
-    lineBreak = false;
-
-    while (token === 15
-    /* Trivia */
-    || token === 14
-    /* LineBreakTrivia */
-    ) {
-      lineBreak = lineBreak || token === 14
-      /* LineBreakTrivia */
-      ;
-      token = scanner.scan();
-    }
-
-    hasError = token === 16
-    /* Unknown */
-    || scanner.getTokenError() !== 0
-    /* None */
-    ;
-    return token;
-  }
-
-  const editOperations = [];
-
-  function addEdit(text, startOffset, endOffset) {
-    if (!hasError && startOffset < rangeEnd && endOffset > rangeStart && documentText.substring(startOffset, endOffset) !== text) {
-      editOperations.push({
-        offset: startOffset,
-        length: endOffset - startOffset,
-        content: text
-      });
-    }
-  }
-
-  let firstToken = scanNext();
-
-  if (firstToken !== 17
-  /* EOF */
-  ) {
-      const firstTokenStart = scanner.getTokenOffset() + formatTextStart;
-      const initialIndent = repeat(indentValue, initialIndentLevel);
-      addEdit(initialIndent, formatTextStart, firstTokenStart);
-    }
-
-  while (firstToken !== 17
-  /* EOF */
-  ) {
-    let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
-    let secondToken = scanNext();
-    let replaceContent = '';
-
-    while (!lineBreak && (secondToken === 12
-    /* LineCommentTrivia */
-    || secondToken === 13
-    /* BlockCommentTrivia */
-    )) {
-      // comments on the same line: keep them on the same line, but ignore them otherwise
-      const commentTokenStart = scanner.getTokenOffset() + formatTextStart;
-      addEdit(' ', firstTokenEnd, commentTokenStart);
-      firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
-      replaceContent = secondToken === 12
-      /* LineCommentTrivia */
-      ? newLineAndIndent() : '';
-      secondToken = scanNext();
-    }
-
-    if (secondToken === 2
-    /* CloseBraceToken */
-    ) {
-        if (firstToken !== 1
-        /* OpenBraceToken */
-        ) {
-            indentLevel--;
-            replaceContent = newLineAndIndent();
-          }
-      } else if (secondToken === 4
-    /* CloseBracketToken */
-    ) {
-        if (firstToken !== 3
-        /* OpenBracketToken */
-        ) {
-            indentLevel--;
-            replaceContent = newLineAndIndent();
-          }
-      } else {
-      switch (firstToken) {
-        case 3
-        /* OpenBracketToken */
-        :
-        case 1
-        /* OpenBraceToken */
-        :
-          indentLevel++;
-          replaceContent = newLineAndIndent();
-          break;
-
-        case 5
-        /* CommaToken */
-        :
-        case 12
-        /* LineCommentTrivia */
-        :
-          replaceContent = newLineAndIndent();
-          break;
-
-        case 13
-        /* BlockCommentTrivia */
-        :
-          if (lineBreak) {
-            replaceContent = newLineAndIndent();
-          } else {
-            // symbol following comment on the same line: keep on same line, separate with ' '
-            replaceContent = ' ';
-          }
-
-          break;
-
-        case 6
-        /* ColonToken */
-        :
-          replaceContent = ' ';
-          break;
-
-        case 10
-        /* StringLiteral */
-        :
-          if (secondToken === 6
-          /* ColonToken */
-          ) {
-              replaceContent = '';
-              break;
-            }
-
-        // fall through
-
-        case 7
-        /* NullKeyword */
-        :
-        case 8
-        /* TrueKeyword */
-        :
-        case 9
-        /* FalseKeyword */
-        :
-        case 11
-        /* NumericLiteral */
-        :
-        case 2
-        /* CloseBraceToken */
-        :
-        case 4
-        /* CloseBracketToken */
-        :
-          if (secondToken === 12
-          /* LineCommentTrivia */
-          || secondToken === 13
-          /* BlockCommentTrivia */
-          ) {
-              replaceContent = ' ';
-            } else if (secondToken !== 5
-          /* CommaToken */
-          && secondToken !== 17
-          /* EOF */
-          ) {
-              hasError = true;
-            }
-
-          break;
-
-        case 16
-        /* Unknown */
-        :
-          hasError = true;
-          break;
-      }
-
-      if (lineBreak && (secondToken === 12
-      /* LineCommentTrivia */
-      || secondToken === 13
-      /* BlockCommentTrivia */
-      )) {
-        replaceContent = newLineAndIndent();
-      }
-    }
-
-    const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
-    addEdit(replaceContent, firstTokenEnd, secondTokenStart);
-    firstToken = secondToken;
-  }
-
-  return editOperations;
-}
-
-exports.format = format;
-
-function repeat(s, count) {
-  let result = '';
-
-  for (let i = 0; i < count; i++) {
-    result += s;
-  }
-
-  return result;
-}
-
-function computeIndentLevel(content, options) {
-  let i = 0;
-  let nChars = 0;
-  const tabSize = options.tabSize || 4;
-
-  while (i < content.length) {
-    const ch = content.charAt(i);
-
-    if (ch === ' ') {
-      nChars++;
-    } else if (ch === '\t') {
-      nChars += tabSize;
-    } else {
-      break;
-    }
-
-    i++;
-  }
-
-  return Math.floor(nChars / tabSize);
-}
-
-function getEOL(options, text) {
-  for (let i = 0; i < text.length; i++) {
-    const ch = text.charAt(i);
-
-    if (ch === '\r') {
-      if (i + 1 < text.length && text.charAt(i + 1) === '\n') {
-        return '\r\n';
-      }
-
-      return '\r';
-    } else if (ch === '\n') {
-      return '\n';
-    }
-  }
-
-  return options && options.eol || '\n';
-}
-
-exports.getEOL = getEOL;
-
-function isEOL(text, offset) {
-  return '\r\n'.indexOf(text.charAt(offset)) !== -1;
-}
-
-exports.isEOL = isEOL;

package/lib/vs/base/common/jsonSchema.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
-});