@coze-editor/parser-json 0.1.0-alpha.0fd19e

package/dist/index.js

@@ -0,0 +1,816 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ErrorCode: () => ErrorCode,
+  findNodeAtOffset: () => findNodeAtOffset,
+  parse: () => parse
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/parser.ts
+var import_vscode_languageserver_types = require("vscode-languageserver-types");
+var l10n = __toESM(require("@vscode/l10n"));
+
+// src/scanner.ts
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16 /* Unknown */, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0 /* None */;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      const ch = text.charCodeAt(pos);
+      if (ch >= 48 /* _0 */ && ch <= 57 /* _9 */) {
+        value2 = value2 * 16 + ch - 48 /* _0 */;
+      } else if (ch >= 65 /* A */ && ch <= 70 /* F */) {
+        value2 = value2 * 16 + ch - 65 /* A */ + 10;
+      } else if (ch >= 97 /* a */ && ch <= 102 /* f */) {
+        value2 = value2 * 16 + ch - 97 /* a */ + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
+    }
+    return value2;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16 /* Unknown */;
+    scanError = 0 /* None */;
+  }
+  function scanNumber() {
+    const start = pos;
+    if (text.charCodeAt(pos) === 48 /* _0 */) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46 /* dot */) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3 /* UnexpectedEndOfNumber */;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 /* E */ || text.charCodeAt(pos) === 101 /* e */)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 /* plus */ || text.charCodeAt(pos) === 45 /* minus */) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3 /* UnexpectedEndOfNumber */;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString(endQuote) {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2 /* UnexpectedEndOfString */;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === endQuote) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92 /* backslash */) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2 /* UnexpectedEndOfString */;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34 /* doubleQuote */:
+            result += '"';
+            break;
+          case 39 /* singleQuote */:
+            result += `'`;
+            break;
+          case 92 /* backslash */:
+            result += "\\";
+            break;
+          case 47 /* slash */:
+            result += "/";
+            break;
+          case 98 /* b */:
+            result += "\b";
+            break;
+          case 102 /* f */:
+            result += "\f";
+            break;
+          case 110 /* n */:
+            result += "\n";
+            break;
+          case 114 /* r */:
+            result += "\r";
+            break;
+          case 116 /* t */:
+            result += "	";
+            break;
+          case 117 /* u */:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4 /* InvalidUnicode */;
+            }
+            break;
+          default:
+            scanError = 5 /* InvalidEscapeCharacter */;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2 /* UnexpectedEndOfString */;
+          break;
+        } else {
+          scanError = 6 /* InvalidCharacter */;
+        }
+      }
+      pos++;
+    }
+    return result;
+  }
+  function scanNext() {
+    value = "";
+    scanError = 0 /* None */;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17 /* EOF */;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15 /* Trivia */;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 /* carriageReturn */ && text.charCodeAt(pos) === 10 /* lineFeed */) {
+        pos++;
+        value += "\n";
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14 /* LineBreakTrivia */;
+    }
+    switch (code) {
+      // tokens: []{}:,
+      case 123 /* openBrace */:
+        pos++;
+        return token = 1 /* OpenBraceToken */;
+      case 125 /* closeBrace */:
+        pos++;
+        return token = 2 /* CloseBraceToken */;
+      case 91 /* openBracket */:
+        pos++;
+        return token = 3 /* OpenBracketToken */;
+      case 93 /* closeBracket */:
+        pos++;
+        return token = 4 /* CloseBracketToken */;
+      case 58 /* colon */:
+        pos++;
+        return token = 6 /* ColonToken */;
+      case 44 /* comma */:
+        pos++;
+        return token = 5 /* CommaToken */;
+      // strings
+      case 34 /* doubleQuote */:
+        pos++;
+        value = scanString(34 /* doubleQuote */);
+        return token = 19 /* DoubleQuoteStringLiteral */;
+      case 39 /* singleQuote */:
+        pos++;
+        value = scanString(39 /* singleQuote */);
+        return token = 18 /* SingleQuoteStringLiteral */;
+      // comments
+      case 47 /* slash */:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47 /* slash */) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12 /* LineCommentTrivia */;
+        }
+        if (text.charCodeAt(pos + 1) === 42 /* asterisk */) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 /* asterisk */ && text.charCodeAt(pos + 1) === 47 /* slash */) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 /* carriageReturn */ && text.charCodeAt(pos) === 10 /* lineFeed */) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1 /* UnexpectedEndOfComment */;
+          }
+          value = text.substring(start, pos);
+          return token = 13 /* BlockCommentTrivia */;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16 /* Unknown */;
+      // numbers
+      // @ts-ignore
+      case 45 /* minus */:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16 /* 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 */:
+        value += scanNumber();
+        return token = 11 /* NumericLiteral */;
+      // literals and unknown symbols
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8 /* TrueKeyword */;
+            case "false":
+              return token = 9 /* FalseKeyword */;
+            case "null":
+              return token = 7 /* NullKeyword */;
+          }
+          return token = 16 /* Unknown */;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16 /* Unknown */;
+    }
+  }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      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 */:
+        return false;
+    }
+    return true;
+  }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 /* LineCommentTrivia */ && result <= 15 /* Trivia */);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    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 */;
+}
+function isLineBreak(ch) {
+  return ch === 10 /* lineFeed */ || ch === 13 /* carriageReturn */;
+}
+function isDigit(ch) {
+  return ch >= 48 /* _0 */ && ch <= 57 /* _9 */;
+}
+
+// src/is.ts
+function isNumber(val) {
+  return typeof val === "number";
+}
+function isObject(val) {
+  return typeof val === "object" && val !== null && !Array.isArray(val);
+}
+
+// src/types.ts
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2[ErrorCode2["Undefined"] = 0] = "Undefined";
+  ErrorCode2[ErrorCode2["EnumValueMismatch"] = 1] = "EnumValueMismatch";
+  ErrorCode2[ErrorCode2["Deprecated"] = 2] = "Deprecated";
+  ErrorCode2[ErrorCode2["UnexpectedEndOfComment"] = 257] = "UnexpectedEndOfComment";
+  ErrorCode2[ErrorCode2["UnexpectedEndOfString"] = 258] = "UnexpectedEndOfString";
+  ErrorCode2[ErrorCode2["UnexpectedEndOfNumber"] = 259] = "UnexpectedEndOfNumber";
+  ErrorCode2[ErrorCode2["InvalidUnicode"] = 260] = "InvalidUnicode";
+  ErrorCode2[ErrorCode2["InvalidEscapeCharacter"] = 261] = "InvalidEscapeCharacter";
+  ErrorCode2[ErrorCode2["InvalidCharacter"] = 262] = "InvalidCharacter";
+  ErrorCode2[ErrorCode2["PropertyExpected"] = 513] = "PropertyExpected";
+  ErrorCode2[ErrorCode2["CommaExpected"] = 514] = "CommaExpected";
+  ErrorCode2[ErrorCode2["ColonExpected"] = 515] = "ColonExpected";
+  ErrorCode2[ErrorCode2["ValueExpected"] = 516] = "ValueExpected";
+  ErrorCode2[ErrorCode2["CommaOrCloseBacketExpected"] = 517] = "CommaOrCloseBacketExpected";
+  ErrorCode2[ErrorCode2["CommaOrCloseBraceExpected"] = 518] = "CommaOrCloseBraceExpected";
+  ErrorCode2[ErrorCode2["TrailingComma"] = 519] = "TrailingComma";
+  ErrorCode2[ErrorCode2["DuplicateKey"] = 520] = "DuplicateKey";
+  ErrorCode2[ErrorCode2["CommentNotPermitted"] = 521] = "CommentNotPermitted";
+  ErrorCode2[ErrorCode2["PropertyKeysMustBeDoublequoted"] = 528] = "PropertyKeysMustBeDoublequoted";
+  ErrorCode2[ErrorCode2["StringValueMustBeDoublequoted"] = 529] = "StringValueMustBeDoublequoted";
+  ErrorCode2[ErrorCode2["SchemaResolveError"] = 768] = "SchemaResolveError";
+  ErrorCode2[ErrorCode2["SchemaUnsupportedFeature"] = 769] = "SchemaUnsupportedFeature";
+  return ErrorCode2;
+})(ErrorCode || {});
+
+// src/parser.ts
+var ASTNodeImpl = class {
+  offset;
+  length;
+  parent;
+  constructor(parent, offset, length = 0) {
+    this.offset = offset;
+    this.length = length;
+    this.parent = parent;
+  }
+  get children() {
+    return [];
+  }
+  toString() {
+    return "type: " + this.type + " (" + this.offset + "/" + this.length + ")" + (this.parent ? " parent: {" + this.parent.toString() + "}" : "");
+  }
+};
+var NullASTNodeImpl = class extends ASTNodeImpl {
+  type = "null";
+  value = null;
+  constructor(parent, offset) {
+    super(parent, offset);
+  }
+};
+var BooleanASTNodeImpl = class extends ASTNodeImpl {
+  type = "boolean";
+  value;
+  constructor(parent, boolValue, offset) {
+    super(parent, offset);
+    this.value = boolValue;
+  }
+};
+var ArrayASTNodeImpl = class extends ASTNodeImpl {
+  type = "array";
+  items;
+  constructor(parent, offset) {
+    super(parent, offset);
+    this.items = [];
+  }
+  get children() {
+    return this.items;
+  }
+};
+var NumberASTNodeImpl = class extends ASTNodeImpl {
+  type = "number";
+  isInteger;
+  value;
+  constructor(parent, offset) {
+    super(parent, offset);
+    this.isInteger = true;
+    this.value = Number.NaN;
+  }
+};
+var StringASTNodeImpl = class extends ASTNodeImpl {
+  type = "string";
+  value;
+  constructor(parent, offset, length) {
+    super(parent, offset, length);
+    this.value = "";
+  }
+};
+var PropertyASTNodeImpl = class extends ASTNodeImpl {
+  type = "property";
+  keyNode;
+  valueNode;
+  colonOffset;
+  constructor(parent, offset, keyNode) {
+    super(parent, offset);
+    this.colonOffset = -1;
+    this.keyNode = keyNode;
+  }
+  get children() {
+    return this.valueNode ? [this.keyNode, this.valueNode] : [this.keyNode];
+  }
+};
+var ObjectASTNodeImpl = class extends ASTNodeImpl {
+  type = "object";
+  properties;
+  constructor(parent, offset) {
+    super(parent, offset);
+    this.properties = [];
+  }
+  get children() {
+    return this.properties;
+  }
+};
+function parse(textDocument, config) {
+  const problems = [];
+  let lastProblemOffset = -1;
+  const text = textDocument.getText();
+  const scanner = createScanner(text, false);
+  const commentRanges = config && config.collectComments ? [] : void 0;
+  function _scanNext() {
+    while (true) {
+      const token2 = scanner.scan();
+      _checkScanError();
+      switch (token2) {
+        case 12 /* LineCommentTrivia */:
+        case 13 /* BlockCommentTrivia */:
+          if (Array.isArray(commentRanges)) {
+            commentRanges.push(import_vscode_languageserver_types.Range.create(textDocument.positionAt(scanner.getTokenOffset()), textDocument.positionAt(scanner.getTokenOffset() + scanner.getTokenLength())));
+          }
+          break;
+        case 15 /* Trivia */:
+        case 14 /* LineBreakTrivia */:
+          break;
+        default:
+          return token2;
+      }
+    }
+  }
+  function _accept(token2) {
+    if (scanner.getToken() === token2) {
+      _scanNext();
+      return true;
+    }
+    return false;
+  }
+  function _errorAtRange(message, code, startOffset, endOffset, severity = import_vscode_languageserver_types.DiagnosticSeverity.Error) {
+    if (problems.length === 0 || startOffset !== lastProblemOffset) {
+      const range = import_vscode_languageserver_types.Range.create(textDocument.positionAt(startOffset), textDocument.positionAt(endOffset));
+      problems.push(import_vscode_languageserver_types.Diagnostic.create(range, message, severity, code, textDocument.languageId));
+      lastProblemOffset = startOffset;
+    }
+  }
+  function _error(message, code, node = void 0, skipUntilAfter = [], skipUntil = []) {
+    let start = scanner.getTokenOffset();
+    let end = scanner.getTokenOffset() + scanner.getTokenLength();
+    if (start === end && start > 0) {
+      start--;
+      while (start > 0 && /\s/.test(text.charAt(start))) {
+        start--;
+      }
+      end = start + 1;
+    }
+    _errorAtRange(message, code, start, end);
+    if (node) {
+      _finalize(node, false);
+    }
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token2 = scanner.getToken();
+      while (token2 !== 17 /* EOF */) {
+        if (skipUntilAfter.indexOf(token2) !== -1) {
+          _scanNext();
+          break;
+        } else if (skipUntil.indexOf(token2) !== -1) {
+          break;
+        }
+        token2 = _scanNext();
+      }
+    }
+    return node;
+  }
+  function _checkScanError() {
+    switch (scanner.getTokenError()) {
+      case 4 /* InvalidUnicode */:
+        _error(l10n.t("Invalid unicode sequence in string."), 260 /* InvalidUnicode */);
+        return true;
+      case 5 /* InvalidEscapeCharacter */:
+        _error(l10n.t("Invalid escape character in string."), 261 /* InvalidEscapeCharacter */);
+        return true;
+      case 3 /* UnexpectedEndOfNumber */:
+        _error(l10n.t("Unexpected end of number."), 259 /* UnexpectedEndOfNumber */);
+        return true;
+      case 1 /* UnexpectedEndOfComment */:
+        _error(l10n.t("Unexpected end of comment."), 257 /* UnexpectedEndOfComment */);
+        return true;
+      case 2 /* UnexpectedEndOfString */:
+        _error(l10n.t("Unexpected end of string."), 258 /* UnexpectedEndOfString */);
+        return true;
+      case 6 /* InvalidCharacter */:
+        _error(l10n.t("Invalid characters in string. Control characters must be escaped."), 262 /* InvalidCharacter */);
+        return true;
+    }
+    return false;
+  }
+  function _finalize(node, scanNext) {
+    node.length = scanner.getTokenOffset() + scanner.getTokenLength() - node.offset;
+    if (scanNext) {
+      _scanNext();
+    }
+    return node;
+  }
+  function _parseArray(parent) {
+    if (scanner.getToken() !== 3 /* OpenBracketToken */) {
+      return void 0;
+    }
+    const node = new ArrayASTNodeImpl(parent, scanner.getTokenOffset());
+    _scanNext();
+    const count = 0;
+    let needsComma = false;
+    while (scanner.getToken() !== 4 /* CloseBracketToken */ && scanner.getToken() !== 17 /* EOF */) {
+      if (scanner.getToken() === 5 /* CommaToken */) {
+        if (!needsComma) {
+          _error(l10n.t("Value expected"), 516 /* ValueExpected */);
+        }
+        const commaOffset = scanner.getTokenOffset();
+        _scanNext();
+        if (scanner.getToken() === 4 /* CloseBracketToken */) {
+          if (needsComma) {
+            _errorAtRange(l10n.t("Trailing comma"), 519 /* TrailingComma */, commaOffset, commaOffset + 1);
+          }
+          continue;
+        }
+      } else if (needsComma) {
+        _error(l10n.t("Expected comma"), 514 /* CommaExpected */);
+      }
+      const item = _parseValue(node);
+      if (!item) {
+        _error(l10n.t("Value expected"), 516 /* ValueExpected */, void 0, [], [4 /* CloseBracketToken */, 5 /* CommaToken */]);
+      } else {
+        node.items.push(item);
+      }
+      needsComma = true;
+    }
+    if (scanner.getToken() !== 4 /* CloseBracketToken */) {
+      return _error(l10n.t("Expected comma or closing bracket"), 517 /* CommaOrCloseBacketExpected */, node);
+    }
+    return _finalize(node, true);
+  }
+  const keyPlaceholder = new StringASTNodeImpl(void 0, 0, 0);
+  function _parseProperty(parent, keysSeen) {
+    const node = new PropertyASTNodeImpl(parent, scanner.getTokenOffset(), keyPlaceholder);
+    let key = _parseString(node);
+    if (!key) {
+      if (scanner.getToken() === 16 /* Unknown */) {
+        _error(l10n.t("Property keys must be doublequoted"), 528 /* PropertyKeysMustBeDoublequoted */);
+        const keyNode = new StringASTNodeImpl(node, scanner.getTokenOffset(), scanner.getTokenLength());
+        keyNode.value = scanner.getTokenValue();
+        key = keyNode;
+        _scanNext();
+      } else {
+        return void 0;
+      }
+    }
+    node.keyNode = key;
+    if (key.value !== "//") {
+      const seen = keysSeen[key.value];
+      if (seen) {
+        _errorAtRange(l10n.t("Duplicate object key"), 520 /* DuplicateKey */, node.keyNode.offset, node.keyNode.offset + node.keyNode.length, import_vscode_languageserver_types.DiagnosticSeverity.Warning);
+        if (isObject(seen)) {
+          _errorAtRange(l10n.t("Duplicate object key"), 520 /* DuplicateKey */, seen.keyNode.offset, seen.keyNode.offset + seen.keyNode.length, import_vscode_languageserver_types.DiagnosticSeverity.Warning);
+        }
+        keysSeen[key.value] = true;
+      } else {
+        keysSeen[key.value] = node;
+      }
+    }
+    if (scanner.getToken() === 6 /* ColonToken */) {
+      node.colonOffset = scanner.getTokenOffset();
+      _scanNext();
+    } else {
+      _error(l10n.t("Colon expected"), 515 /* ColonExpected */);
+      if ((scanner.getToken() === 18 /* SingleQuoteStringLiteral */ || scanner.getToken() === 19 /* DoubleQuoteStringLiteral */) && textDocument.positionAt(key.offset + key.length).line < textDocument.positionAt(scanner.getTokenOffset()).line) {
+        node.length = key.length;
+        return node;
+      }
+    }
+    const value = _parseValue(node);
+    if (!value) {
+      return _error(l10n.t("Value expected"), 516 /* ValueExpected */, node, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
+    }
+    node.valueNode = value;
+    node.length = value.offset + value.length - node.offset;
+    return node;
+  }
+  function _parseObject(parent) {
+    if (scanner.getToken() !== 1 /* OpenBraceToken */) {
+      return void 0;
+    }
+    const node = new ObjectASTNodeImpl(parent, scanner.getTokenOffset());
+    const keysSeen = /* @__PURE__ */ Object.create(null);
+    _scanNext();
+    let needsComma = false;
+    while (scanner.getToken() !== 2 /* CloseBraceToken */ && scanner.getToken() !== 17 /* EOF */) {
+      if (scanner.getToken() === 5 /* CommaToken */) {
+        if (!needsComma) {
+          _error(l10n.t("Property expected"), 513 /* PropertyExpected */);
+        }
+        const commaOffset = scanner.getTokenOffset();
+        _scanNext();
+        if (scanner.getToken() === 2 /* CloseBraceToken */) {
+          if (needsComma) {
+            _errorAtRange(l10n.t("Trailing comma"), 519 /* TrailingComma */, commaOffset, commaOffset + 1);
+          }
+          continue;
+        }
+      } else if (needsComma) {
+        _error(l10n.t("Expected comma"), 514 /* CommaExpected */);
+      }
+      const property = _parseProperty(node, keysSeen);
+      if (!property) {
+        _error(l10n.t("Property expected"), 513 /* PropertyExpected */, void 0, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
+      } else {
+        node.properties.push(property);
+      }
+      needsComma = true;
+    }
+    if (scanner.getToken() !== 2 /* CloseBraceToken */) {
+      return _error(l10n.t("Expected comma or closing brace"), 518 /* CommaOrCloseBraceExpected */, node);
+    }
+    return _finalize(node, true);
+  }
+  function _parseString(parent) {
+    if (scanner.getToken() !== 18 /* SingleQuoteStringLiteral */ && scanner.getToken() !== 19 /* DoubleQuoteStringLiteral */) {
+      return void 0;
+    }
+    if (scanner.getToken() === 18 /* SingleQuoteStringLiteral */) {
+      _error(l10n.t("String value must be doublequoted"), 529 /* StringValueMustBeDoublequoted */);
+    }
+    const node = new StringASTNodeImpl(parent, scanner.getTokenOffset());
+    node.value = scanner.getTokenValue();
+    return _finalize(node, true);
+  }
+  function _parseNumber(parent) {
+    if (scanner.getToken() !== 11 /* NumericLiteral */) {
+      return void 0;
+    }
+    const node = new NumberASTNodeImpl(parent, scanner.getTokenOffset());
+    if (scanner.getTokenError() === 0 /* None */) {
+      const tokenValue = scanner.getTokenValue();
+      try {
+        const numberValue = JSON.parse(tokenValue);
+        if (!isNumber(numberValue)) {
+          return _error(l10n.t("Invalid number format."), 0 /* Undefined */, node);
+        }
+        node.value = numberValue;
+      } catch (e) {
+        return _error(l10n.t("Invalid number format."), 0 /* Undefined */, node);
+      }
+      node.isInteger = tokenValue.indexOf(".") === -1;
+    }
+    return _finalize(node, true);
+  }
+  function _parseLiteral(parent) {
+    let node;
+    switch (scanner.getToken()) {
+      case 7 /* NullKeyword */:
+        return _finalize(new NullASTNodeImpl(parent, scanner.getTokenOffset()), true);
+      case 8 /* TrueKeyword */:
+        return _finalize(new BooleanASTNodeImpl(parent, true, scanner.getTokenOffset()), true);
+      case 9 /* FalseKeyword */:
+        return _finalize(new BooleanASTNodeImpl(parent, false, scanner.getTokenOffset()), true);
+      default:
+        return void 0;
+    }
+  }
+  function _parseValue(parent) {
+    return _parseArray(parent) || _parseObject(parent) || _parseString(parent) || _parseNumber(parent) || _parseLiteral(parent);
+  }
+  let _root = void 0;
+  const token = _scanNext();
+  if (token !== 17 /* EOF */) {
+    _root = _parseValue(_root);
+    if (!_root) {
+      _error(l10n.t("Expected a JSON object, array or literal."), 0 /* Undefined */);
+    } else if (scanner.getToken() !== 17 /* EOF */) {
+      _error(l10n.t("End of file expected."), 0 /* Undefined */);
+    }
+  }
+  return {
+    // _root is undefined is source is empty string
+    ast: _root,
+    problems,
+    commentRanges
+  };
+}
+
+// src/helpers.ts
+function contains(node, offset, includeRightBound = false) {
+  return offset >= node.offset && offset < node.offset + node.length || includeRightBound && offset === node.offset + node.length;
+}
+function findNodeAtOffset(node, offset, includeRightBound = false) {
+  if (contains(node, offset, includeRightBound)) {
+    const { children } = node;
+    if (Array.isArray(children)) {
+      for (let i = 0; i < children.length && children[i].offset <= offset; i++) {
+        const item = findNodeAtOffset(children[i], offset, includeRightBound);
+        if (item) {
+          return item;
+        }
+      }
+    }
+    return node;
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ErrorCode,
+  findNodeAtOffset,
+  parse
+});
+//# sourceMappingURL=index.js.map