@codingame/monaco-vscode-configuration-editing-default-extension 1.82.6 → 1.83.0-next.0

package/configurationEditingMain.js

@@ -7,6 +7,9 @@
 "use strict";
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "ParseErrorCode": () => (/* binding */ ParseErrorCode),
+/* harmony export */   "ScanError": () => (/* binding */ ScanError),
+/* harmony export */   "SyntaxKind": () => (/* binding */ SyntaxKind),
 /* harmony export */   "applyEdits": () => (/* binding */ applyEdits),
 /* harmony export */   "createScanner": () => (/* binding */ createScanner),
 /* harmony export */   "findNodeAtLocation": () => (/* binding */ findNodeAtLocation),
@@ -39,84 +42,130 @@ __webpack_require__.r(__webpack_exports__);
  * Creates a JSON scanner on the given text.
  * If ignoreTrivia is set, whitespaces or comments are ignored.
  */
-var createScanner = _impl_scanner__WEBPACK_IMPORTED_MODULE_2__.createScanner;
+const createScanner = _impl_scanner__WEBPACK_IMPORTED_MODULE_2__.createScanner;
+var ScanError;
+(function (ScanError) {
+    ScanError[ScanError["None"] = 0] = "None";
+    ScanError[ScanError["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+    ScanError[ScanError["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+    ScanError[ScanError["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+    ScanError[ScanError["InvalidUnicode"] = 4] = "InvalidUnicode";
+    ScanError[ScanError["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+    ScanError[ScanError["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function (SyntaxKind) {
+    SyntaxKind[SyntaxKind["OpenBraceToken"] = 1] = "OpenBraceToken";
+    SyntaxKind[SyntaxKind["CloseBraceToken"] = 2] = "CloseBraceToken";
+    SyntaxKind[SyntaxKind["OpenBracketToken"] = 3] = "OpenBracketToken";
+    SyntaxKind[SyntaxKind["CloseBracketToken"] = 4] = "CloseBracketToken";
+    SyntaxKind[SyntaxKind["CommaToken"] = 5] = "CommaToken";
+    SyntaxKind[SyntaxKind["ColonToken"] = 6] = "ColonToken";
+    SyntaxKind[SyntaxKind["NullKeyword"] = 7] = "NullKeyword";
+    SyntaxKind[SyntaxKind["TrueKeyword"] = 8] = "TrueKeyword";
+    SyntaxKind[SyntaxKind["FalseKeyword"] = 9] = "FalseKeyword";
+    SyntaxKind[SyntaxKind["StringLiteral"] = 10] = "StringLiteral";
+    SyntaxKind[SyntaxKind["NumericLiteral"] = 11] = "NumericLiteral";
+    SyntaxKind[SyntaxKind["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+    SyntaxKind[SyntaxKind["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+    SyntaxKind[SyntaxKind["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+    SyntaxKind[SyntaxKind["Trivia"] = 15] = "Trivia";
+    SyntaxKind[SyntaxKind["Unknown"] = 16] = "Unknown";
+    SyntaxKind[SyntaxKind["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
 /**
  * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.
  */
-var getLocation = _impl_parser__WEBPACK_IMPORTED_MODULE_3__.getLocation;
+const getLocation = _impl_parser__WEBPACK_IMPORTED_MODULE_3__.getLocation;
 /**
  * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
  * Therefore, always check the errors list to find out if the input was valid.
  */
-var parse = _impl_parser__WEBPACK_IMPORTED_MODULE_3__.parse;
+const parse = _impl_parser__WEBPACK_IMPORTED_MODULE_3__.parse;
 /**
  * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
  */
-var parseTree = _impl_parser__WEBPACK_IMPORTED_MODULE_3__.parseTree;
+const parseTree = _impl_parser__WEBPACK_IMPORTED_MODULE_3__.parseTree;
 /**
  * Finds the node at the given path in a JSON DOM.
  */
-var findNodeAtLocation = _impl_parser__WEBPACK_IMPORTED_MODULE_3__.findNodeAtLocation;
+const findNodeAtLocation = _impl_parser__WEBPACK_IMPORTED_MODULE_3__.findNodeAtLocation;
 /**
  * Finds the innermost node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.
  */
-var findNodeAtOffset = _impl_parser__WEBPACK_IMPORTED_MODULE_3__.findNodeAtOffset;
+const findNodeAtOffset = _impl_parser__WEBPACK_IMPORTED_MODULE_3__.findNodeAtOffset;
 /**
  * Gets the JSON path of the given JSON DOM node
  */
-var getNodePath = _impl_parser__WEBPACK_IMPORTED_MODULE_3__.getNodePath;
+const getNodePath = _impl_parser__WEBPACK_IMPORTED_MODULE_3__.getNodePath;
 /**
  * Evaluates the JavaScript object of the given JSON DOM node
  */
-var getNodeValue = _impl_parser__WEBPACK_IMPORTED_MODULE_3__.getNodeValue;
+const getNodeValue = _impl_parser__WEBPACK_IMPORTED_MODULE_3__.getNodeValue;
 /**
  * Parses the given text and invokes the visitor functions for each object, array and literal reached.
  */
-var visit = _impl_parser__WEBPACK_IMPORTED_MODULE_3__.visit;
+const visit = _impl_parser__WEBPACK_IMPORTED_MODULE_3__.visit;
 /**
  * Takes JSON with JavaScript-style comments and remove
  * them. Optionally replaces every none-newline character
  * of comments with a replaceCharacter
  */
-var stripComments = _impl_parser__WEBPACK_IMPORTED_MODULE_3__.stripComments;
+const stripComments = _impl_parser__WEBPACK_IMPORTED_MODULE_3__.stripComments;
+var ParseErrorCode;
+(function (ParseErrorCode) {
+    ParseErrorCode[ParseErrorCode["InvalidSymbol"] = 1] = "InvalidSymbol";
+    ParseErrorCode[ParseErrorCode["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+    ParseErrorCode[ParseErrorCode["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+    ParseErrorCode[ParseErrorCode["ValueExpected"] = 4] = "ValueExpected";
+    ParseErrorCode[ParseErrorCode["ColonExpected"] = 5] = "ColonExpected";
+    ParseErrorCode[ParseErrorCode["CommaExpected"] = 6] = "CommaExpected";
+    ParseErrorCode[ParseErrorCode["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+    ParseErrorCode[ParseErrorCode["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+    ParseErrorCode[ParseErrorCode["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+    ParseErrorCode[ParseErrorCode["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+    ParseErrorCode[ParseErrorCode["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+    ParseErrorCode[ParseErrorCode["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+    ParseErrorCode[ParseErrorCode["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+    ParseErrorCode[ParseErrorCode["InvalidUnicode"] = 14] = "InvalidUnicode";
+    ParseErrorCode[ParseErrorCode["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+    ParseErrorCode[ParseErrorCode["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
 function printParseErrorCode(code) {
     switch (code) {
-        case 1 /* InvalidSymbol */: return 'InvalidSymbol';
-        case 2 /* InvalidNumberFormat */: return 'InvalidNumberFormat';
-        case 3 /* PropertyNameExpected */: return 'PropertyNameExpected';
-        case 4 /* ValueExpected */: return 'ValueExpected';
-        case 5 /* ColonExpected */: return 'ColonExpected';
-        case 6 /* CommaExpected */: return 'CommaExpected';
-        case 7 /* CloseBraceExpected */: return 'CloseBraceExpected';
-        case 8 /* CloseBracketExpected */: return 'CloseBracketExpected';
-        case 9 /* EndOfFileExpected */: return 'EndOfFileExpected';
-        case 10 /* InvalidCommentToken */: return 'InvalidCommentToken';
-        case 11 /* UnexpectedEndOfComment */: return 'UnexpectedEndOfComment';
-        case 12 /* UnexpectedEndOfString */: return 'UnexpectedEndOfString';
-        case 13 /* UnexpectedEndOfNumber */: return 'UnexpectedEndOfNumber';
-        case 14 /* InvalidUnicode */: return 'InvalidUnicode';
-        case 15 /* InvalidEscapeCharacter */: return 'InvalidEscapeCharacter';
-        case 16 /* InvalidCharacter */: return 'InvalidCharacter';
+        case 1 /* ParseErrorCode.InvalidSymbol */: return 'InvalidSymbol';
+        case 2 /* ParseErrorCode.InvalidNumberFormat */: return 'InvalidNumberFormat';
+        case 3 /* ParseErrorCode.PropertyNameExpected */: return 'PropertyNameExpected';
+        case 4 /* ParseErrorCode.ValueExpected */: return 'ValueExpected';
+        case 5 /* ParseErrorCode.ColonExpected */: return 'ColonExpected';
+        case 6 /* ParseErrorCode.CommaExpected */: return 'CommaExpected';
+        case 7 /* ParseErrorCode.CloseBraceExpected */: return 'CloseBraceExpected';
+        case 8 /* ParseErrorCode.CloseBracketExpected */: return 'CloseBracketExpected';
+        case 9 /* ParseErrorCode.EndOfFileExpected */: return 'EndOfFileExpected';
+        case 10 /* ParseErrorCode.InvalidCommentToken */: return 'InvalidCommentToken';
+        case 11 /* ParseErrorCode.UnexpectedEndOfComment */: return 'UnexpectedEndOfComment';
+        case 12 /* ParseErrorCode.UnexpectedEndOfString */: return 'UnexpectedEndOfString';
+        case 13 /* ParseErrorCode.UnexpectedEndOfNumber */: return 'UnexpectedEndOfNumber';
+        case 14 /* ParseErrorCode.InvalidUnicode */: return 'InvalidUnicode';
+        case 15 /* ParseErrorCode.InvalidEscapeCharacter */: return 'InvalidEscapeCharacter';
+        case 16 /* ParseErrorCode.InvalidCharacter */: return 'InvalidCharacter';
     }
     return '<unknown ParseErrorCode>';
 }
 /**
- * Computes the edits needed to format a JSON document.
+ * Computes the edit operations needed to format a JSON document.
  *
  * @param documentText The input text
  * @param range The range to format or `undefined` to format the full content
  * @param options The formatting options
- * @returns A list of edit operations describing the formatting changes to the original document. Edits can be either inserts, replacements or
- * removals of text segments. All offsets refer to the original state of the document. No two edits must change or remove the same range of
- * text in the original document. However, multiple edits can have
- * the same offset, for example multiple inserts, or an insert followed by a remove or replace. The order in the array defines which edit is applied first.
- * To apply edits to an input, you can use `applyEdits`.
+ * @returns The edit operations describing the formatting changes to the original document following the format described in {@linkcode EditResult}.
+ * To apply the edit operations to the input, use {@linkcode applyEdits}.
  */
 function format(documentText, range, options) {
     return _impl_format__WEBPACK_IMPORTED_MODULE_0__.format(documentText, range, options);
 }
 /**
- * Computes the edits needed to modify a value in the JSON document.
+ * Computes the edit operations needed to modify a value in the JSON document.
  *
  * @param documentText The input text
  * @param path The path of the value to change. The path represents either to the document root, a property or an array item.
@@ -124,21 +173,37 @@ function format(documentText, range, options) {
  * @param value The new value for the specified property or item. If the value is undefined,
  * the property or item will be removed.
  * @param options Options
- * @returns A list of edit operations describing the formatting changes to the original document. Edits can be either inserts, replacements or
- * removals of text segments. All offsets refer to the original state of the document. No two edits must change or remove the same range of
- * text in the original document. However, multiple edits can have
- * the same offset, for example multiple inserts, or an insert followed by a remove or replace. The order in the array defines which edit is applied first.
- * To apply edits to an input, you can use `applyEdits`.
+ * @returns The edit operations describing the changes to the original document, following the format described in {@linkcode EditResult}.
+ * To apply the edit operations to the input, use {@linkcode applyEdits}.
  */
 function modify(text, path, value, options) {
-    return _impl_edit__WEBPACK_IMPORTED_MODULE_1__.setProperty(text, path, value, options.formattingOptions, options.getInsertionIndex);
+    return _impl_edit__WEBPACK_IMPORTED_MODULE_1__.setProperty(text, path, value, options);
 }
 /**
- * Applies edits to a input string.
+ * Applies edits to an input string.
+ * @param text The input text
+ * @param edits Edit operations following the format described in {@linkcode EditResult}.
+ * @returns The text with the applied edits.
+ * @throws An error if the edit operations are not well-formed as described in {@linkcode EditResult}.
  */
 function applyEdits(text, edits) {
-    for (var i = edits.length - 1; i >= 0; i--) {
-        text = _impl_edit__WEBPACK_IMPORTED_MODULE_1__.applyEdit(text, edits[i]);
+    let sortedEdits = edits.slice(0).sort((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 = _impl_edit__WEBPACK_IMPORTED_MODULE_1__.applyEdit(text, e);
+        }
+        else {
+            throw new Error('Overlapping edit');
+        }
+        lastModifiedOffset = e.offset;
     }
     return text;
 }
@@ -162,11 +227,11 @@ __webpack_require__.r(__webpack_exports__);
 
 
 function format(documentText, range, options) {
-    var initialIndentLevel;
-    var formatText;
-    var formatTextStart;
-    var rangeStart;
-    var rangeEnd;
+    let initialIndentLevel;
+    let formatText;
+    let formatTextStart;
+    let rangeStart;
+    let rangeEnd;
     if (range) {
         rangeStart = range.offset;
         rangeEnd = rangeStart + range.length;
@@ -174,7 +239,7 @@ function format(documentText, range, options) {
         while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {
             formatTextStart--;
         }
-        var endOffset = rangeEnd;
+        let endOffset = rangeEnd;
         while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {
             endOffset++;
         }
@@ -188,136 +253,193 @@ function format(documentText, range, options) {
         rangeStart = 0;
         rangeEnd = documentText.length;
     }
-    var eol = getEOL(options, documentText);
-    var lineBreak = false;
-    var indentLevel = 0;
-    var indentValue;
+    const eol = getEOL(options, documentText);
+    let numberLineBreaks = 0;
+    let indentLevel = 0;
+    let indentValue;
     if (options.insertSpaces) {
         indentValue = repeat(' ', options.tabSize || 4);
     }
     else {
         indentValue = '\t';
     }
-    var scanner = (0,_scanner__WEBPACK_IMPORTED_MODULE_0__.createScanner)(formatText, false);
-    var hasError = false;
-    function newLineAndIndent() {
-        return eol + repeat(indentValue, initialIndentLevel + indentLevel);
+    let scanner = (0,_scanner__WEBPACK_IMPORTED_MODULE_0__.createScanner)(formatText, false);
+    let hasError = false;
+    function newLinesAndIndent() {
+        if (numberLineBreaks > 1) {
+            return repeat(eol, numberLineBreaks) + repeat(indentValue, initialIndentLevel + indentLevel);
+        }
+        else {
+            return eol + repeat(indentValue, initialIndentLevel + indentLevel);
+        }
     }
     function scanNext() {
-        var token = scanner.scan();
-        lineBreak = false;
-        while (token === 15 /* Trivia */ || token === 14 /* LineBreakTrivia */) {
-            lineBreak = lineBreak || (token === 14 /* LineBreakTrivia */);
+        let token = scanner.scan();
+        numberLineBreaks = 0;
+        while (token === 15 /* SyntaxKind.Trivia */ || token === 14 /* SyntaxKind.LineBreakTrivia */) {
+            if (token === 14 /* SyntaxKind.LineBreakTrivia */ && options.keepLines) {
+                numberLineBreaks += 1;
+            }
+            else if (token === 14 /* SyntaxKind.LineBreakTrivia */) {
+                numberLineBreaks = 1;
+            }
             token = scanner.scan();
         }
-        hasError = token === 16 /* Unknown */ || scanner.getTokenError() !== 0 /* None */;
+        hasError = token === 16 /* SyntaxKind.Unknown */ || scanner.getTokenError() !== 0 /* ScanError.None */;
         return token;
     }
-    var editOperations = [];
+    const editOperations = [];
     function addEdit(text, startOffset, endOffset) {
-        if (!hasError && startOffset < rangeEnd && endOffset > rangeStart && documentText.substring(startOffset, endOffset) !== text) {
+        if (!hasError && (!range || (startOffset < rangeEnd && endOffset > rangeStart)) && documentText.substring(startOffset, endOffset) !== text) {
             editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });
         }
     }
-    var firstToken = scanNext();
-    if (firstToken !== 17 /* EOF */) {
-        var firstTokenStart = scanner.getTokenOffset() + formatTextStart;
-        var initialIndent = repeat(indentValue, initialIndentLevel);
+    let firstToken = scanNext();
+    if (options.keepLines && numberLineBreaks > 0) {
+        addEdit(repeat(eol, numberLineBreaks), 0, 0);
+    }
+    if (firstToken !== 17 /* SyntaxKind.EOF */) {
+        let firstTokenStart = scanner.getTokenOffset() + formatTextStart;
+        let initialIndent = repeat(indentValue, initialIndentLevel);
         addEdit(initialIndent, formatTextStart, firstTokenStart);
     }
-    while (firstToken !== 17 /* EOF */) {
-        var firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
-        var secondToken = scanNext();
-        var replaceContent = '';
-        while (!lineBreak && (secondToken === 12 /* LineCommentTrivia */ || secondToken === 13 /* BlockCommentTrivia */)) {
-            // comments on the same line: keep them on the same line, but ignore them otherwise
-            var commentTokenStart = scanner.getTokenOffset() + formatTextStart;
+    while (firstToken !== 17 /* SyntaxKind.EOF */) {
+        let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+        let secondToken = scanNext();
+        let replaceContent = '';
+        let needsLineBreak = false;
+        while (numberLineBreaks === 0 && (secondToken === 12 /* SyntaxKind.LineCommentTrivia */ || secondToken === 13 /* SyntaxKind.BlockCommentTrivia */)) {
+            let commentTokenStart = scanner.getTokenOffset() + formatTextStart;
             addEdit(' ', firstTokenEnd, commentTokenStart);
             firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
-            replaceContent = secondToken === 12 /* LineCommentTrivia */ ? newLineAndIndent() : '';
+            needsLineBreak = secondToken === 12 /* SyntaxKind.LineCommentTrivia */;
+            replaceContent = needsLineBreak ? newLinesAndIndent() : '';
             secondToken = scanNext();
         }
-        if (secondToken === 2 /* CloseBraceToken */) {
-            if (firstToken !== 1 /* OpenBraceToken */) {
+        if (secondToken === 2 /* SyntaxKind.CloseBraceToken */) {
+            if (firstToken !== 1 /* SyntaxKind.OpenBraceToken */) {
                 indentLevel--;
-                replaceContent = newLineAndIndent();
+            }
+            ;
+            if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 1 /* SyntaxKind.OpenBraceToken */) {
+                replaceContent = newLinesAndIndent();
+            }
+            else if (options.keepLines) {
+                replaceContent = ' ';
             }
         }
-        else if (secondToken === 4 /* CloseBracketToken */) {
-            if (firstToken !== 3 /* OpenBracketToken */) {
+        else if (secondToken === 4 /* SyntaxKind.CloseBracketToken */) {
+            if (firstToken !== 3 /* SyntaxKind.OpenBracketToken */) {
                 indentLevel--;
-                replaceContent = newLineAndIndent();
+            }
+            ;
+            if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 3 /* SyntaxKind.OpenBracketToken */) {
+                replaceContent = newLinesAndIndent();
+            }
+            else if (options.keepLines) {
+                replaceContent = ' ';
             }
         }
         else {
             switch (firstToken) {
-                case 3 /* OpenBracketToken */:
-                case 1 /* OpenBraceToken */:
+                case 3 /* SyntaxKind.OpenBracketToken */:
+                case 1 /* SyntaxKind.OpenBraceToken */:
                     indentLevel++;
-                    replaceContent = newLineAndIndent();
-                    break;
-                case 5 /* CommaToken */:
-                case 12 /* LineCommentTrivia */:
-                    replaceContent = newLineAndIndent();
+                    if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+                        replaceContent = newLinesAndIndent();
+                    }
+                    else {
+                        replaceContent = ' ';
+                    }
                     break;
-                case 13 /* BlockCommentTrivia */:
-                    if (lineBreak) {
-                        replaceContent = newLineAndIndent();
+                case 5 /* SyntaxKind.CommaToken */:
+                    if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+                        replaceContent = newLinesAndIndent();
                     }
                     else {
-                        // symbol following comment on the same line: keep on same line, separate with ' '
                         replaceContent = ' ';
                     }
                     break;
-                case 6 /* ColonToken */:
-                    replaceContent = ' ';
+                case 12 /* SyntaxKind.LineCommentTrivia */:
+                    replaceContent = newLinesAndIndent();
                     break;
-                case 10 /* StringLiteral */:
-                    if (secondToken === 6 /* ColonToken */) {
-                        replaceContent = '';
-                        break;
+                case 13 /* SyntaxKind.BlockCommentTrivia */:
+                    if (numberLineBreaks > 0) {
+                        replaceContent = newLinesAndIndent();
                     }
-                // 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 */) {
+                    else if (!needsLineBreak) {
                         replaceContent = ' ';
                     }
-                    else if (secondToken !== 5 /* CommaToken */ && secondToken !== 17 /* EOF */) {
-                        hasError = true;
+                    break;
+                case 6 /* SyntaxKind.ColonToken */:
+                    if (options.keepLines && numberLineBreaks > 0) {
+                        replaceContent = newLinesAndIndent();
+                    }
+                    else if (!needsLineBreak) {
+                        replaceContent = ' ';
                     }
                     break;
-                case 16 /* Unknown */:
+                case 10 /* SyntaxKind.StringLiteral */:
+                    if (options.keepLines && numberLineBreaks > 0) {
+                        replaceContent = newLinesAndIndent();
+                    }
+                    else if (secondToken === 6 /* SyntaxKind.ColonToken */ && !needsLineBreak) {
+                        replaceContent = '';
+                    }
+                    break;
+                case 7 /* SyntaxKind.NullKeyword */:
+                case 8 /* SyntaxKind.TrueKeyword */:
+                case 9 /* SyntaxKind.FalseKeyword */:
+                case 11 /* SyntaxKind.NumericLiteral */:
+                case 2 /* SyntaxKind.CloseBraceToken */:
+                case 4 /* SyntaxKind.CloseBracketToken */:
+                    if (options.keepLines && numberLineBreaks > 0) {
+                        replaceContent = newLinesAndIndent();
+                    }
+                    else {
+                        if ((secondToken === 12 /* SyntaxKind.LineCommentTrivia */ || secondToken === 13 /* SyntaxKind.BlockCommentTrivia */) && !needsLineBreak) {
+                            replaceContent = ' ';
+                        }
+                        else if (secondToken !== 5 /* SyntaxKind.CommaToken */ && secondToken !== 17 /* SyntaxKind.EOF */) {
+                            hasError = true;
+                        }
+                    }
+                    break;
+                case 16 /* SyntaxKind.Unknown */:
                     hasError = true;
                     break;
             }
-            if (lineBreak && (secondToken === 12 /* LineCommentTrivia */ || secondToken === 13 /* BlockCommentTrivia */)) {
-                replaceContent = newLineAndIndent();
+            if (numberLineBreaks > 0 && (secondToken === 12 /* SyntaxKind.LineCommentTrivia */ || secondToken === 13 /* SyntaxKind.BlockCommentTrivia */)) {
+                replaceContent = newLinesAndIndent();
+            }
+        }
+        if (secondToken === 17 /* SyntaxKind.EOF */) {
+            if (options.keepLines && numberLineBreaks > 0) {
+                replaceContent = newLinesAndIndent();
+            }
+            else {
+                replaceContent = options.insertFinalNewline ? eol : '';
             }
         }
-        var secondTokenStart = scanner.getTokenOffset() + formatTextStart;
+        const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
         addEdit(replaceContent, firstTokenEnd, secondTokenStart);
         firstToken = secondToken;
     }
     return editOperations;
 }
 function repeat(s, count) {
-    var result = '';
-    for (var i = 0; i < count; i++) {
+    let result = '';
+    for (let i = 0; i < count; i++) {
         result += s;
     }
     return result;
 }
 function computeIndentLevel(content, options) {
-    var i = 0;
-    var nChars = 0;
-    var tabSize = options.tabSize || 4;
+    let i = 0;
+    let nChars = 0;
+    const tabSize = options.tabSize || 4;
     while (i < content.length) {
-        var ch = content.charAt(i);
+        let ch = content.charAt(i);
         if (ch === ' ') {
             nChars++;
         }
@@ -332,8 +454,8 @@ function computeIndentLevel(content, options) {
     return Math.floor(nChars / tabSize);
 }
 function getEOL(options, text) {
-    for (var i = 0; i < text.length; i++) {
-        var ch = text.charAt(i);
+    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';
@@ -369,23 +491,22 @@ __webpack_require__.r(__webpack_exports__);
  * Creates a JSON scanner on the given text.
  * If ignoreTrivia is set, whitespaces or comments are ignored.
  */
-function createScanner(text, ignoreTrivia) {
-    if (ignoreTrivia === void 0) { ignoreTrivia = false; }
-    var len = text.length;
-    var pos = 0, value = '', tokenOffset = 0, token = 16 /* Unknown */, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0 /* None */;
+function createScanner(text, ignoreTrivia = false) {
+    const len = text.length;
+    let pos = 0, value = '', tokenOffset = 0, token = 16 /* SyntaxKind.Unknown */, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0 /* ScanError.None */;
     function scanHexDigits(count, exact) {
-        var digits = 0;
-        var value = 0;
+        let digits = 0;
+        let value = 0;
         while (digits < count || !exact) {
-            var ch = text.charCodeAt(pos);
-            if (ch >= 48 /* _0 */ && ch <= 57 /* _9 */) {
-                value = value * 16 + ch - 48 /* _0 */;
+            let ch = text.charCodeAt(pos);
+            if (ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */) {
+                value = value * 16 + ch - 48 /* CharacterCodes._0 */;
             }
-            else if (ch >= 65 /* A */ && ch <= 70 /* F */) {
-                value = value * 16 + ch - 65 /* A */ + 10;
+            else if (ch >= 65 /* CharacterCodes.A */ && ch <= 70 /* CharacterCodes.F */) {
+                value = value * 16 + ch - 65 /* CharacterCodes.A */ + 10;
             }
-            else if (ch >= 97 /* a */ && ch <= 102 /* f */) {
-                value = value * 16 + ch - 97 /* a */ + 10;
+            else if (ch >= 97 /* CharacterCodes.a */ && ch <= 102 /* CharacterCodes.f */) {
+                value = value * 16 + ch - 97 /* CharacterCodes.a */ + 10;
             }
             else {
                 break;
@@ -402,12 +523,12 @@ function createScanner(text, ignoreTrivia) {
         pos = newPosition;
         value = '';
         tokenOffset = 0;
-        token = 16 /* Unknown */;
-        scanError = 0 /* None */;
+        token = 16 /* SyntaxKind.Unknown */;
+        scanError = 0 /* ScanError.None */;
     }
     function scanNumber() {
-        var start = pos;
-        if (text.charCodeAt(pos) === 48 /* _0 */) {
+        let start = pos;
+        if (text.charCodeAt(pos) === 48 /* CharacterCodes._0 */) {
             pos++;
         }
         else {
@@ -416,7 +537,7 @@ function createScanner(text, ignoreTrivia) {
                 pos++;
             }
         }
-        if (pos < text.length && text.charCodeAt(pos) === 46 /* dot */) {
+        if (pos < text.length && text.charCodeAt(pos) === 46 /* CharacterCodes.dot */) {
             pos++;
             if (pos < text.length && isDigit(text.charCodeAt(pos))) {
                 pos++;
@@ -425,14 +546,14 @@ function createScanner(text, ignoreTrivia) {
                 }
             }
             else {
-                scanError = 3 /* UnexpectedEndOfNumber */;
+                scanError = 3 /* ScanError.UnexpectedEndOfNumber */;
                 return text.substring(start, pos);
             }
         }
-        var end = pos;
-        if (pos < text.length && (text.charCodeAt(pos) === 69 /* E */ || text.charCodeAt(pos) === 101 /* e */)) {
+        let end = pos;
+        if (pos < text.length && (text.charCodeAt(pos) === 69 /* CharacterCodes.E */ || text.charCodeAt(pos) === 101 /* CharacterCodes.e */)) {
             pos++;
-            if (pos < text.length && text.charCodeAt(pos) === 43 /* plus */ || text.charCodeAt(pos) === 45 /* minus */) {
+            if (pos < text.length && text.charCodeAt(pos) === 43 /* CharacterCodes.plus */ || text.charCodeAt(pos) === 45 /* CharacterCodes.minus */) {
                 pos++;
             }
             if (pos < text.length && isDigit(text.charCodeAt(pos))) {
@@ -443,69 +564,69 @@ function createScanner(text, ignoreTrivia) {
                 end = pos;
             }
             else {
-                scanError = 3 /* UnexpectedEndOfNumber */;
+                scanError = 3 /* ScanError.UnexpectedEndOfNumber */;
             }
         }
         return text.substring(start, end);
     }
     function scanString() {
-        var result = '', start = pos;
+        let result = '', start = pos;
         while (true) {
             if (pos >= len) {
                 result += text.substring(start, pos);
-                scanError = 2 /* UnexpectedEndOfString */;
+                scanError = 2 /* ScanError.UnexpectedEndOfString */;
                 break;
             }
-            var ch = text.charCodeAt(pos);
-            if (ch === 34 /* doubleQuote */) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 34 /* CharacterCodes.doubleQuote */) {
                 result += text.substring(start, pos);
                 pos++;
                 break;
             }
-            if (ch === 92 /* backslash */) {
+            if (ch === 92 /* CharacterCodes.backslash */) {
                 result += text.substring(start, pos);
                 pos++;
                 if (pos >= len) {
-                    scanError = 2 /* UnexpectedEndOfString */;
+                    scanError = 2 /* ScanError.UnexpectedEndOfString */;
                     break;
                 }
-                var ch2 = text.charCodeAt(pos++);
+                const ch2 = text.charCodeAt(pos++);
                 switch (ch2) {
-                    case 34 /* doubleQuote */:
+                    case 34 /* CharacterCodes.doubleQuote */:
                         result += '\"';
                         break;
-                    case 92 /* backslash */:
+                    case 92 /* CharacterCodes.backslash */:
                         result += '\\';
                         break;
-                    case 47 /* slash */:
+                    case 47 /* CharacterCodes.slash */:
                         result += '/';
                         break;
-                    case 98 /* b */:
+                    case 98 /* CharacterCodes.b */:
                         result += '\b';
                         break;
-                    case 102 /* f */:
+                    case 102 /* CharacterCodes.f */:
                         result += '\f';
                         break;
-                    case 110 /* n */:
+                    case 110 /* CharacterCodes.n */:
                         result += '\n';
                         break;
-                    case 114 /* r */:
+                    case 114 /* CharacterCodes.r */:
                         result += '\r';
                         break;
-                    case 116 /* t */:
+                    case 116 /* CharacterCodes.t */:
                         result += '\t';
                         break;
-                    case 117 /* u */:
-                        var ch3 = scanHexDigits(4, true);
+                    case 117 /* CharacterCodes.u */:
+                        const ch3 = scanHexDigits(4, true);
                         if (ch3 >= 0) {
                             result += String.fromCharCode(ch3);
                         }
                         else {
-                            scanError = 4 /* InvalidUnicode */;
+                            scanError = 4 /* ScanError.InvalidUnicode */;
                         }
                         break;
                     default:
-                        scanError = 5 /* InvalidEscapeCharacter */;
+                        scanError = 5 /* ScanError.InvalidEscapeCharacter */;
                 }
                 start = pos;
                 continue;
@@ -513,11 +634,11 @@ function createScanner(text, ignoreTrivia) {
             if (ch >= 0 && ch <= 0x1f) {
                 if (isLineBreak(ch)) {
                     result += text.substring(start, pos);
-                    scanError = 2 /* UnexpectedEndOfString */;
+                    scanError = 2 /* ScanError.UnexpectedEndOfString */;
                     break;
                 }
                 else {
-                    scanError = 6 /* InvalidCharacter */;
+                    scanError = 6 /* ScanError.InvalidCharacter */;
                     // mark as error but continue with string
                 }
             }
@@ -527,16 +648,16 @@ function createScanner(text, ignoreTrivia) {
     }
     function scanNext() {
         value = '';
-        scanError = 0 /* None */;
+        scanError = 0 /* ScanError.None */;
         tokenOffset = pos;
         lineStartOffset = lineNumber;
         prevTokenLineStartOffset = tokenLineStartOffset;
         if (pos >= len) {
             // at the end
             tokenOffset = len;
-            return token = 17 /* EOF */;
+            return token = 17 /* SyntaxKind.EOF */;
         }
-        var code = text.charCodeAt(pos);
+        let code = text.charCodeAt(pos);
         // trivia: whitespace
         if (isWhiteSpace(code)) {
             do {
@@ -544,50 +665,50 @@ function createScanner(text, ignoreTrivia) {
                 value += String.fromCharCode(code);
                 code = text.charCodeAt(pos);
             } while (isWhiteSpace(code));
-            return token = 15 /* Trivia */;
+            return token = 15 /* SyntaxKind.Trivia */;
         }
         // trivia: newlines
         if (isLineBreak(code)) {
             pos++;
             value += String.fromCharCode(code);
-            if (code === 13 /* carriageReturn */ && text.charCodeAt(pos) === 10 /* lineFeed */) {
+            if (code === 13 /* CharacterCodes.carriageReturn */ && text.charCodeAt(pos) === 10 /* CharacterCodes.lineFeed */) {
                 pos++;
                 value += '\n';
             }
             lineNumber++;
             tokenLineStartOffset = pos;
-            return token = 14 /* LineBreakTrivia */;
+            return token = 14 /* SyntaxKind.LineBreakTrivia */;
         }
         switch (code) {
             // tokens: []{}:,
-            case 123 /* openBrace */:
+            case 123 /* CharacterCodes.openBrace */:
                 pos++;
-                return token = 1 /* OpenBraceToken */;
-            case 125 /* closeBrace */:
+                return token = 1 /* SyntaxKind.OpenBraceToken */;
+            case 125 /* CharacterCodes.closeBrace */:
                 pos++;
-                return token = 2 /* CloseBraceToken */;
-            case 91 /* openBracket */:
+                return token = 2 /* SyntaxKind.CloseBraceToken */;
+            case 91 /* CharacterCodes.openBracket */:
                 pos++;
-                return token = 3 /* OpenBracketToken */;
-            case 93 /* closeBracket */:
+                return token = 3 /* SyntaxKind.OpenBracketToken */;
+            case 93 /* CharacterCodes.closeBracket */:
                 pos++;
-                return token = 4 /* CloseBracketToken */;
-            case 58 /* colon */:
+                return token = 4 /* SyntaxKind.CloseBracketToken */;
+            case 58 /* CharacterCodes.colon */:
                 pos++;
-                return token = 6 /* ColonToken */;
-            case 44 /* comma */:
+                return token = 6 /* SyntaxKind.ColonToken */;
+            case 44 /* CharacterCodes.comma */:
                 pos++;
-                return token = 5 /* CommaToken */;
+                return token = 5 /* SyntaxKind.CommaToken */;
             // strings
-            case 34 /* doubleQuote */:
+            case 34 /* CharacterCodes.doubleQuote */:
                 pos++;
                 value = scanString();
-                return token = 10 /* StringLiteral */;
+                return token = 10 /* SyntaxKind.StringLiteral */;
             // comments
-            case 47 /* slash */:
-                var start = pos - 1;
+            case 47 /* CharacterCodes.slash */:
+                const start = pos - 1;
                 // Single-line comment
-                if (text.charCodeAt(pos + 1) === 47 /* slash */) {
+                if (text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) {
                     pos += 2;
                     while (pos < len) {
                         if (isLineBreak(text.charCodeAt(pos))) {
@@ -596,23 +717,23 @@ function createScanner(text, ignoreTrivia) {
                         pos++;
                     }
                     value = text.substring(start, pos);
-                    return token = 12 /* LineCommentTrivia */;
+                    return token = 12 /* SyntaxKind.LineCommentTrivia */;
                 }
                 // Multi-line comment
-                if (text.charCodeAt(pos + 1) === 42 /* asterisk */) {
+                if (text.charCodeAt(pos + 1) === 42 /* CharacterCodes.asterisk */) {
                     pos += 2;
-                    var safeLength = len - 1; // For lookahead.
-                    var commentClosed = false;
+                    const safeLength = len - 1; // For lookahead.
+                    let commentClosed = false;
                     while (pos < safeLength) {
-                        var ch = text.charCodeAt(pos);
-                        if (ch === 42 /* asterisk */ && text.charCodeAt(pos + 1) === 47 /* slash */) {
+                        const ch = text.charCodeAt(pos);
+                        if (ch === 42 /* CharacterCodes.asterisk */ && text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) {
                             pos += 2;
                             commentClosed = true;
                             break;
                         }
                         pos++;
                         if (isLineBreak(ch)) {
-                            if (ch === 13 /* carriageReturn */ && text.charCodeAt(pos) === 10 /* lineFeed */) {
+                            if (ch === 13 /* CharacterCodes.carriageReturn */ && text.charCodeAt(pos) === 10 /* CharacterCodes.lineFeed */) {
                                 pos++;
                             }
                             lineNumber++;
@@ -621,37 +742,37 @@ function createScanner(text, ignoreTrivia) {
                     }
                     if (!commentClosed) {
                         pos++;
-                        scanError = 1 /* UnexpectedEndOfComment */;
+                        scanError = 1 /* ScanError.UnexpectedEndOfComment */;
                     }
                     value = text.substring(start, pos);
-                    return token = 13 /* BlockCommentTrivia */;
+                    return token = 13 /* SyntaxKind.BlockCommentTrivia */;
                 }
                 // just a single slash
                 value += String.fromCharCode(code);
                 pos++;
-                return token = 16 /* Unknown */;
+                return token = 16 /* SyntaxKind.Unknown */;
             // numbers
-            case 45 /* minus */:
+            case 45 /* CharacterCodes.minus */:
                 value += String.fromCharCode(code);
                 pos++;
                 if (pos === len || !isDigit(text.charCodeAt(pos))) {
-                    return token = 16 /* Unknown */;
+                    return token = 16 /* SyntaxKind.Unknown */;
                 }
             // found a minus, followed by a number so
             // we fall through to proceed with scanning
             // numbers
-            case 48 /* _0 */:
-            case 49 /* _1 */:
-            case 50 /* _2 */:
-            case 51 /* _3 */:
-            case 52 /* _4 */:
-            case 53 /* _5 */:
-            case 54 /* _6 */:
-            case 55 /* _7 */:
-            case 56 /* _8 */:
-            case 57 /* _9 */:
+            case 48 /* CharacterCodes._0 */:
+            case 49 /* CharacterCodes._1 */:
+            case 50 /* CharacterCodes._2 */:
+            case 51 /* CharacterCodes._3 */:
+            case 52 /* CharacterCodes._4 */:
+            case 53 /* CharacterCodes._5 */:
+            case 54 /* CharacterCodes._6 */:
+            case 55 /* CharacterCodes._7 */:
+            case 56 /* CharacterCodes._8 */:
+            case 57 /* CharacterCodes._9 */:
                 value += scanNumber();
-                return token = 11 /* NumericLiteral */;
+                return token = 11 /* SyntaxKind.NumericLiteral */;
             // literals and unknown symbols
             default:
                 // is a literal? Read the full word.
@@ -663,16 +784,16 @@ function createScanner(text, ignoreTrivia) {
                     value = text.substring(tokenOffset, pos);
                     // keywords: true, false, null
                     switch (value) {
-                        case 'true': return token = 8 /* TrueKeyword */;
-                        case 'false': return token = 9 /* FalseKeyword */;
-                        case 'null': return token = 7 /* NullKeyword */;
+                        case 'true': return token = 8 /* SyntaxKind.TrueKeyword */;
+                        case 'false': return token = 9 /* SyntaxKind.FalseKeyword */;
+                        case 'null': return token = 7 /* SyntaxKind.NullKeyword */;
                     }
-                    return token = 16 /* Unknown */;
+                    return token = 16 /* SyntaxKind.Unknown */;
                 }
                 // some
                 value += String.fromCharCode(code);
                 pos++;
-                return token = 16 /* Unknown */;
+                return token = 16 /* SyntaxKind.Unknown */;
         }
     }
     function isUnknownContentCharacter(code) {
@@ -680,49 +801,130 @@ function createScanner(text, ignoreTrivia) {
             return false;
         }
         switch (code) {
-            case 125 /* closeBrace */:
-            case 93 /* closeBracket */:
-            case 123 /* openBrace */:
-            case 91 /* openBracket */:
-            case 34 /* doubleQuote */:
-            case 58 /* colon */:
-            case 44 /* comma */:
-            case 47 /* slash */:
+            case 125 /* CharacterCodes.closeBrace */:
+            case 93 /* CharacterCodes.closeBracket */:
+            case 123 /* CharacterCodes.openBrace */:
+            case 91 /* CharacterCodes.openBracket */:
+            case 34 /* CharacterCodes.doubleQuote */:
+            case 58 /* CharacterCodes.colon */:
+            case 44 /* CharacterCodes.comma */:
+            case 47 /* CharacterCodes.slash */:
                 return false;
         }
         return true;
     }
     function scanNextNonTrivia() {
-        var result;
+        let result;
         do {
             result = scanNext();
-        } while (result >= 12 /* LineCommentTrivia */ && result <= 15 /* Trivia */);
+        } while (result >= 12 /* SyntaxKind.LineCommentTrivia */ && result <= 15 /* SyntaxKind.Trivia */);
         return result;
     }
     return {
         setPosition: setPosition,
-        getPosition: function () { return pos; },
+        getPosition: () => pos,
         scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
-        getToken: function () { return token; },
-        getTokenValue: function () { return value; },
-        getTokenOffset: function () { return tokenOffset; },
-        getTokenLength: function () { return pos - tokenOffset; },
-        getTokenStartLine: function () { return lineStartOffset; },
-        getTokenStartCharacter: function () { return tokenOffset - prevTokenLineStartOffset; },
-        getTokenError: function () { return scanError; },
+        getToken: () => token,
+        getTokenValue: () => value,
+        getTokenOffset: () => tokenOffset,
+        getTokenLength: () => pos - tokenOffset,
+        getTokenStartLine: () => lineStartOffset,
+        getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+        getTokenError: () => scanError,
     };
 }
 function isWhiteSpace(ch) {
-    return ch === 32 /* space */ || ch === 9 /* tab */ || ch === 11 /* verticalTab */ || ch === 12 /* formFeed */ ||
-        ch === 160 /* nonBreakingSpace */ || ch === 5760 /* ogham */ || ch >= 8192 /* enQuad */ && ch <= 8203 /* zeroWidthSpace */ ||
-        ch === 8239 /* narrowNoBreakSpace */ || ch === 8287 /* mathematicalSpace */ || ch === 12288 /* ideographicSpace */ || ch === 65279 /* byteOrderMark */;
+    return ch === 32 /* CharacterCodes.space */ || ch === 9 /* CharacterCodes.tab */;
 }
 function isLineBreak(ch) {
-    return ch === 10 /* lineFeed */ || ch === 13 /* carriageReturn */ || ch === 8232 /* lineSeparator */ || ch === 8233 /* paragraphSeparator */;
+    return ch === 10 /* CharacterCodes.lineFeed */ || ch === 13 /* CharacterCodes.carriageReturn */;
 }
 function isDigit(ch) {
-    return ch >= 48 /* _0 */ && ch <= 57 /* _9 */;
+    return ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */;
 }
+var CharacterCodes;
+(function (CharacterCodes) {
+    CharacterCodes[CharacterCodes["lineFeed"] = 10] = "lineFeed";
+    CharacterCodes[CharacterCodes["carriageReturn"] = 13] = "carriageReturn";
+    CharacterCodes[CharacterCodes["space"] = 32] = "space";
+    CharacterCodes[CharacterCodes["_0"] = 48] = "_0";
+    CharacterCodes[CharacterCodes["_1"] = 49] = "_1";
+    CharacterCodes[CharacterCodes["_2"] = 50] = "_2";
+    CharacterCodes[CharacterCodes["_3"] = 51] = "_3";
+    CharacterCodes[CharacterCodes["_4"] = 52] = "_4";
+    CharacterCodes[CharacterCodes["_5"] = 53] = "_5";
+    CharacterCodes[CharacterCodes["_6"] = 54] = "_6";
+    CharacterCodes[CharacterCodes["_7"] = 55] = "_7";
+    CharacterCodes[CharacterCodes["_8"] = 56] = "_8";
+    CharacterCodes[CharacterCodes["_9"] = 57] = "_9";
+    CharacterCodes[CharacterCodes["a"] = 97] = "a";
+    CharacterCodes[CharacterCodes["b"] = 98] = "b";
+    CharacterCodes[CharacterCodes["c"] = 99] = "c";
+    CharacterCodes[CharacterCodes["d"] = 100] = "d";
+    CharacterCodes[CharacterCodes["e"] = 101] = "e";
+    CharacterCodes[CharacterCodes["f"] = 102] = "f";
+    CharacterCodes[CharacterCodes["g"] = 103] = "g";
+    CharacterCodes[CharacterCodes["h"] = 104] = "h";
+    CharacterCodes[CharacterCodes["i"] = 105] = "i";
+    CharacterCodes[CharacterCodes["j"] = 106] = "j";
+    CharacterCodes[CharacterCodes["k"] = 107] = "k";
+    CharacterCodes[CharacterCodes["l"] = 108] = "l";
+    CharacterCodes[CharacterCodes["m"] = 109] = "m";
+    CharacterCodes[CharacterCodes["n"] = 110] = "n";
+    CharacterCodes[CharacterCodes["o"] = 111] = "o";
+    CharacterCodes[CharacterCodes["p"] = 112] = "p";
+    CharacterCodes[CharacterCodes["q"] = 113] = "q";
+    CharacterCodes[CharacterCodes["r"] = 114] = "r";
+    CharacterCodes[CharacterCodes["s"] = 115] = "s";
+    CharacterCodes[CharacterCodes["t"] = 116] = "t";
+    CharacterCodes[CharacterCodes["u"] = 117] = "u";
+    CharacterCodes[CharacterCodes["v"] = 118] = "v";
+    CharacterCodes[CharacterCodes["w"] = 119] = "w";
+    CharacterCodes[CharacterCodes["x"] = 120] = "x";
+    CharacterCodes[CharacterCodes["y"] = 121] = "y";
+    CharacterCodes[CharacterCodes["z"] = 122] = "z";
+    CharacterCodes[CharacterCodes["A"] = 65] = "A";
+    CharacterCodes[CharacterCodes["B"] = 66] = "B";
+    CharacterCodes[CharacterCodes["C"] = 67] = "C";
+    CharacterCodes[CharacterCodes["D"] = 68] = "D";
+    CharacterCodes[CharacterCodes["E"] = 69] = "E";
+    CharacterCodes[CharacterCodes["F"] = 70] = "F";
+    CharacterCodes[CharacterCodes["G"] = 71] = "G";
+    CharacterCodes[CharacterCodes["H"] = 72] = "H";
+    CharacterCodes[CharacterCodes["I"] = 73] = "I";
+    CharacterCodes[CharacterCodes["J"] = 74] = "J";
+    CharacterCodes[CharacterCodes["K"] = 75] = "K";
+    CharacterCodes[CharacterCodes["L"] = 76] = "L";
+    CharacterCodes[CharacterCodes["M"] = 77] = "M";
+    CharacterCodes[CharacterCodes["N"] = 78] = "N";
+    CharacterCodes[CharacterCodes["O"] = 79] = "O";
+    CharacterCodes[CharacterCodes["P"] = 80] = "P";
+    CharacterCodes[CharacterCodes["Q"] = 81] = "Q";
+    CharacterCodes[CharacterCodes["R"] = 82] = "R";
+    CharacterCodes[CharacterCodes["S"] = 83] = "S";
+    CharacterCodes[CharacterCodes["T"] = 84] = "T";
+    CharacterCodes[CharacterCodes["U"] = 85] = "U";
+    CharacterCodes[CharacterCodes["V"] = 86] = "V";
+    CharacterCodes[CharacterCodes["W"] = 87] = "W";
+    CharacterCodes[CharacterCodes["X"] = 88] = "X";
+    CharacterCodes[CharacterCodes["Y"] = 89] = "Y";
+    CharacterCodes[CharacterCodes["Z"] = 90] = "Z";
+    CharacterCodes[CharacterCodes["asterisk"] = 42] = "asterisk";
+    CharacterCodes[CharacterCodes["backslash"] = 92] = "backslash";
+    CharacterCodes[CharacterCodes["closeBrace"] = 125] = "closeBrace";
+    CharacterCodes[CharacterCodes["closeBracket"] = 93] = "closeBracket";
+    CharacterCodes[CharacterCodes["colon"] = 58] = "colon";
+    CharacterCodes[CharacterCodes["comma"] = 44] = "comma";
+    CharacterCodes[CharacterCodes["dot"] = 46] = "dot";
+    CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote";
+    CharacterCodes[CharacterCodes["minus"] = 45] = "minus";
+    CharacterCodes[CharacterCodes["openBrace"] = 123] = "openBrace";
+    CharacterCodes[CharacterCodes["openBracket"] = 91] = "openBracket";
+    CharacterCodes[CharacterCodes["plus"] = 43] = "plus";
+    CharacterCodes[CharacterCodes["slash"] = 47] = "slash";
+    CharacterCodes[CharacterCodes["formFeed"] = 12] = "formFeed";
+    CharacterCodes[CharacterCodes["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
 
 
 /***/ }),
@@ -746,22 +948,21 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
-function removeProperty(text, path, formattingOptions) {
-    return setProperty(text, path, void 0, formattingOptions);
+function removeProperty(text, path, options) {
+    return setProperty(text, path, void 0, options);
 }
-function setProperty(text, originalPath, value, formattingOptions, getInsertionIndex) {
-    var _a;
-    var path = originalPath.slice();
-    var errors = [];
-    var root = (0,_parser__WEBPACK_IMPORTED_MODULE_1__.parseTree)(text, errors);
-    var parent = void 0;
-    var lastSegment = void 0;
+function setProperty(text, originalPath, value, options) {
+    const path = originalPath.slice();
+    const errors = [];
+    const root = (0,_parser__WEBPACK_IMPORTED_MODULE_1__.parseTree)(text, errors);
+    let parent = void 0;
+    let lastSegment = void 0;
     while (path.length > 0) {
         lastSegment = path.pop();
         parent = (0,_parser__WEBPACK_IMPORTED_MODULE_1__.findNodeAtLocation)(root, path);
         if (parent === void 0 && value !== void 0) {
             if (typeof lastSegment === 'string') {
-                value = (_a = {}, _a[lastSegment] = value, _a);
+                value = { [lastSegment]: value };
             }
             else {
                 value = [value];
@@ -776,47 +977,47 @@ function setProperty(text, originalPath, value, formattingOptions, getInsertionI
         if (value === void 0) { // 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);
+        return withFormatting(text, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, options);
     }
     else if (parent.type === 'object' && typeof lastSegment === 'string' && Array.isArray(parent.children)) {
-        var existing = (0,_parser__WEBPACK_IMPORTED_MODULE_1__.findNodeAtLocation)(parent, [lastSegment]);
+        const existing = (0,_parser__WEBPACK_IMPORTED_MODULE_1__.findNodeAtLocation)(parent, [lastSegment]);
         if (existing !== void 0) {
             if (value === void 0) { // delete
                 if (!existing.parent) {
                     throw new Error('Malformed AST');
                 }
-                var propertyIndex = parent.children.indexOf(existing.parent);
-                var removeBegin = void 0;
-                var removeEnd = existing.parent.offset + existing.parent.length;
+                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
-                    var previous = parent.children[propertyIndex - 1];
+                    let 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
-                        var next = parent.children[1];
+                        let next = parent.children[1];
                         removeEnd = next.offset;
                     }
                 }
-                return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: '' }, formattingOptions);
+                return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: '' }, options);
             }
             else {
                 // set value of existing property
-                return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, formattingOptions);
+                return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, options);
             }
         }
         else {
             if (value === void 0) { // delete
                 return []; // property does not exist, nothing to do
             }
-            var newProperty = JSON.stringify(lastSegment) + ": " + JSON.stringify(value);
-            var index = getInsertionIndex ? getInsertionIndex(parent.children.map(function (p) { return p.children[0].value; })) : parent.children.length;
-            var edit = void 0;
+            const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
+            const index = options.getInsertionIndex ? options.getInsertionIndex(parent.children.map(p => p.children[0].value)) : parent.children.length;
+            let edit;
             if (index > 0) {
-                var previous = parent.children[index - 1];
+                let previous = parent.children[index - 1];
                 edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };
             }
             else if (parent.children.length === 0) {
@@ -825,61 +1026,79 @@ function setProperty(text, originalPath, value, formattingOptions, getInsertionI
             else {
                 edit = { offset: parent.offset + 1, length: 0, content: newProperty + ',' };
             }
-            return withFormatting(text, edit, formattingOptions);
+            return withFormatting(text, edit, options);
         }
     }
     else if (parent.type === 'array' && typeof lastSegment === 'number' && Array.isArray(parent.children)) {
-        var insertIndex = lastSegment;
+        const insertIndex = lastSegment;
         if (insertIndex === -1) {
             // Insert
-            var newProperty = "" + JSON.stringify(value);
-            var edit = void 0;
+            const newProperty = `${JSON.stringify(value)}`;
+            let edit;
             if (parent.children.length === 0) {
                 edit = { offset: parent.offset + 1, length: 0, content: newProperty };
             }
             else {
-                var previous = parent.children[parent.children.length - 1];
+                const previous = parent.children[parent.children.length - 1];
                 edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };
             }
-            return withFormatting(text, edit, formattingOptions);
-        }
-        else {
-            if (value === void 0 && parent.children.length >= 0) {
-                //Removal
-                var removalIndex = lastSegment;
-                var toRemove = parent.children[removalIndex];
-                var edit = void 0;
-                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
-                    var previous = parent.children[removalIndex - 1];
-                    var offset = previous.offset + previous.length;
-                    var parentEndOffset = parent.offset + parent.length;
-                    edit = { offset: 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);
+            return withFormatting(text, edit, options);
+        }
+        else if (value === void 0 && parent.children.length >= 0) {
+            // 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
+                let previous = parent.children[removalIndex - 1];
+                let offset = previous.offset + previous.length;
+                let parentEndOffset = parent.offset + parent.length;
+                edit = { offset, length: parentEndOffset - 2 - offset, content: '' };
             }
             else {
-                throw new Error('Array modification not supported yet');
+                edit = { offset: toRemove.offset, length: parent.children[removalIndex + 1].offset - toRemove.offset, content: '' };
+            }
+            return withFormatting(text, edit, options);
+        }
+        else if (value !== void 0) {
+            let edit;
+            const newProperty = `${JSON.stringify(value)}`;
+            if (!options.isArrayInsertion && parent.children.length > lastSegment) {
+                const toModify = parent.children[lastSegment];
+                edit = { offset: toModify.offset, length: toModify.length, content: newProperty };
+            }
+            else 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 > 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, options);
+        }
+        else {
+            throw new Error(`Can not ${value === void 0 ? 'remove' : (options.isArrayInsertion ? 'insert' : 'modify')} Array index ${insertIndex} as length is not sufficient`);
         }
     }
     else {
-        throw new Error("Can not add " + (typeof lastSegment !== 'number' ? 'index' : 'property') + " to parent of type " + parent.type);
+        throw new Error(`Can not add ${typeof lastSegment !== 'number' ? 'index' : 'property'} to parent of type ${parent.type}`);
     }
 }
-function withFormatting(text, edit, formattingOptions) {
+function withFormatting(text, edit, options) {
+    if (!options.formattingOptions) {
+        return [edit];
+    }
     // apply the edit
-    var newText = applyEdit(text, edit);
+    let newText = applyEdit(text, edit);
     // format the new text
-    var begin = edit.offset;
-    var end = edit.offset + edit.content.length;
+    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 && !(0,_format__WEBPACK_IMPORTED_MODULE_0__.isEOL)(newText, begin - 1)) {
             begin--;
@@ -888,17 +1107,17 @@ function withFormatting(text, edit, formattingOptions) {
             end++;
         }
     }
-    var edits = (0,_format__WEBPACK_IMPORTED_MODULE_0__.format)(newText, { offset: begin, length: end - begin }, formattingOptions);
+    const edits = (0,_format__WEBPACK_IMPORTED_MODULE_0__.format)(newText, { offset: begin, length: end - begin }, { ...options.formattingOptions, keepLines: false });
     // apply the formatting edits and track the begin and end offsets of the changes
-    for (var i = edits.length - 1; i >= 0; i--) {
-        var edit_1 = edits[i];
-        newText = applyEdit(newText, edit_1);
-        begin = Math.min(begin, edit_1.offset);
-        end = Math.max(end, edit_1.offset + edit_1.length);
-        end += edit_1.content.length - edit_1.length;
+    for (let i = edits.length - 1; i >= 0; i--) {
+        const edit = edits[i];
+        newText = applyEdit(newText, edit);
+        begin = Math.min(begin, edit.offset);
+        end = Math.max(end, edit.offset + edit.length);
+        end += edit.content.length - edit.length;
     }
     // create a single edit with all changes
-    var editLength = text.length - (newText.length - end) - begin;
+    const editLength = text.length - (newText.length - end) - begin;
     return [{ offset: begin, length: editLength, content: newText.substring(begin, end) }];
 }
 function applyEdit(text, edit) {
@@ -945,17 +1164,17 @@ var ParseOptions;
  * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.
  */
 function getLocation(text, position) {
-    var segments = []; // strings or numbers
-    var earlyReturnException = new Object();
-    var previousNode = undefined;
-    var previousNodeInst = {
+    const segments = []; // strings or numbers
+    const earlyReturnException = new Object();
+    let previousNode = undefined;
+    const previousNodeInst = {
         value: {},
         offset: 0,
         length: 0,
         type: 'object',
         parent: undefined
     };
-    var isAtPropertyKey = false;
+    let isAtPropertyKey = false;
     function setPreviousNode(value, offset, length, type) {
         previousNodeInst.value = value;
         previousNodeInst.offset = offset;
@@ -966,7 +1185,7 @@ function getLocation(text, position) {
     }
     try {
         visit(text, {
-            onObjectBegin: function (offset, length) {
+            onObjectBegin: (offset, length) => {
                 if (position <= offset) {
                     throw earlyReturnException;
                 }
@@ -974,7 +1193,7 @@ function getLocation(text, position) {
                 isAtPropertyKey = position > offset;
                 segments.push(''); // push a placeholder (will be replaced)
             },
-            onObjectProperty: function (name, offset, length) {
+            onObjectProperty: (name, offset, length) => {
                 if (position < offset) {
                     throw earlyReturnException;
                 }
@@ -984,28 +1203,28 @@ function getLocation(text, position) {
                     throw earlyReturnException;
                 }
             },
-            onObjectEnd: function (offset, length) {
+            onObjectEnd: (offset, length) => {
                 if (position <= offset) {
                     throw earlyReturnException;
                 }
                 previousNode = undefined;
                 segments.pop();
             },
-            onArrayBegin: function (offset, length) {
+            onArrayBegin: (offset, length) => {
                 if (position <= offset) {
                     throw earlyReturnException;
                 }
                 previousNode = undefined;
                 segments.push(0);
             },
-            onArrayEnd: function (offset, length) {
+            onArrayEnd: (offset, length) => {
                 if (position <= offset) {
                     throw earlyReturnException;
                 }
                 previousNode = undefined;
                 segments.pop();
             },
-            onLiteralValue: function (value, offset, length) {
+            onLiteralValue: (value, offset, length) => {
                 if (position < offset) {
                     throw earlyReturnException;
                 }
@@ -1014,7 +1233,7 @@ function getLocation(text, position) {
                     throw earlyReturnException;
                 }
             },
-            onSeparator: function (sep, offset, length) {
+            onSeparator: (sep, offset, length) => {
                 if (position <= offset) {
                     throw earlyReturnException;
                 }
@@ -1024,7 +1243,7 @@ function getLocation(text, position) {
                     previousNode = undefined;
                 }
                 else if (sep === ',') {
-                    var last = segments[segments.length - 1];
+                    const last = segments[segments.length - 1];
                     if (typeof last === 'number') {
                         segments[segments.length - 1] = last + 1;
                     }
@@ -1044,11 +1263,11 @@ function getLocation(text, position) {
     }
     return {
         path: segments,
-        previousNode: previousNode,
-        isAtPropertyKey: isAtPropertyKey,
-        matches: function (pattern) {
-            var k = 0;
-            for (var i = 0; k < pattern.length && i < segments.length; i++) {
+        previousNode,
+        isAtPropertyKey,
+        matches: (pattern) => {
+            let k = 0;
+            for (let i = 0; k < pattern.length && i < segments.length; i++) {
                 if (pattern[k] === segments[i] || pattern[k] === '*') {
                     k++;
                 }
@@ -1064,12 +1283,10 @@ function getLocation(text, position) {
  * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
  * Therefore always check the errors list to find out if the input was valid.
  */
-function parse(text, errors, options) {
-    if (errors === void 0) { errors = []; }
-    if (options === void 0) { options = ParseOptions.DEFAULT; }
-    var currentProperty = null;
-    var currentParent = [];
-    var previousParents = [];
+function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+    let currentProperty = null;
+    let currentParent = [];
+    const previousParents = [];
     function onValue(value) {
         if (Array.isArray(currentParent)) {
             currentParent.push(value);
@@ -1078,33 +1295,33 @@ function parse(text, errors, options) {
             currentParent[currentProperty] = value;
         }
     }
-    var visitor = {
-        onObjectBegin: function () {
-            var object = {};
+    const visitor = {
+        onObjectBegin: () => {
+            const object = {};
             onValue(object);
             previousParents.push(currentParent);
             currentParent = object;
             currentProperty = null;
         },
-        onObjectProperty: function (name) {
+        onObjectProperty: (name) => {
             currentProperty = name;
         },
-        onObjectEnd: function () {
+        onObjectEnd: () => {
             currentParent = previousParents.pop();
         },
-        onArrayBegin: function () {
-            var array = [];
+        onArrayBegin: () => {
+            const array = [];
             onValue(array);
             previousParents.push(currentParent);
             currentParent = array;
             currentProperty = null;
         },
-        onArrayEnd: function () {
+        onArrayEnd: () => {
             currentParent = previousParents.pop();
         },
         onLiteralValue: onValue,
-        onError: function (error, offset, length) {
-            errors.push({ error: error, offset: offset, length: length });
+        onError: (error, offset, length) => {
+            errors.push({ error, offset, length });
         }
     };
     visit(text, visitor, options);
@@ -1113,10 +1330,8 @@ function parse(text, errors, options) {
 /**
  * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
  */
-function parseTree(text, errors, options) {
-    if (errors === void 0) { errors = []; }
-    if (options === void 0) { options = ParseOptions.DEFAULT; }
-    var currentParent = { type: 'array', offset: -1, length: -1, children: [], parent: undefined }; // artificial root
+function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
+    let currentParent = { type: 'array', offset: -1, length: -1, children: [], parent: undefined }; // artificial root
     function ensurePropertyComplete(endOffset) {
         if (currentParent.type === 'property') {
             currentParent.length = endOffset - currentParent.offset;
@@ -1127,33 +1342,33 @@ function parseTree(text, errors, options) {
         currentParent.children.push(valueNode);
         return valueNode;
     }
-    var visitor = {
-        onObjectBegin: function (offset) {
-            currentParent = onValue({ type: 'object', offset: offset, length: -1, parent: currentParent, children: [] });
+    const visitor = {
+        onObjectBegin: (offset) => {
+            currentParent = onValue({ type: 'object', offset, length: -1, parent: currentParent, children: [] });
         },
-        onObjectProperty: function (name, offset, length) {
-            currentParent = onValue({ type: 'property', offset: offset, length: -1, parent: currentParent, children: [] });
-            currentParent.children.push({ type: 'string', value: name, offset: offset, length: length, parent: currentParent });
+        onObjectProperty: (name, offset, length) => {
+            currentParent = onValue({ type: 'property', offset, length: -1, parent: currentParent, children: [] });
+            currentParent.children.push({ type: 'string', value: name, offset, length, parent: currentParent });
         },
-        onObjectEnd: function (offset, length) {
+        onObjectEnd: (offset, length) => {
             ensurePropertyComplete(offset + length); // in case of a missing value for a property: make sure property is complete
             currentParent.length = offset + length - currentParent.offset;
             currentParent = currentParent.parent;
             ensurePropertyComplete(offset + length);
         },
-        onArrayBegin: function (offset, length) {
-            currentParent = onValue({ type: 'array', offset: offset, length: -1, parent: currentParent, children: [] });
+        onArrayBegin: (offset, length) => {
+            currentParent = onValue({ type: 'array', offset, length: -1, parent: currentParent, children: [] });
         },
-        onArrayEnd: function (offset, length) {
+        onArrayEnd: (offset, length) => {
             currentParent.length = offset + length - currentParent.offset;
             currentParent = currentParent.parent;
             ensurePropertyComplete(offset + length);
         },
-        onLiteralValue: function (value, offset, length) {
-            onValue({ type: getNodeType(value), offset: offset, length: length, parent: currentParent, value: value });
+        onLiteralValue: (value, offset, length) => {
+            onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
             ensurePropertyComplete(offset + length);
         },
-        onSeparator: function (sep, offset, length) {
+        onSeparator: (sep, offset, length) => {
             if (currentParent.type === 'property') {
                 if (sep === ':') {
                     currentParent.colonOffset = offset;
@@ -1163,12 +1378,12 @@ function parseTree(text, errors, options) {
                 }
             }
         },
-        onError: function (error, offset, length) {
-            errors.push({ error: error, offset: offset, length: length });
+        onError: (error, offset, length) => {
+            errors.push({ error, offset, length });
         }
     };
     visit(text, visitor, options);
-    var result = currentParent.children[0];
+    const result = currentParent.children[0];
     if (result) {
         delete result.parent;
     }
@@ -1181,17 +1396,15 @@ function findNodeAtLocation(root, path) {
     if (!root) {
         return undefined;
     }
-    var node = root;
-    for (var _i = 0, path_1 = path; _i < path_1.length; _i++) {
-        var segment = path_1[_i];
+    let node = root;
+    for (let segment of path) {
         if (typeof segment === 'string') {
             if (node.type !== 'object' || !Array.isArray(node.children)) {
                 return undefined;
             }
-            var found = false;
-            for (var _a = 0, _b = node.children; _a < _b.length; _a++) {
-                var propertyNode = _b[_a];
-                if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment) {
+            let found = false;
+            for (const propertyNode of node.children) {
+                if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {
                     node = propertyNode.children[1];
                     found = true;
                     break;
@@ -1202,7 +1415,7 @@ function findNodeAtLocation(root, path) {
             }
         }
         else {
-            var index = segment;
+            const index = segment;
             if (node.type !== 'array' || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
                 return undefined;
             }
@@ -1218,13 +1431,13 @@ function getNodePath(node) {
     if (!node.parent || !node.parent.children) {
         return [];
     }
-    var path = getNodePath(node.parent);
+    const path = getNodePath(node.parent);
     if (node.parent.type === 'property') {
-        var key = node.parent.children[0].value;
+        const key = node.parent.children[0].value;
         path.push(key);
     }
     else if (node.parent.type === 'array') {
-        var index = node.parent.children.indexOf(node);
+        const index = node.parent.children.indexOf(node);
         if (index !== -1) {
             path.push(index);
         }
@@ -1239,10 +1452,9 @@ function getNodeValue(node) {
         case 'array':
             return node.children.map(getNodeValue);
         case 'object':
-            var obj = Object.create(null);
-            for (var _i = 0, _a = node.children; _i < _a.length; _i++) {
-                var prop = _a[_i];
-                var valueNode = prop.children[1];
+            const obj = Object.create(null);
+            for (let prop of node.children) {
+                const valueNode = prop.children[1];
                 if (valueNode) {
                     obj[prop.children[0].value] = getNodeValue(valueNode);
                 }
@@ -1257,20 +1469,18 @@ function getNodeValue(node) {
             return undefined;
     }
 }
-function contains(node, offset, includeRightBound) {
-    if (includeRightBound === void 0) { includeRightBound = false; }
+function contains(node, offset, includeRightBound = false) {
     return (offset >= node.offset && offset < (node.offset + node.length)) || includeRightBound && (offset === (node.offset + node.length));
 }
 /**
  * Finds the most inner node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.
  */
-function findNodeAtOffset(node, offset, includeRightBound) {
-    if (includeRightBound === void 0) { includeRightBound = false; }
+function findNodeAtOffset(node, offset, includeRightBound = false) {
     if (contains(node, offset, includeRightBound)) {
-        var children = node.children;
+        const children = node.children;
         if (Array.isArray(children)) {
-            for (var i = 0; i < children.length && children[i].offset <= offset; i++) {
-                var item = findNodeAtOffset(children[i], offset, includeRightBound);
+            for (let i = 0; i < children.length && children[i].offset <= offset; i++) {
+                const item = findNodeAtOffset(children[i], offset, includeRightBound);
                 if (item) {
                     return item;
                 }
@@ -1283,71 +1493,77 @@ function findNodeAtOffset(node, offset, includeRightBound) {
 /**
  * Parses the given text and invokes the visitor functions for each object, array and literal reached.
  */
-function visit(text, visitor, options) {
-    if (options === void 0) { options = ParseOptions.DEFAULT; }
-    var _scanner = (0,_scanner__WEBPACK_IMPORTED_MODULE_0__.createScanner)(text, false);
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+    const _scanner = (0,_scanner__WEBPACK_IMPORTED_MODULE_0__.createScanner)(text, false);
+    // Important: Only pass copies of this to visitor functions to prevent accidental modification, and
+    // to not affect visitor functions which stored a reference to a previous JSONPath
+    const _jsonPath = [];
     function toNoArgVisit(visitFunction) {
-        return visitFunction ? function () { return visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()); } : function () { return true; };
+        return visitFunction ? () => visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+    }
+    function toNoArgVisitWithPath(visitFunction) {
+        return visitFunction ? () => visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
     }
     function toOneArgVisit(visitFunction) {
-        return visitFunction ? function (arg) { return visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()); } : function () { return true; };
+        return visitFunction ? (arg) => visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+    }
+    function toOneArgVisitWithPath(visitFunction) {
+        return visitFunction ? (arg) => visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
     }
-    var onObjectBegin = toNoArgVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisit(visitor.onObjectProperty), onObjectEnd = toNoArgVisit(visitor.onObjectEnd), onArrayBegin = toNoArgVisit(visitor.onArrayBegin), onArrayEnd = toNoArgVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisit(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
-    var disallowComments = options && options.disallowComments;
-    var allowTrailingComma = options && options.allowTrailingComma;
+    const onObjectBegin = toNoArgVisitWithPath(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toNoArgVisit(visitor.onObjectEnd), onArrayBegin = toNoArgVisitWithPath(visitor.onArrayBegin), onArrayEnd = toNoArgVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+    const disallowComments = options && options.disallowComments;
+    const allowTrailingComma = options && options.allowTrailingComma;
     function scanNext() {
         while (true) {
-            var token = _scanner.scan();
+            const token = _scanner.scan();
             switch (_scanner.getTokenError()) {
-                case 4 /* InvalidUnicode */:
-                    handleError(14 /* InvalidUnicode */);
+                case 4 /* ScanError.InvalidUnicode */:
+                    handleError(14 /* ParseErrorCode.InvalidUnicode */);
                     break;
-                case 5 /* InvalidEscapeCharacter */:
-                    handleError(15 /* InvalidEscapeCharacter */);
+                case 5 /* ScanError.InvalidEscapeCharacter */:
+                    handleError(15 /* ParseErrorCode.InvalidEscapeCharacter */);
                     break;
-                case 3 /* UnexpectedEndOfNumber */:
-                    handleError(13 /* UnexpectedEndOfNumber */);
+                case 3 /* ScanError.UnexpectedEndOfNumber */:
+                    handleError(13 /* ParseErrorCode.UnexpectedEndOfNumber */);
                     break;
-                case 1 /* UnexpectedEndOfComment */:
+                case 1 /* ScanError.UnexpectedEndOfComment */:
                     if (!disallowComments) {
-                        handleError(11 /* UnexpectedEndOfComment */);
+                        handleError(11 /* ParseErrorCode.UnexpectedEndOfComment */);
                     }
                     break;
-                case 2 /* UnexpectedEndOfString */:
-                    handleError(12 /* UnexpectedEndOfString */);
+                case 2 /* ScanError.UnexpectedEndOfString */:
+                    handleError(12 /* ParseErrorCode.UnexpectedEndOfString */);
                     break;
-                case 6 /* InvalidCharacter */:
-                    handleError(16 /* InvalidCharacter */);
+                case 6 /* ScanError.InvalidCharacter */:
+                    handleError(16 /* ParseErrorCode.InvalidCharacter */);
                     break;
             }
             switch (token) {
-                case 12 /* LineCommentTrivia */:
-                case 13 /* BlockCommentTrivia */:
+                case 12 /* SyntaxKind.LineCommentTrivia */:
+                case 13 /* SyntaxKind.BlockCommentTrivia */:
                     if (disallowComments) {
-                        handleError(10 /* InvalidCommentToken */);
+                        handleError(10 /* ParseErrorCode.InvalidCommentToken */);
                     }
                     else {
                         onComment();
                     }
                     break;
-                case 16 /* Unknown */:
-                    handleError(1 /* InvalidSymbol */);
+                case 16 /* SyntaxKind.Unknown */:
+                    handleError(1 /* ParseErrorCode.InvalidSymbol */);
                     break;
-                case 15 /* Trivia */:
-                case 14 /* LineBreakTrivia */:
+                case 15 /* SyntaxKind.Trivia */:
+                case 14 /* SyntaxKind.LineBreakTrivia */:
                     break;
                 default:
                     return token;
             }
         }
     }
-    function handleError(error, skipUntilAfter, skipUntil) {
-        if (skipUntilAfter === void 0) { skipUntilAfter = []; }
-        if (skipUntil === void 0) { skipUntil = []; }
+    function handleError(error, skipUntilAfter = [], skipUntil = []) {
         onError(error);
         if (skipUntilAfter.length + skipUntil.length > 0) {
-            var token = _scanner.getToken();
-            while (token !== 17 /* EOF */) {
+            let token = _scanner.getToken();
+            while (token !== 17 /* SyntaxKind.EOF */) {
                 if (skipUntilAfter.indexOf(token) !== -1) {
                     scanNext();
                     break;
@@ -1360,39 +1576,36 @@ function visit(text, visitor, options) {
         }
     }
     function parseString(isValue) {
-        var value = _scanner.getTokenValue();
+        const value = _scanner.getTokenValue();
         if (isValue) {
             onLiteralValue(value);
         }
         else {
             onObjectProperty(value);
+            // add property name afterwards
+            _jsonPath.push(value);
         }
         scanNext();
         return true;
     }
     function parseLiteral() {
         switch (_scanner.getToken()) {
-            case 11 /* NumericLiteral */:
-                var value = 0;
-                try {
-                    value = JSON.parse(_scanner.getTokenValue());
-                    if (typeof value !== 'number') {
-                        handleError(2 /* InvalidNumberFormat */);
-                        value = 0;
-                    }
-                }
-                catch (e) {
-                    handleError(2 /* InvalidNumberFormat */);
+            case 11 /* SyntaxKind.NumericLiteral */:
+                const tokenValue = _scanner.getTokenValue();
+                let value = Number(tokenValue);
+                if (isNaN(value)) {
+                    handleError(2 /* ParseErrorCode.InvalidNumberFormat */);
+                    value = 0;
                 }
                 onLiteralValue(value);
                 break;
-            case 7 /* NullKeyword */:
+            case 7 /* SyntaxKind.NullKeyword */:
                 onLiteralValue(null);
                 break;
-            case 8 /* TrueKeyword */:
+            case 8 /* SyntaxKind.TrueKeyword */:
                 onLiteralValue(true);
                 break;
-            case 9 /* FalseKeyword */:
+            case 9 /* SyntaxKind.FalseKeyword */:
                 onLiteralValue(false);
                 break;
             default:
@@ -1402,49 +1615,50 @@ function visit(text, visitor, options) {
         return true;
     }
     function parseProperty() {
-        if (_scanner.getToken() !== 10 /* StringLiteral */) {
-            handleError(3 /* PropertyNameExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
+        if (_scanner.getToken() !== 10 /* SyntaxKind.StringLiteral */) {
+            handleError(3 /* ParseErrorCode.PropertyNameExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
             return false;
         }
         parseString(false);
-        if (_scanner.getToken() === 6 /* ColonToken */) {
+        if (_scanner.getToken() === 6 /* SyntaxKind.ColonToken */) {
             onSeparator(':');
             scanNext(); // consume colon
             if (!parseValue()) {
-                handleError(4 /* ValueExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
+                handleError(4 /* ParseErrorCode.ValueExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
             }
         }
         else {
-            handleError(5 /* ColonExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
+            handleError(5 /* ParseErrorCode.ColonExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
         }
+        _jsonPath.pop(); // remove processed property name
         return true;
     }
     function parseObject() {
         onObjectBegin();
         scanNext(); // consume open brace
-        var needsComma = false;
-        while (_scanner.getToken() !== 2 /* CloseBraceToken */ && _scanner.getToken() !== 17 /* EOF */) {
-            if (_scanner.getToken() === 5 /* CommaToken */) {
+        let needsComma = false;
+        while (_scanner.getToken() !== 2 /* SyntaxKind.CloseBraceToken */ && _scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
+            if (_scanner.getToken() === 5 /* SyntaxKind.CommaToken */) {
                 if (!needsComma) {
-                    handleError(4 /* ValueExpected */, [], []);
+                    handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
                 }
                 onSeparator(',');
                 scanNext(); // consume comma
-                if (_scanner.getToken() === 2 /* CloseBraceToken */ && allowTrailingComma) {
+                if (_scanner.getToken() === 2 /* SyntaxKind.CloseBraceToken */ && allowTrailingComma) {
                     break;
                 }
             }
             else if (needsComma) {
-                handleError(6 /* CommaExpected */, [], []);
+                handleError(6 /* ParseErrorCode.CommaExpected */, [], []);
             }
             if (!parseProperty()) {
-                handleError(4 /* ValueExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
+                handleError(4 /* ParseErrorCode.ValueExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
             }
             needsComma = true;
         }
         onObjectEnd();
-        if (_scanner.getToken() !== 2 /* CloseBraceToken */) {
-            handleError(7 /* CloseBraceExpected */, [2 /* CloseBraceToken */], []);
+        if (_scanner.getToken() !== 2 /* SyntaxKind.CloseBraceToken */) {
+            handleError(7 /* ParseErrorCode.CloseBraceExpected */, [2 /* SyntaxKind.CloseBraceToken */], []);
         }
         else {
             scanNext(); // consume close brace
@@ -1454,29 +1668,40 @@ function visit(text, visitor, options) {
     function parseArray() {
         onArrayBegin();
         scanNext(); // consume open bracket
-        var needsComma = false;
-        while (_scanner.getToken() !== 4 /* CloseBracketToken */ && _scanner.getToken() !== 17 /* EOF */) {
-            if (_scanner.getToken() === 5 /* CommaToken */) {
+        let isFirstElement = true;
+        let needsComma = false;
+        while (_scanner.getToken() !== 4 /* SyntaxKind.CloseBracketToken */ && _scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
+            if (_scanner.getToken() === 5 /* SyntaxKind.CommaToken */) {
                 if (!needsComma) {
-                    handleError(4 /* ValueExpected */, [], []);
+                    handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
                 }
                 onSeparator(',');
                 scanNext(); // consume comma
-                if (_scanner.getToken() === 4 /* CloseBracketToken */ && allowTrailingComma) {
+                if (_scanner.getToken() === 4 /* SyntaxKind.CloseBracketToken */ && allowTrailingComma) {
                     break;
                 }
             }
             else if (needsComma) {
-                handleError(6 /* CommaExpected */, [], []);
+                handleError(6 /* ParseErrorCode.CommaExpected */, [], []);
+            }
+            if (isFirstElement) {
+                _jsonPath.push(0);
+                isFirstElement = false;
+            }
+            else {
+                _jsonPath[_jsonPath.length - 1]++;
             }
             if (!parseValue()) {
-                handleError(4 /* ValueExpected */, [], [4 /* CloseBracketToken */, 5 /* CommaToken */]);
+                handleError(4 /* ParseErrorCode.ValueExpected */, [], [4 /* SyntaxKind.CloseBracketToken */, 5 /* SyntaxKind.CommaToken */]);
             }
             needsComma = true;
         }
         onArrayEnd();
-        if (_scanner.getToken() !== 4 /* CloseBracketToken */) {
-            handleError(8 /* CloseBracketExpected */, [4 /* CloseBracketToken */], []);
+        if (!isFirstElement) {
+            _jsonPath.pop(); // remove array index
+        }
+        if (_scanner.getToken() !== 4 /* SyntaxKind.CloseBracketToken */) {
+            handleError(8 /* ParseErrorCode.CloseBracketExpected */, [4 /* SyntaxKind.CloseBracketToken */], []);
         }
         else {
             scanNext(); // consume close bracket
@@ -1485,30 +1710,30 @@ function visit(text, visitor, options) {
     }
     function parseValue() {
         switch (_scanner.getToken()) {
-            case 3 /* OpenBracketToken */:
+            case 3 /* SyntaxKind.OpenBracketToken */:
                 return parseArray();
-            case 1 /* OpenBraceToken */:
+            case 1 /* SyntaxKind.OpenBraceToken */:
                 return parseObject();
-            case 10 /* StringLiteral */:
+            case 10 /* SyntaxKind.StringLiteral */:
                 return parseString(true);
             default:
                 return parseLiteral();
         }
     }
     scanNext();
-    if (_scanner.getToken() === 17 /* EOF */) {
+    if (_scanner.getToken() === 17 /* SyntaxKind.EOF */) {
         if (options.allowEmptyContent) {
             return true;
         }
-        handleError(4 /* ValueExpected */, [], []);
+        handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
         return false;
     }
     if (!parseValue()) {
-        handleError(4 /* ValueExpected */, [], []);
+        handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
         return false;
     }
-    if (_scanner.getToken() !== 17 /* EOF */) {
-        handleError(9 /* EndOfFileExpected */, [], []);
+    if (_scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
+        handleError(9 /* ParseErrorCode.EndOfFileExpected */, [], []);
     }
     return true;
 }
@@ -1518,14 +1743,14 @@ function visit(text, visitor, options) {
  * of comments with a replaceCharacter
  */
 function stripComments(text, replaceCh) {
-    var _scanner = (0,_scanner__WEBPACK_IMPORTED_MODULE_0__.createScanner)(text), parts = [], kind, offset = 0, pos;
+    let _scanner = (0,_scanner__WEBPACK_IMPORTED_MODULE_0__.createScanner)(text), parts = [], kind, offset = 0, pos;
     do {
         pos = _scanner.getPosition();
         kind = _scanner.scan();
         switch (kind) {
-            case 12 /* LineCommentTrivia */:
-            case 13 /* BlockCommentTrivia */:
-            case 17 /* EOF */:
+            case 12 /* SyntaxKind.LineCommentTrivia */:
+            case 13 /* SyntaxKind.BlockCommentTrivia */:
+            case 17 /* SyntaxKind.EOF */:
                 if (offset !== pos) {
                     parts.push(text.substring(offset, pos));
                 }
@@ -1535,7 +1760,7 @@ function stripComments(text, replaceCh) {
                 offset = _scanner.getPosition();
                 break;
         }
-    } while (kind !== 17 /* EOF */);
+    } while (kind !== 17 /* SyntaxKind.EOF */);
     return parts.join('');
 }
 function getNodeType(value) {
@@ -2602,137 +2827,137 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _octokit_request__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(18);
 /* harmony import */ var _octokit_graphql__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(27);
 /* harmony import */ var _octokit_auth_token__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(28);
+// pkg/dist-src/index.js
 
 
 
 
 
 
-const VERSION = "4.1.0";
+// pkg/dist-src/version.js
+var VERSION = "4.2.4";
 
-class Octokit {
-    constructor(options = {}) {
-        const hook = new before_after_hook__WEBPACK_IMPORTED_MODULE_0__.Collection();
-        const requestDefaults = {
-            baseUrl: _octokit_request__WEBPACK_IMPORTED_MODULE_1__.request.endpoint.DEFAULTS.baseUrl,
-            headers: {},
-            request: Object.assign({}, options.request, {
-                // @ts-ignore internal usage only, no need to type
-                hook: hook.bind(null, "request"),
-            }),
-            mediaType: {
-                previews: [],
-                format: "",
-            },
-        };
-        // prepend default user agent with `options.userAgent` if set
-        requestDefaults.headers["user-agent"] = [
-            options.userAgent,
-            `octokit-core.js/${VERSION} ${(0,universal_user_agent__WEBPACK_IMPORTED_MODULE_2__.getUserAgent)()}`,
-        ]
-            .filter(Boolean)
-            .join(" ");
-        if (options.baseUrl) {
-            requestDefaults.baseUrl = options.baseUrl;
-        }
-        if (options.previews) {
-            requestDefaults.mediaType.previews = options.previews;
-        }
-        if (options.timeZone) {
-            requestDefaults.headers["time-zone"] = options.timeZone;
-        }
-        this.request = _octokit_request__WEBPACK_IMPORTED_MODULE_1__.request.defaults(requestDefaults);
-        this.graphql = (0,_octokit_graphql__WEBPACK_IMPORTED_MODULE_3__.withCustomRequest)(this.request).defaults(requestDefaults);
-        this.log = Object.assign({
-            debug: () => { },
-            info: () => { },
-            warn: console.warn.bind(console),
-            error: console.error.bind(console),
-        }, options.log);
-        this.hook = hook;
-        // (1) If neither `options.authStrategy` nor `options.auth` are set, the `octokit` instance
-        //     is unauthenticated. The `this.auth()` method is a no-op and no request hook is registered.
-        // (2) If only `options.auth` is set, use the default token authentication strategy.
-        // (3) If `options.authStrategy` is set then use it and pass in `options.auth`. Always pass own request as many strategies accept a custom request instance.
-        // TODO: type `options.auth` based on `options.authStrategy`.
-        if (!options.authStrategy) {
-            if (!options.auth) {
-                // (1)
-                this.auth = async () => ({
-                    type: "unauthenticated",
-                });
-            }
-            else {
-                // (2)
-                const auth = (0,_octokit_auth_token__WEBPACK_IMPORTED_MODULE_4__.createTokenAuth)(options.auth);
-                // @ts-ignore  ¯\_(ツ)_/¯
-                hook.wrap("request", auth.hook);
-                this.auth = auth;
-            }
+// pkg/dist-src/index.js
+var Octokit = class {
+  static defaults(defaults) {
+    const OctokitWithDefaults = class extends this {
+      constructor(...args) {
+        const options = args[0] || {};
+        if (typeof defaults === "function") {
+          super(defaults(options));
+          return;
         }
-        else {
-            const { authStrategy, ...otherOptions } = options;
-            const auth = authStrategy(Object.assign({
-                request: this.request,
-                log: this.log,
-                // we pass the current octokit instance as well as its constructor options
-                // to allow for authentication strategies that return a new octokit instance
-                // that shares the same internal state as the current one. The original
-                // requirement for this was the "event-octokit" authentication strategy
-                // of https://github.com/probot/octokit-auth-probot.
-                octokit: this,
-                octokitOptions: otherOptions,
-            }, options.auth));
-            // @ts-ignore  ¯\_(ツ)_/¯
-            hook.wrap("request", auth.hook);
-            this.auth = auth;
-        }
-        // apply plugins
-        // https://stackoverflow.com/a/16345172
-        const classConstructor = this.constructor;
-        classConstructor.plugins.forEach((plugin) => {
-            Object.assign(this, plugin(this, options));
+        super(
+          Object.assign(
+            {},
+            defaults,
+            options,
+            options.userAgent && defaults.userAgent ? {
+              userAgent: `${options.userAgent} ${defaults.userAgent}`
+            } : null
+          )
+        );
+      }
+    };
+    return OctokitWithDefaults;
+  }
+  /**
+   * Attach a plugin (or many) to your Octokit instance.
+   *
+   * @example
+   * const API = Octokit.plugin(plugin1, plugin2, plugin3, ...)
+   */
+  static plugin(...newPlugins) {
+    var _a;
+    const currentPlugins = this.plugins;
+    const NewOctokit = (_a = class extends this {
+    }, _a.plugins = currentPlugins.concat(
+      newPlugins.filter((plugin) => !currentPlugins.includes(plugin))
+    ), _a);
+    return NewOctokit;
+  }
+  constructor(options = {}) {
+    const hook = new before_after_hook__WEBPACK_IMPORTED_MODULE_0__.Collection();
+    const requestDefaults = {
+      baseUrl: _octokit_request__WEBPACK_IMPORTED_MODULE_1__.request.endpoint.DEFAULTS.baseUrl,
+      headers: {},
+      request: Object.assign({}, options.request, {
+        // @ts-ignore internal usage only, no need to type
+        hook: hook.bind(null, "request")
+      }),
+      mediaType: {
+        previews: [],
+        format: ""
+      }
+    };
+    requestDefaults.headers["user-agent"] = [
+      options.userAgent,
+      `octokit-core.js/${VERSION} ${(0,universal_user_agent__WEBPACK_IMPORTED_MODULE_2__.getUserAgent)()}`
+    ].filter(Boolean).join(" ");
+    if (options.baseUrl) {
+      requestDefaults.baseUrl = options.baseUrl;
+    }
+    if (options.previews) {
+      requestDefaults.mediaType.previews = options.previews;
+    }
+    if (options.timeZone) {
+      requestDefaults.headers["time-zone"] = options.timeZone;
+    }
+    this.request = _octokit_request__WEBPACK_IMPORTED_MODULE_1__.request.defaults(requestDefaults);
+    this.graphql = (0,_octokit_graphql__WEBPACK_IMPORTED_MODULE_3__.withCustomRequest)(this.request).defaults(requestDefaults);
+    this.log = Object.assign(
+      {
+        debug: () => {
+        },
+        info: () => {
+        },
+        warn: console.warn.bind(console),
+        error: console.error.bind(console)
+      },
+      options.log
+    );
+    this.hook = hook;
+    if (!options.authStrategy) {
+      if (!options.auth) {
+        this.auth = async () => ({
+          type: "unauthenticated"
         });
-    }
-    static defaults(defaults) {
-        const OctokitWithDefaults = class extends this {
-            constructor(...args) {
-                const options = args[0] || {};
-                if (typeof defaults === "function") {
-                    super(defaults(options));
-                    return;
-                }
-                super(Object.assign({}, defaults, options, options.userAgent && defaults.userAgent
-                    ? {
-                        userAgent: `${options.userAgent} ${defaults.userAgent}`,
-                    }
-                    : null));
-            }
-        };
-        return OctokitWithDefaults;
-    }
-    /**
-     * Attach a plugin (or many) to your Octokit instance.
-     *
-     * @example
-     * const API = Octokit.plugin(plugin1, plugin2, plugin3, ...)
-     */
-    static plugin(...newPlugins) {
-        var _a;
-        const currentPlugins = this.plugins;
-        const NewOctokit = (_a = class extends this {
-            },
-            _a.plugins = currentPlugins.concat(newPlugins.filter((plugin) => !currentPlugins.includes(plugin))),
-            _a);
-        return NewOctokit;
-    }
-}
+      } else {
+        const auth = (0,_octokit_auth_token__WEBPACK_IMPORTED_MODULE_4__.createTokenAuth)(options.auth);
+        hook.wrap("request", auth.hook);
+        this.auth = auth;
+      }
+    } else {
+      const { authStrategy, ...otherOptions } = options;
+      const auth = authStrategy(
+        Object.assign(
+          {
+            request: this.request,
+            log: this.log,
+            // we pass the current octokit instance as well as its constructor options
+            // to allow for authentication strategies that return a new octokit instance
+            // that shares the same internal state as the current one. The original
+            // requirement for this was the "event-octokit" authentication strategy
+            // of https://github.com/probot/octokit-auth-probot.
+            octokit: this,
+            octokitOptions: otherOptions
+          },
+          options.auth
+        )
+      );
+      hook.wrap("request", auth.hook);
+      this.auth = auth;
+    }
+    const classConstructor = this.constructor;
+    classConstructor.plugins.forEach((plugin) => {
+      Object.assign(this, plugin(this, options));
+    });
+  }
+};
 Octokit.VERSION = VERSION;
 Octokit.plugins = [];
 
 
-//# sourceMappingURL=index.js.map
-
 
 /***/ }),
 /* 14 */
@@ -2926,169 +3151,177 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var node_fetch__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(20);
 /* harmony import */ var node_fetch__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(node_fetch__WEBPACK_IMPORTED_MODULE_1__);
 /* harmony import */ var _octokit_request_error__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(21);
+// pkg/dist-src/index.js
+
 
 
+// pkg/dist-src/version.js
+var VERSION = "6.2.8";
 
+// pkg/dist-src/fetch-wrapper.js
 
 
 
-const VERSION = "6.2.2";
 
+// pkg/dist-src/get-buffer-response.js
 function getBufferResponse(response) {
-    return response.arrayBuffer();
+  return response.arrayBuffer();
 }
 
+// pkg/dist-src/fetch-wrapper.js
 function fetchWrapper(requestOptions) {
-    const log = requestOptions.request && requestOptions.request.log
-        ? requestOptions.request.log
-        : console;
-    if ((0,is_plain_object__WEBPACK_IMPORTED_MODULE_0__.isPlainObject)(requestOptions.body) ||
-        Array.isArray(requestOptions.body)) {
-        requestOptions.body = JSON.stringify(requestOptions.body);
-    }
-    let headers = {};
-    let status;
-    let url;
-    const fetch = (requestOptions.request && requestOptions.request.fetch) ||
-        globalThis.fetch ||
-        /* istanbul ignore next */ (node_fetch__WEBPACK_IMPORTED_MODULE_1___default());
-    return fetch(requestOptions.url, Object.assign({
+  const log = requestOptions.request && requestOptions.request.log ? requestOptions.request.log : console;
+  if ((0,is_plain_object__WEBPACK_IMPORTED_MODULE_0__.isPlainObject)(requestOptions.body) || Array.isArray(requestOptions.body)) {
+    requestOptions.body = JSON.stringify(requestOptions.body);
+  }
+  let headers = {};
+  let status;
+  let url;
+  const fetch = requestOptions.request && requestOptions.request.fetch || globalThis.fetch || /* istanbul ignore next */
+  (node_fetch__WEBPACK_IMPORTED_MODULE_1___default());
+  return fetch(
+    requestOptions.url,
+    Object.assign(
+      {
         method: requestOptions.method,
         body: requestOptions.body,
         headers: requestOptions.headers,
         redirect: requestOptions.redirect,
-    }, 
-    // `requestOptions.request.agent` type is incompatible
-    // see https://github.com/octokit/types.ts/pull/264
-    requestOptions.request))
-        .then(async (response) => {
-        url = response.url;
-        status = response.status;
-        for (const keyAndValue of response.headers) {
-            headers[keyAndValue[0]] = keyAndValue[1];
-        }
-        if ("deprecation" in headers) {
-            const matches = headers.link && headers.link.match(/<([^>]+)>; rel="deprecation"/);
-            const deprecationLink = matches && matches.pop();
-            log.warn(`[@octokit/request] "${requestOptions.method} ${requestOptions.url}" is deprecated. It is scheduled to be removed on ${headers.sunset}${deprecationLink ? `. See ${deprecationLink}` : ""}`);
-        }
-        if (status === 204 || status === 205) {
-            return;
-        }
-        // GitHub API returns 200 for HEAD requests
-        if (requestOptions.method === "HEAD") {
-            if (status < 400) {
-                return;
-            }
-            throw new _octokit_request_error__WEBPACK_IMPORTED_MODULE_2__.RequestError(response.statusText, status, {
-                response: {
-                    url,
-                    status,
-                    headers,
-                    data: undefined,
-                },
-                request: requestOptions,
-            });
-        }
-        if (status === 304) {
-            throw new _octokit_request_error__WEBPACK_IMPORTED_MODULE_2__.RequestError("Not modified", status, {
-                response: {
-                    url,
-                    status,
-                    headers,
-                    data: await getResponseData(response),
-                },
-                request: requestOptions,
-            });
-        }
-        if (status >= 400) {
-            const data = await getResponseData(response);
-            const error = new _octokit_request_error__WEBPACK_IMPORTED_MODULE_2__.RequestError(toErrorMessage(data), status, {
-                response: {
-                    url,
-                    status,
-                    headers,
-                    data,
-                },
-                request: requestOptions,
-            });
-            throw error;
-        }
-        return getResponseData(response);
-    })
-        .then((data) => {
-        return {
-            status,
-            url,
-            headers,
-            data,
-        };
-    })
-        .catch((error) => {
-        if (error instanceof _octokit_request_error__WEBPACK_IMPORTED_MODULE_2__.RequestError)
-            throw error;
-        else if (error.name === "AbortError")
-            throw error;
-        throw new _octokit_request_error__WEBPACK_IMPORTED_MODULE_2__.RequestError(error.message, 500, {
-            request: requestOptions,
-        });
+        // duplex must be set if request.body is ReadableStream or Async Iterables.
+        // See https://fetch.spec.whatwg.org/#dom-requestinit-duplex.
+        ...requestOptions.body && { duplex: "half" }
+      },
+      // `requestOptions.request.agent` type is incompatible
+      // see https://github.com/octokit/types.ts/pull/264
+      requestOptions.request
+    )
+  ).then(async (response) => {
+    url = response.url;
+    status = response.status;
+    for (const keyAndValue of response.headers) {
+      headers[keyAndValue[0]] = keyAndValue[1];
+    }
+    if ("deprecation" in headers) {
+      const matches = headers.link && headers.link.match(/<([^>]+)>; rel="deprecation"/);
+      const deprecationLink = matches && matches.pop();
+      log.warn(
+        `[@octokit/request] "${requestOptions.method} ${requestOptions.url}" is deprecated. It is scheduled to be removed on ${headers.sunset}${deprecationLink ? `. See ${deprecationLink}` : ""}`
+      );
+    }
+    if (status === 204 || status === 205) {
+      return;
+    }
+    if (requestOptions.method === "HEAD") {
+      if (status < 400) {
+        return;
+      }
+      throw new _octokit_request_error__WEBPACK_IMPORTED_MODULE_2__.RequestError(response.statusText, status, {
+        response: {
+          url,
+          status,
+          headers,
+          data: void 0
+        },
+        request: requestOptions
+      });
+    }
+    if (status === 304) {
+      throw new _octokit_request_error__WEBPACK_IMPORTED_MODULE_2__.RequestError("Not modified", status, {
+        response: {
+          url,
+          status,
+          headers,
+          data: await getResponseData(response)
+        },
+        request: requestOptions
+      });
+    }
+    if (status >= 400) {
+      const data = await getResponseData(response);
+      const error = new _octokit_request_error__WEBPACK_IMPORTED_MODULE_2__.RequestError(toErrorMessage(data), status, {
+        response: {
+          url,
+          status,
+          headers,
+          data
+        },
+        request: requestOptions
+      });
+      throw error;
+    }
+    return getResponseData(response);
+  }).then((data) => {
+    return {
+      status,
+      url,
+      headers,
+      data
+    };
+  }).catch((error) => {
+    if (error instanceof _octokit_request_error__WEBPACK_IMPORTED_MODULE_2__.RequestError)
+      throw error;
+    else if (error.name === "AbortError")
+      throw error;
+    throw new _octokit_request_error__WEBPACK_IMPORTED_MODULE_2__.RequestError(error.message, 500, {
+      request: requestOptions
     });
+  });
 }
 async function getResponseData(response) {
-    const contentType = response.headers.get("content-type");
-    if (/application\/json/.test(contentType)) {
-        return response.json();
-    }
-    if (!contentType || /^text\/|charset=utf-8$/.test(contentType)) {
-        return response.text();
-    }
-    return getBufferResponse(response);
+  const contentType = response.headers.get("content-type");
+  if (/application\/json/.test(contentType)) {
+    return response.json();
+  }
+  if (!contentType || /^text\/|charset=utf-8$/.test(contentType)) {
+    return response.text();
+  }
+  return getBufferResponse(response);
 }
 function toErrorMessage(data) {
-    if (typeof data === "string")
-        return data;
-    // istanbul ignore else - just in case
-    if ("message" in data) {
-        if (Array.isArray(data.errors)) {
-            return `${data.message}: ${data.errors.map(JSON.stringify).join(", ")}`;
-        }
-        return data.message;
+  if (typeof data === "string")
+    return data;
+  if ("message" in data) {
+    if (Array.isArray(data.errors)) {
+      return `${data.message}: ${data.errors.map(JSON.stringify).join(", ")}`;
     }
-    // istanbul ignore next - just in case
-    return `Unknown error: ${JSON.stringify(data)}`;
+    return data.message;
+  }
+  return `Unknown error: ${JSON.stringify(data)}`;
 }
 
+// pkg/dist-src/with-defaults.js
 function withDefaults(oldEndpoint, newDefaults) {
-    const endpoint = oldEndpoint.defaults(newDefaults);
-    const newApi = function (route, parameters) {
-        const endpointOptions = endpoint.merge(route, parameters);
-        if (!endpointOptions.request || !endpointOptions.request.hook) {
-            return fetchWrapper(endpoint.parse(endpointOptions));
-        }
-        const request = (route, parameters) => {
-            return fetchWrapper(endpoint.parse(endpoint.merge(route, parameters)));
-        };
-        Object.assign(request, {
-            endpoint,
-            defaults: withDefaults.bind(null, endpoint),
-        });
-        return endpointOptions.request.hook(request, endpointOptions);
+  const endpoint2 = oldEndpoint.defaults(newDefaults);
+  const newApi = function(route, parameters) {
+    const endpointOptions = endpoint2.merge(route, parameters);
+    if (!endpointOptions.request || !endpointOptions.request.hook) {
+      return fetchWrapper(endpoint2.parse(endpointOptions));
+    }
+    const request2 = (route2, parameters2) => {
+      return fetchWrapper(
+        endpoint2.parse(endpoint2.merge(route2, parameters2))
+      );
     };
-    return Object.assign(newApi, {
-        endpoint,
-        defaults: withDefaults.bind(null, endpoint),
+    Object.assign(request2, {
+      endpoint: endpoint2,
+      defaults: withDefaults.bind(null, endpoint2)
     });
+    return endpointOptions.request.hook(request2, endpointOptions);
+  };
+  return Object.assign(newApi, {
+    endpoint: endpoint2,
+    defaults: withDefaults.bind(null, endpoint2)
+  });
 }
 
-const request = withDefaults(_octokit_endpoint__WEBPACK_IMPORTED_MODULE_3__.endpoint, {
-    headers: {
-        "user-agent": `octokit-request.js/${VERSION} ${(0,universal_user_agent__WEBPACK_IMPORTED_MODULE_4__.getUserAgent)()}`,
-    },
+// pkg/dist-src/index.js
+var request = withDefaults(_octokit_endpoint__WEBPACK_IMPORTED_MODULE_3__.endpoint, {
+  headers: {
+    "user-agent": `octokit-request.js/${VERSION} ${(0,universal_user_agent__WEBPACK_IMPORTED_MODULE_4__.getUserAgent)()}`
+  }
 });
 
 
-//# sourceMappingURL=index.js.map
-
 
 /***/ }),
 /* 19 */
@@ -3159,7 +3392,7 @@ module.exports = exports = globalObject.fetch;
 
 // Needed for TypeScript and Webpack.
 if (globalObject.fetch) {
-	exports["default"] = globalObject.fetch.bind(__webpack_require__.g);
+	exports["default"] = globalObject.fetch.bind(globalObject);
 }
 
 exports.Headers = globalObject.Headers;
@@ -3365,384 +3598,332 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ });
 /* harmony import */ var is_plain_object__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(19);
 /* harmony import */ var universal_user_agent__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(26);
-
-
-
+// pkg/dist-src/util/lowercase-keys.js
 function lowercaseKeys(object) {
-    if (!object) {
-        return {};
-    }
-    return Object.keys(object).reduce((newObj, key) => {
-        newObj[key.toLowerCase()] = object[key];
-        return newObj;
-    }, {});
+  if (!object) {
+    return {};
+  }
+  return Object.keys(object).reduce((newObj, key) => {
+    newObj[key.toLowerCase()] = object[key];
+    return newObj;
+  }, {});
 }
 
+// pkg/dist-src/util/merge-deep.js
+
 function mergeDeep(defaults, options) {
-    const result = Object.assign({}, defaults);
-    Object.keys(options).forEach((key) => {
-        if ((0,is_plain_object__WEBPACK_IMPORTED_MODULE_0__.isPlainObject)(options[key])) {
-            if (!(key in defaults))
-                Object.assign(result, { [key]: options[key] });
-            else
-                result[key] = mergeDeep(defaults[key], options[key]);
-        }
-        else {
-            Object.assign(result, { [key]: options[key] });
-        }
-    });
-    return result;
+  const result = Object.assign({}, defaults);
+  Object.keys(options).forEach((key) => {
+    if ((0,is_plain_object__WEBPACK_IMPORTED_MODULE_0__.isPlainObject)(options[key])) {
+      if (!(key in defaults))
+        Object.assign(result, { [key]: options[key] });
+      else
+        result[key] = mergeDeep(defaults[key], options[key]);
+    } else {
+      Object.assign(result, { [key]: options[key] });
+    }
+  });
+  return result;
 }
 
+// pkg/dist-src/util/remove-undefined-properties.js
 function removeUndefinedProperties(obj) {
-    for (const key in obj) {
-        if (obj[key] === undefined) {
-            delete obj[key];
-        }
+  for (const key in obj) {
+    if (obj[key] === void 0) {
+      delete obj[key];
     }
-    return obj;
+  }
+  return obj;
 }
 
+// pkg/dist-src/merge.js
 function merge(defaults, route, options) {
-    if (typeof route === "string") {
-        let [method, url] = route.split(" ");
-        options = Object.assign(url ? { method, url } : { url: method }, options);
-    }
-    else {
-        options = Object.assign({}, route);
-    }
-    // lowercase header names before merging with defaults to avoid duplicates
-    options.headers = lowercaseKeys(options.headers);
-    // remove properties with undefined values before merging
-    removeUndefinedProperties(options);
-    removeUndefinedProperties(options.headers);
-    const mergedOptions = mergeDeep(defaults || {}, options);
-    // mediaType.previews arrays are merged, instead of overwritten
-    if (defaults && defaults.mediaType.previews.length) {
-        mergedOptions.mediaType.previews = defaults.mediaType.previews
-            .filter((preview) => !mergedOptions.mediaType.previews.includes(preview))
-            .concat(mergedOptions.mediaType.previews);
-    }
-    mergedOptions.mediaType.previews = mergedOptions.mediaType.previews.map((preview) => preview.replace(/-preview/, ""));
-    return mergedOptions;
+  if (typeof route === "string") {
+    let [method, url] = route.split(" ");
+    options = Object.assign(url ? { method, url } : { url: method }, options);
+  } else {
+    options = Object.assign({}, route);
+  }
+  options.headers = lowercaseKeys(options.headers);
+  removeUndefinedProperties(options);
+  removeUndefinedProperties(options.headers);
+  const mergedOptions = mergeDeep(defaults || {}, options);
+  if (defaults && defaults.mediaType.previews.length) {
+    mergedOptions.mediaType.previews = defaults.mediaType.previews.filter((preview) => !mergedOptions.mediaType.previews.includes(preview)).concat(mergedOptions.mediaType.previews);
+  }
+  mergedOptions.mediaType.previews = mergedOptions.mediaType.previews.map(
+    (preview) => preview.replace(/-preview/, "")
+  );
+  return mergedOptions;
 }
 
+// pkg/dist-src/util/add-query-parameters.js
 function addQueryParameters(url, parameters) {
-    const separator = /\?/.test(url) ? "&" : "?";
-    const names = Object.keys(parameters);
-    if (names.length === 0) {
-        return url;
-    }
-    return (url +
-        separator +
-        names
-            .map((name) => {
-            if (name === "q") {
-                return ("q=" + parameters.q.split("+").map(encodeURIComponent).join("+"));
-            }
-            return `${name}=${encodeURIComponent(parameters[name])}`;
-        })
-            .join("&"));
+  const separator = /\?/.test(url) ? "&" : "?";
+  const names = Object.keys(parameters);
+  if (names.length === 0) {
+    return url;
+  }
+  return url + separator + names.map((name) => {
+    if (name === "q") {
+      return "q=" + parameters.q.split("+").map(encodeURIComponent).join("+");
+    }
+    return `${name}=${encodeURIComponent(parameters[name])}`;
+  }).join("&");
 }
 
-const urlVariableRegex = /\{[^}]+\}/g;
+// pkg/dist-src/util/extract-url-variable-names.js
+var urlVariableRegex = /\{[^}]+\}/g;
 function removeNonChars(variableName) {
-    return variableName.replace(/^\W+|\W+$/g, "").split(/,/);
+  return variableName.replace(/^\W+|\W+$/g, "").split(/,/);
 }
 function extractUrlVariableNames(url) {
-    const matches = url.match(urlVariableRegex);
-    if (!matches) {
-        return [];
-    }
-    return matches.map(removeNonChars).reduce((a, b) => a.concat(b), []);
+  const matches = url.match(urlVariableRegex);
+  if (!matches) {
+    return [];
+  }
+  return matches.map(removeNonChars).reduce((a, b) => a.concat(b), []);
 }
 
+// pkg/dist-src/util/omit.js
 function omit(object, keysToOmit) {
-    return Object.keys(object)
-        .filter((option) => !keysToOmit.includes(option))
-        .reduce((obj, key) => {
-        obj[key] = object[key];
-        return obj;
-    }, {});
+  return Object.keys(object).filter((option) => !keysToOmit.includes(option)).reduce((obj, key) => {
+    obj[key] = object[key];
+    return obj;
+  }, {});
 }
 
-// Based on https://github.com/bramstein/url-template, licensed under BSD
-// TODO: create separate package.
-//
-// Copyright (c) 2012-2014, Bram Stein
-// All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions
-// are met:
-//  1. Redistributions of source code must retain the above copyright
-//     notice, this list of conditions and the following disclaimer.
-//  2. Redistributions in binary form must reproduce the above copyright
-//     notice, this list of conditions and the following disclaimer in the
-//     documentation and/or other materials provided with the distribution.
-//  3. The name of the author may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-// THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED
-// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
-// EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
-// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
-// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-/* istanbul ignore file */
+// pkg/dist-src/util/url-template.js
 function encodeReserved(str) {
-    return str
-        .split(/(%[0-9A-Fa-f]{2})/g)
-        .map(function (part) {
-        if (!/%[0-9A-Fa-f]/.test(part)) {
-            part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]");
-        }
-        return part;
-    })
-        .join("");
+  return str.split(/(%[0-9A-Fa-f]{2})/g).map(function(part) {
+    if (!/%[0-9A-Fa-f]/.test(part)) {
+      part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]");
+    }
+    return part;
+  }).join("");
 }
 function encodeUnreserved(str) {
-    return encodeURIComponent(str).replace(/[!'()*]/g, function (c) {
-        return "%" + c.charCodeAt(0).toString(16).toUpperCase();
-    });
+  return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {
+    return "%" + c.charCodeAt(0).toString(16).toUpperCase();
+  });
 }
 function encodeValue(operator, value, key) {
-    value =
-        operator === "+" || operator === "#"
-            ? encodeReserved(value)
-            : encodeUnreserved(value);
-    if (key) {
-        return encodeUnreserved(key) + "=" + value;
-    }
-    else {
-        return value;
-    }
+  value = operator === "+" || operator === "#" ? encodeReserved(value) : encodeUnreserved(value);
+  if (key) {
+    return encodeUnreserved(key) + "=" + value;
+  } else {
+    return value;
+  }
 }
 function isDefined(value) {
-    return value !== undefined && value !== null;
+  return value !== void 0 && value !== null;
 }
 function isKeyOperator(operator) {
-    return operator === ";" || operator === "&" || operator === "?";
+  return operator === ";" || operator === "&" || operator === "?";
 }
 function getValues(context, operator, key, modifier) {
-    var value = context[key], result = [];
-    if (isDefined(value) && value !== "") {
-        if (typeof value === "string" ||
-            typeof value === "number" ||
-            typeof value === "boolean") {
-            value = value.toString();
-            if (modifier && modifier !== "*") {
-                value = value.substring(0, parseInt(modifier, 10));
-            }
-            result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : ""));
-        }
-        else {
-            if (modifier === "*") {
-                if (Array.isArray(value)) {
-                    value.filter(isDefined).forEach(function (value) {
-                        result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : ""));
-                    });
-                }
-                else {
-                    Object.keys(value).forEach(function (k) {
-                        if (isDefined(value[k])) {
-                            result.push(encodeValue(operator, value[k], k));
-                        }
-                    });
-                }
-            }
-            else {
-                const tmp = [];
-                if (Array.isArray(value)) {
-                    value.filter(isDefined).forEach(function (value) {
-                        tmp.push(encodeValue(operator, value));
-                    });
-                }
-                else {
-                    Object.keys(value).forEach(function (k) {
-                        if (isDefined(value[k])) {
-                            tmp.push(encodeUnreserved(k));
-                            tmp.push(encodeValue(operator, value[k].toString()));
-                        }
-                    });
-                }
-                if (isKeyOperator(operator)) {
-                    result.push(encodeUnreserved(key) + "=" + tmp.join(","));
-                }
-                else if (tmp.length !== 0) {
-                    result.push(tmp.join(","));
-                }
+  var value = context[key], result = [];
+  if (isDefined(value) && value !== "") {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      value = value.toString();
+      if (modifier && modifier !== "*") {
+        value = value.substring(0, parseInt(modifier, 10));
+      }
+      result.push(
+        encodeValue(operator, value, isKeyOperator(operator) ? key : "")
+      );
+    } else {
+      if (modifier === "*") {
+        if (Array.isArray(value)) {
+          value.filter(isDefined).forEach(function(value2) {
+            result.push(
+              encodeValue(operator, value2, isKeyOperator(operator) ? key : "")
+            );
+          });
+        } else {
+          Object.keys(value).forEach(function(k) {
+            if (isDefined(value[k])) {
+              result.push(encodeValue(operator, value[k], k));
             }
+          });
         }
-    }
-    else {
-        if (operator === ";") {
-            if (isDefined(value)) {
-                result.push(encodeUnreserved(key));
+      } else {
+        const tmp = [];
+        if (Array.isArray(value)) {
+          value.filter(isDefined).forEach(function(value2) {
+            tmp.push(encodeValue(operator, value2));
+          });
+        } else {
+          Object.keys(value).forEach(function(k) {
+            if (isDefined(value[k])) {
+              tmp.push(encodeUnreserved(k));
+              tmp.push(encodeValue(operator, value[k].toString()));
             }
+          });
         }
-        else if (value === "" && (operator === "&" || operator === "?")) {
-            result.push(encodeUnreserved(key) + "=");
-        }
-        else if (value === "") {
-            result.push("");
+        if (isKeyOperator(operator)) {
+          result.push(encodeUnreserved(key) + "=" + tmp.join(","));
+        } else if (tmp.length !== 0) {
+          result.push(tmp.join(","));
         }
+      }
     }
-    return result;
+  } else {
+    if (operator === ";") {
+      if (isDefined(value)) {
+        result.push(encodeUnreserved(key));
+      }
+    } else if (value === "" && (operator === "&" || operator === "?")) {
+      result.push(encodeUnreserved(key) + "=");
+    } else if (value === "") {
+      result.push("");
+    }
+  }
+  return result;
 }
 function parseUrl(template) {
-    return {
-        expand: expand.bind(null, template),
-    };
+  return {
+    expand: expand.bind(null, template)
+  };
 }
 function expand(template, context) {
-    var operators = ["+", "#", ".", "/", ";", "?", "&"];
-    return template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function (_, expression, literal) {
-        if (expression) {
-            let operator = "";
-            const values = [];
-            if (operators.indexOf(expression.charAt(0)) !== -1) {
-                operator = expression.charAt(0);
-                expression = expression.substr(1);
-            }
-            expression.split(/,/g).forEach(function (variable) {
-                var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable);
-                values.push(getValues(context, operator, tmp[1], tmp[2] || tmp[3]));
-            });
-            if (operator && operator !== "+") {
-                var separator = ",";
-                if (operator === "?") {
-                    separator = "&";
-                }
-                else if (operator !== "#") {
-                    separator = operator;
-                }
-                return (values.length !== 0 ? operator : "") + values.join(separator);
-            }
-            else {
-                return values.join(",");
-            }
-        }
-        else {
-            return encodeReserved(literal);
+  var operators = ["+", "#", ".", "/", ";", "?", "&"];
+  return template.replace(
+    /\{([^\{\}]+)\}|([^\{\}]+)/g,
+    function(_, expression, literal) {
+      if (expression) {
+        let operator = "";
+        const values = [];
+        if (operators.indexOf(expression.charAt(0)) !== -1) {
+          operator = expression.charAt(0);
+          expression = expression.substr(1);
+        }
+        expression.split(/,/g).forEach(function(variable) {
+          var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable);
+          values.push(getValues(context, operator, tmp[1], tmp[2] || tmp[3]));
+        });
+        if (operator && operator !== "+") {
+          var separator = ",";
+          if (operator === "?") {
+            separator = "&";
+          } else if (operator !== "#") {
+            separator = operator;
+          }
+          return (values.length !== 0 ? operator : "") + values.join(separator);
+        } else {
+          return values.join(",");
         }
-    });
+      } else {
+        return encodeReserved(literal);
+      }
+    }
+  );
 }
 
+// pkg/dist-src/parse.js
 function parse(options) {
-    // https://fetch.spec.whatwg.org/#methods
-    let method = options.method.toUpperCase();
-    // replace :varname with {varname} to make it RFC 6570 compatible
-    let url = (options.url || "/").replace(/:([a-z]\w+)/g, "{$1}");
-    let headers = Object.assign({}, options.headers);
-    let body;
-    let parameters = omit(options, [
-        "method",
-        "baseUrl",
-        "url",
-        "headers",
-        "request",
-        "mediaType",
-    ]);
-    // extract variable names from URL to calculate remaining variables later
-    const urlVariableNames = extractUrlVariableNames(url);
-    url = parseUrl(url).expand(parameters);
-    if (!/^http/.test(url)) {
-        url = options.baseUrl + url;
-    }
-    const omittedParameters = Object.keys(options)
-        .filter((option) => urlVariableNames.includes(option))
-        .concat("baseUrl");
-    const remainingParameters = omit(parameters, omittedParameters);
-    const isBinaryRequest = /application\/octet-stream/i.test(headers.accept);
-    if (!isBinaryRequest) {
-        if (options.mediaType.format) {
-            // e.g. application/vnd.github.v3+json => application/vnd.github.v3.raw
-            headers.accept = headers.accept
-                .split(/,/)
-                .map((preview) => preview.replace(/application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/, `application/vnd$1$2.${options.mediaType.format}`))
-                .join(",");
-        }
-        if (options.mediaType.previews.length) {
-            const previewsFromAcceptHeader = headers.accept.match(/[\w-]+(?=-preview)/g) || [];
-            headers.accept = previewsFromAcceptHeader
-                .concat(options.mediaType.previews)
-                .map((preview) => {
-                const format = options.mediaType.format
-                    ? `.${options.mediaType.format}`
-                    : "+json";
-                return `application/vnd.github.${preview}-preview${format}`;
-            })
-                .join(",");
-        }
-    }
-    // for GET/HEAD requests, set URL query parameters from remaining parameters
-    // for PATCH/POST/PUT/DELETE requests, set request body from remaining parameters
-    if (["GET", "HEAD"].includes(method)) {
-        url = addQueryParameters(url, remainingParameters);
-    }
-    else {
-        if ("data" in remainingParameters) {
-            body = remainingParameters.data;
-        }
-        else {
-            if (Object.keys(remainingParameters).length) {
-                body = remainingParameters;
-            }
-        }
-    }
-    // default content-type for JSON if body is set
-    if (!headers["content-type"] && typeof body !== "undefined") {
-        headers["content-type"] = "application/json; charset=utf-8";
+  let method = options.method.toUpperCase();
+  let url = (options.url || "/").replace(/:([a-z]\w+)/g, "{$1}");
+  let headers = Object.assign({}, options.headers);
+  let body;
+  let parameters = omit(options, [
+    "method",
+    "baseUrl",
+    "url",
+    "headers",
+    "request",
+    "mediaType"
+  ]);
+  const urlVariableNames = extractUrlVariableNames(url);
+  url = parseUrl(url).expand(parameters);
+  if (!/^http/.test(url)) {
+    url = options.baseUrl + url;
+  }
+  const omittedParameters = Object.keys(options).filter((option) => urlVariableNames.includes(option)).concat("baseUrl");
+  const remainingParameters = omit(parameters, omittedParameters);
+  const isBinaryRequest = /application\/octet-stream/i.test(headers.accept);
+  if (!isBinaryRequest) {
+    if (options.mediaType.format) {
+      headers.accept = headers.accept.split(/,/).map(
+        (preview) => preview.replace(
+          /application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/,
+          `application/vnd$1$2.${options.mediaType.format}`
+        )
+      ).join(",");
+    }
+    if (options.mediaType.previews.length) {
+      const previewsFromAcceptHeader = headers.accept.match(/[\w-]+(?=-preview)/g) || [];
+      headers.accept = previewsFromAcceptHeader.concat(options.mediaType.previews).map((preview) => {
+        const format = options.mediaType.format ? `.${options.mediaType.format}` : "+json";
+        return `application/vnd.github.${preview}-preview${format}`;
+      }).join(",");
     }
-    // GitHub expects 'content-length: 0' header for PUT/PATCH requests without body.
-    // fetch does not allow to set `content-length` header, but we can set body to an empty string
-    if (["PATCH", "PUT"].includes(method) && typeof body === "undefined") {
-        body = "";
+  }
+  if (["GET", "HEAD"].includes(method)) {
+    url = addQueryParameters(url, remainingParameters);
+  } else {
+    if ("data" in remainingParameters) {
+      body = remainingParameters.data;
+    } else {
+      if (Object.keys(remainingParameters).length) {
+        body = remainingParameters;
+      }
     }
-    // Only return body/request keys if present
-    return Object.assign({ method, url, headers }, typeof body !== "undefined" ? { body } : null, options.request ? { request: options.request } : null);
+  }
+  if (!headers["content-type"] && typeof body !== "undefined") {
+    headers["content-type"] = "application/json; charset=utf-8";
+  }
+  if (["PATCH", "PUT"].includes(method) && typeof body === "undefined") {
+    body = "";
+  }
+  return Object.assign(
+    { method, url, headers },
+    typeof body !== "undefined" ? { body } : null,
+    options.request ? { request: options.request } : null
+  );
 }
 
+// pkg/dist-src/endpoint-with-defaults.js
 function endpointWithDefaults(defaults, route, options) {
-    return parse(merge(defaults, route, options));
+  return parse(merge(defaults, route, options));
 }
 
+// pkg/dist-src/with-defaults.js
 function withDefaults(oldDefaults, newDefaults) {
-    const DEFAULTS = merge(oldDefaults, newDefaults);
-    const endpoint = endpointWithDefaults.bind(null, DEFAULTS);
-    return Object.assign(endpoint, {
-        DEFAULTS,
-        defaults: withDefaults.bind(null, DEFAULTS),
-        merge: merge.bind(null, DEFAULTS),
-        parse,
-    });
+  const DEFAULTS2 = merge(oldDefaults, newDefaults);
+  const endpoint2 = endpointWithDefaults.bind(null, DEFAULTS2);
+  return Object.assign(endpoint2, {
+    DEFAULTS: DEFAULTS2,
+    defaults: withDefaults.bind(null, DEFAULTS2),
+    merge: merge.bind(null, DEFAULTS2),
+    parse
+  });
 }
 
-const VERSION = "7.0.3";
-
-const userAgent = `octokit-endpoint.js/${VERSION} ${(0,universal_user_agent__WEBPACK_IMPORTED_MODULE_1__.getUserAgent)()}`;
-// DEFAULTS has all properties set that EndpointOptions has, except url.
-// So we use RequestParameters and add method as additional required property.
-const DEFAULTS = {
-    method: "GET",
-    baseUrl: "https://api.github.com",
-    headers: {
-        accept: "application/vnd.github.v3+json",
-        "user-agent": userAgent,
-    },
-    mediaType: {
-        format: "",
-        previews: [],
-    },
-};
+// pkg/dist-src/defaults.js
 
-const endpoint = withDefaults(null, DEFAULTS);
 
+// pkg/dist-src/version.js
+var VERSION = "7.0.6";
+
+// pkg/dist-src/defaults.js
+var userAgent = `octokit-endpoint.js/${VERSION} ${(0,universal_user_agent__WEBPACK_IMPORTED_MODULE_1__.getUserAgent)()}`;
+var DEFAULTS = {
+  method: "GET",
+  baseUrl: "https://api.github.com",
+  headers: {
+    accept: "application/vnd.github.v3+json",
+    "user-agent": userAgent
+  },
+  mediaType: {
+    format: "",
+    previews: []
+  }
+};
+
+// pkg/dist-src/index.js
+var endpoint = withDefaults(null, DEFAULTS);
 
-//# sourceMappingURL=index.js.map
 
 
 /***/ }),
@@ -3776,118 +3957,127 @@ function getUserAgent() {
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "GraphqlResponseError": () => (/* binding */ GraphqlResponseError),
-/* harmony export */   "graphql": () => (/* binding */ graphql$1),
+/* harmony export */   "graphql": () => (/* binding */ graphql2),
 /* harmony export */   "withCustomRequest": () => (/* binding */ withCustomRequest)
 /* harmony export */ });
 /* harmony import */ var _octokit_request__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(18);
 /* harmony import */ var universal_user_agent__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(26);
+// pkg/dist-src/index.js
 
 
 
-const VERSION = "5.0.4";
+// pkg/dist-src/version.js
+var VERSION = "5.0.6";
 
+// pkg/dist-src/error.js
 function _buildMessageForResponseErrors(data) {
-    return (`Request failed due to following response errors:\n` +
-        data.errors.map((e) => ` - ${e.message}`).join("\n"));
+  return `Request failed due to following response errors:
+` + data.errors.map((e) => ` - ${e.message}`).join("\n");
 }
-class GraphqlResponseError extends Error {
-    constructor(request, headers, response) {
-        super(_buildMessageForResponseErrors(response));
-        this.request = request;
-        this.headers = headers;
-        this.response = response;
-        this.name = "GraphqlResponseError";
-        // Expose the errors and response data in their shorthand properties.
-        this.errors = response.errors;
-        this.data = response.data;
-        // Maintains proper stack trace (only available on V8)
-        /* istanbul ignore next */
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, this.constructor);
-        }
+var GraphqlResponseError = class extends Error {
+  constructor(request2, headers, response) {
+    super(_buildMessageForResponseErrors(response));
+    this.request = request2;
+    this.headers = headers;
+    this.response = response;
+    this.name = "GraphqlResponseError";
+    this.errors = response.errors;
+    this.data = response.data;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
     }
-}
+  }
+};
 
-const NON_VARIABLE_OPTIONS = [
-    "method",
-    "baseUrl",
-    "url",
-    "headers",
-    "request",
-    "query",
-    "mediaType",
+// pkg/dist-src/graphql.js
+var NON_VARIABLE_OPTIONS = [
+  "method",
+  "baseUrl",
+  "url",
+  "headers",
+  "request",
+  "query",
+  "mediaType"
 ];
-const FORBIDDEN_VARIABLE_OPTIONS = ["query", "method", "url"];
-const GHES_V3_SUFFIX_REGEX = /\/api\/v3\/?$/;
-function graphql(request, query, options) {
-    if (options) {
-        if (typeof query === "string" && "query" in options) {
-            return Promise.reject(new Error(`[@octokit/graphql] "query" cannot be used as variable name`));
-        }
-        for (const key in options) {
-            if (!FORBIDDEN_VARIABLE_OPTIONS.includes(key))
-                continue;
-            return Promise.reject(new Error(`[@octokit/graphql] "${key}" cannot be used as variable name`));
-        }
+var FORBIDDEN_VARIABLE_OPTIONS = ["query", "method", "url"];
+var GHES_V3_SUFFIX_REGEX = /\/api\/v3\/?$/;
+function graphql(request2, query, options) {
+  if (options) {
+    if (typeof query === "string" && "query" in options) {
+      return Promise.reject(
+        new Error(`[@octokit/graphql] "query" cannot be used as variable name`)
+      );
+    }
+    for (const key in options) {
+      if (!FORBIDDEN_VARIABLE_OPTIONS.includes(key))
+        continue;
+      return Promise.reject(
+        new Error(`[@octokit/graphql] "${key}" cannot be used as variable name`)
+      );
     }
-    const parsedOptions = typeof query === "string" ? Object.assign({ query }, options) : query;
-    const requestOptions = Object.keys(parsedOptions).reduce((result, key) => {
-        if (NON_VARIABLE_OPTIONS.includes(key)) {
-            result[key] = parsedOptions[key];
-            return result;
-        }
-        if (!result.variables) {
-            result.variables = {};
-        }
-        result.variables[key] = parsedOptions[key];
-        return result;
-    }, {});
-    // workaround for GitHub Enterprise baseUrl set with /api/v3 suffix
-    // https://github.com/octokit/auth-app.js/issues/111#issuecomment-657610451
-    const baseUrl = parsedOptions.baseUrl || request.endpoint.DEFAULTS.baseUrl;
-    if (GHES_V3_SUFFIX_REGEX.test(baseUrl)) {
-        requestOptions.url = baseUrl.replace(GHES_V3_SUFFIX_REGEX, "/api/graphql");
-    }
-    return request(requestOptions).then((response) => {
-        if (response.data.errors) {
-            const headers = {};
-            for (const key of Object.keys(response.headers)) {
-                headers[key] = response.headers[key];
-            }
-            throw new GraphqlResponseError(requestOptions, headers, response.data);
-        }
-        return response.data.data;
-    });
+  }
+  const parsedOptions = typeof query === "string" ? Object.assign({ query }, options) : query;
+  const requestOptions = Object.keys(
+    parsedOptions
+  ).reduce((result, key) => {
+    if (NON_VARIABLE_OPTIONS.includes(key)) {
+      result[key] = parsedOptions[key];
+      return result;
+    }
+    if (!result.variables) {
+      result.variables = {};
+    }
+    result.variables[key] = parsedOptions[key];
+    return result;
+  }, {});
+  const baseUrl = parsedOptions.baseUrl || request2.endpoint.DEFAULTS.baseUrl;
+  if (GHES_V3_SUFFIX_REGEX.test(baseUrl)) {
+    requestOptions.url = baseUrl.replace(GHES_V3_SUFFIX_REGEX, "/api/graphql");
+  }
+  return request2(requestOptions).then((response) => {
+    if (response.data.errors) {
+      const headers = {};
+      for (const key of Object.keys(response.headers)) {
+        headers[key] = response.headers[key];
+      }
+      throw new GraphqlResponseError(
+        requestOptions,
+        headers,
+        response.data
+      );
+    }
+    return response.data.data;
+  });
 }
 
-function withDefaults(request, newDefaults) {
-    const newRequest = request.defaults(newDefaults);
-    const newApi = (query, options) => {
-        return graphql(newRequest, query, options);
-    };
-    return Object.assign(newApi, {
-        defaults: withDefaults.bind(null, newRequest),
-        endpoint: newRequest.endpoint,
-    });
+// pkg/dist-src/with-defaults.js
+function withDefaults(request2, newDefaults) {
+  const newRequest = request2.defaults(newDefaults);
+  const newApi = (query, options) => {
+    return graphql(newRequest, query, options);
+  };
+  return Object.assign(newApi, {
+    defaults: withDefaults.bind(null, newRequest),
+    endpoint: newRequest.endpoint
+  });
 }
 
-const graphql$1 = withDefaults(_octokit_request__WEBPACK_IMPORTED_MODULE_0__.request, {
-    headers: {
-        "user-agent": `octokit-graphql.js/${VERSION} ${(0,universal_user_agent__WEBPACK_IMPORTED_MODULE_1__.getUserAgent)()}`,
-    },
-    method: "POST",
-    url: "/graphql",
+// pkg/dist-src/index.js
+var graphql2 = withDefaults(_octokit_request__WEBPACK_IMPORTED_MODULE_0__.request, {
+  headers: {
+    "user-agent": `octokit-graphql.js/${VERSION} ${(0,universal_user_agent__WEBPACK_IMPORTED_MODULE_1__.getUserAgent)()}`
+  },
+  method: "POST",
+  url: "/graphql"
 });
 function withCustomRequest(customRequest) {
-    return withDefaults(customRequest, {
-        method: "POST",
-        url: "/graphql",
-    });
+  return withDefaults(customRequest, {
+    method: "POST",
+    url: "/graphql"
+  });
 }
 
 
-//# sourceMappingURL=index.js.map
-
 
 /***/ }),
 /* 28 */
@@ -3898,62 +4088,57 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "createTokenAuth": () => (/* binding */ createTokenAuth)
 /* harmony export */ });
-const REGEX_IS_INSTALLATION_LEGACY = /^v1\./;
-const REGEX_IS_INSTALLATION = /^ghs_/;
-const REGEX_IS_USER_TO_SERVER = /^ghu_/;
+// pkg/dist-src/auth.js
+var REGEX_IS_INSTALLATION_LEGACY = /^v1\./;
+var REGEX_IS_INSTALLATION = /^ghs_/;
+var REGEX_IS_USER_TO_SERVER = /^ghu_/;
 async function auth(token) {
-    const isApp = token.split(/\./).length === 3;
-    const isInstallation = REGEX_IS_INSTALLATION_LEGACY.test(token) ||
-        REGEX_IS_INSTALLATION.test(token);
-    const isUserToServer = REGEX_IS_USER_TO_SERVER.test(token);
-    const tokenType = isApp
-        ? "app"
-        : isInstallation
-            ? "installation"
-            : isUserToServer
-                ? "user-to-server"
-                : "oauth";
-    return {
-        type: "token",
-        token: token,
-        tokenType,
-    };
+  const isApp = token.split(/\./).length === 3;
+  const isInstallation = REGEX_IS_INSTALLATION_LEGACY.test(token) || REGEX_IS_INSTALLATION.test(token);
+  const isUserToServer = REGEX_IS_USER_TO_SERVER.test(token);
+  const tokenType = isApp ? "app" : isInstallation ? "installation" : isUserToServer ? "user-to-server" : "oauth";
+  return {
+    type: "token",
+    token,
+    tokenType
+  };
 }
 
-/**
- * Prefix token for usage in the Authorization header
- *
- * @param token OAuth token or JSON Web Token
- */
+// pkg/dist-src/with-authorization-prefix.js
 function withAuthorizationPrefix(token) {
-    if (token.split(/\./).length === 3) {
-        return `bearer ${token}`;
-    }
-    return `token ${token}`;
+  if (token.split(/\./).length === 3) {
+    return `bearer ${token}`;
+  }
+  return `token ${token}`;
 }
 
+// pkg/dist-src/hook.js
 async function hook(token, request, route, parameters) {
-    const endpoint = request.endpoint.merge(route, parameters);
-    endpoint.headers.authorization = withAuthorizationPrefix(token);
-    return request(endpoint);
+  const endpoint = request.endpoint.merge(
+    route,
+    parameters
+  );
+  endpoint.headers.authorization = withAuthorizationPrefix(token);
+  return request(endpoint);
 }
 
-const createTokenAuth = function createTokenAuth(token) {
-    if (!token) {
-        throw new Error("[@octokit/auth-token] No token passed to createTokenAuth");
-    }
-    if (typeof token !== "string") {
-        throw new Error("[@octokit/auth-token] Token passed to createTokenAuth is not a string");
-    }
-    token = token.replace(/^(token|bearer) +/i, "");
-    return Object.assign(auth.bind(null, token), {
-        hook: hook.bind(null, token),
-    });
+// pkg/dist-src/index.js
+var createTokenAuth = function createTokenAuth2(token) {
+  if (!token) {
+    throw new Error("[@octokit/auth-token] No token passed to createTokenAuth");
+  }
+  if (typeof token !== "string") {
+    throw new Error(
+      "[@octokit/auth-token] Token passed to createTokenAuth is not a string"
+    );
+  }
+  token = token.replace(/^(token|bearer) +/i, "");
+  return Object.assign(auth.bind(null, token), {
+    hook: hook.bind(null, token)
+  });
 };
 
 
-//# sourceMappingURL=index.js.map
-
 
 /***/ }),
 /* 29 */
@@ -5744,7 +5929,7 @@ const Endpoints = {
     },
 };
 
-const VERSION = "6.7.0";
+const VERSION = "6.8.1";
 
 function endpointsToMethods(octokit, endpointsMap) {
     const newMethods = {};