@asymmetric-effort/jsonlint 0.0.1 → 0.0.3

package/build/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/build/cli.d.ts

@@ -0,0 +1 @@
+export declare function main(args?: string[]): void;

package/build/formatter.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Character-by-character JSON formatter.
+ * Works even on invalid JSON — used for best-effort pretty-printing.
+ */
+export declare function formatJson(json: string, indent?: string): string;

package/build/index.d.ts

@@ -0,0 +1,14 @@
+export { JsonParser, parse, ParseError } from "./parser.js";
+export { Lexer, LexerError, TokenType } from "./lexer.js";
+export type { Token, SourceLocation } from "./lexer.js";
+export type { ParseErrorHash } from "./parser.js";
+export { formatJson } from "./formatter.js";
+export { SchemaValidator } from "./schema.js";
+export type { JsonSchema, SchemaError } from "./schema.js";
+export { main } from "./cli.js";
+import { JsonParser } from "./parser.js";
+export declare const parser: JsonParser;
+import { formatJson } from "./formatter.js";
+export declare const formatter: {
+    formatJson: typeof formatJson;
+};

package/build/index.js

@@ -0,0 +1,1129 @@
+// src/lexer.ts
+var TokenType;
+((TokenType2) => {
+  TokenType2["STRING"] = "STRING";
+  TokenType2["NUMBER"] = "NUMBER";
+  TokenType2["TRUE"] = "TRUE";
+  TokenType2["FALSE"] = "FALSE";
+  TokenType2["NULL"] = "NULL";
+  TokenType2["LBRACE"] = "{";
+  TokenType2["RBRACE"] = "}";
+  TokenType2["LBRACKET"] = "[";
+  TokenType2["RBRACKET"] = "]";
+  TokenType2["COMMA"] = ",";
+  TokenType2["COLON"] = ":";
+  TokenType2["EOF"] = "EOF";
+  TokenType2["INVALID"] = "INVALID";
+})(TokenType ||= {});
+
+class LexerError extends Error {
+  line;
+  column;
+  position;
+  input;
+  constructor(message, line, column, position, input) {
+    super(message);
+    this.name = "LexerError";
+    this.line = line;
+    this.column = column;
+    this.position = position;
+    this.input = input;
+  }
+  showPosition() {
+    const lines = this.input.split(`
+`);
+    const errorLine = lines[this.line - 1] || "";
+    const before = errorLine.substring(Math.max(0, this.column - 20), this.column);
+    const after = errorLine.substring(this.column, this.column + 20);
+    const pad = new Array(before.length + 1).join("-");
+    return before + after + `
+` + pad + "^";
+  }
+}
+
+class Lexer {
+  input = "";
+  pos = 0;
+  line = 1;
+  column = 0;
+  setInput(input) {
+    this.input = input;
+    this.pos = 0;
+    this.line = 1;
+    this.column = 0;
+  }
+  peek() {
+    return this.input[this.pos] ?? "";
+  }
+  advance() {
+    const ch = this.input[this.pos];
+    this.pos++;
+    if (ch === `
+`) {
+      this.line++;
+      this.column = 0;
+    } else {
+      this.column++;
+    }
+    return ch ?? "";
+  }
+  skipWhitespace() {
+    while (this.pos < this.input.length) {
+      const ch = this.input[this.pos];
+      if (ch === " " || ch === "\t" || ch === `
+` || ch === "\r") {
+        this.advance();
+      } else {
+        break;
+      }
+    }
+  }
+  readString() {
+    const startLine = this.line;
+    const startCol = this.column;
+    this.advance();
+    let value = "";
+    while (this.pos < this.input.length) {
+      const ch = this.input[this.pos];
+      if (ch.charCodeAt(0) >= 0 && ch.charCodeAt(0) <= 31) {
+        if (ch === `
+` || ch === "\r") {
+          throw new LexerError(`Lexical error on line ${this.line}. Bad string: unterminated string.
+${this.showPositionAt(startLine, startCol)}`, this.line, this.column, this.pos, this.input);
+        }
+        throw new LexerError(`Lexical error on line ${this.line}. Bad string: control character in string.
+${this.showPositionAt(this.line, this.column)}`, this.line, this.column, this.pos, this.input);
+      }
+      if (ch === '"') {
+        this.advance();
+        return {
+          type: "STRING" /* STRING */,
+          value,
+          loc: {
+            first_line: startLine,
+            last_line: this.line,
+            first_column: startCol,
+            last_column: this.column
+          }
+        };
+      }
+      if (ch === "\\") {
+        this.advance();
+        const escaped = this.input[this.pos];
+        if (escaped === undefined) {
+          throw new LexerError(`Lexical error on line ${this.line}. Bad string: unterminated escape sequence.
+${this.showPositionAt(this.line, this.column)}`, this.line, this.column, this.pos, this.input);
+        }
+        switch (escaped) {
+          case '"':
+            value += '"';
+            this.advance();
+            break;
+          case "\\":
+            value += "\\";
+            this.advance();
+            break;
+          case "/":
+            value += "/";
+            this.advance();
+            break;
+          case "b":
+            value += "\b";
+            this.advance();
+            break;
+          case "f":
+            value += "\f";
+            this.advance();
+            break;
+          case "n":
+            value += `
+`;
+            this.advance();
+            break;
+          case "r":
+            value += "\r";
+            this.advance();
+            break;
+          case "t":
+            value += "\t";
+            this.advance();
+            break;
+          case "u": {
+            this.advance();
+            let hex = "";
+            for (let i = 0;i < 4; i++) {
+              const h = this.input[this.pos];
+              if (h === undefined || !/[0-9a-fA-F]/.test(h)) {
+                throw new LexerError(`Lexical error on line ${this.line}. Bad string: invalid unicode escape.
+${this.showPositionAt(this.line, this.column)}`, this.line, this.column, this.pos, this.input);
+              }
+              hex += h;
+              this.advance();
+            }
+            value += String.fromCharCode(parseInt(hex, 16));
+            break;
+          }
+          default:
+            throw new LexerError(`Lexical error on line ${this.line}. Bad string: invalid escape character '\\${escaped}'.
+${this.showPositionAt(this.line, this.column)}`, this.line, this.column, this.pos, this.input);
+        }
+        continue;
+      }
+      value += ch;
+      this.advance();
+    }
+    throw new LexerError(`Lexical error on line ${this.line}. Bad string: unterminated string.
+${this.showPositionAt(startLine, startCol)}`, this.line, this.column, this.pos, this.input);
+  }
+  readNumber() {
+    const startLine = this.line;
+    const startCol = this.column;
+    let numStr = "";
+    if (this.peek() === "-") {
+      numStr += this.advance();
+    }
+    if (this.peek() === "0") {
+      numStr += this.advance();
+      if (this.pos < this.input.length && /[0-9]/.test(this.peek())) {
+        throw new LexerError(`Lexical error on line ${this.line}. Bad number: leading zeros are not allowed.
+${this.showPositionAt(this.line, this.column)}`, this.line, this.column, this.pos, this.input);
+      }
+    } else if (/[1-9]/.test(this.peek())) {
+      numStr += this.advance();
+      while (this.pos < this.input.length && /[0-9]/.test(this.peek())) {
+        numStr += this.advance();
+      }
+    } else {
+      throw new LexerError(`Lexical error on line ${this.line}. Bad number: expected digit.
+${this.showPositionAt(this.line, this.column)}`, this.line, this.column, this.pos, this.input);
+    }
+    if (this.peek() === ".") {
+      numStr += this.advance();
+      if (!/[0-9]/.test(this.peek())) {
+        throw new LexerError(`Lexical error on line ${this.line}. Bad number: expected digit after decimal point.
+${this.showPositionAt(this.line, this.column)}`, this.line, this.column, this.pos, this.input);
+      }
+      while (this.pos < this.input.length && /[0-9]/.test(this.peek())) {
+        numStr += this.advance();
+      }
+    }
+    if (this.peek() === "e" || this.peek() === "E") {
+      numStr += this.advance();
+      if (this.peek() === "+" || this.peek() === "-") {
+        numStr += this.advance();
+      }
+      if (!/[0-9]/.test(this.peek())) {
+        throw new LexerError(`Lexical error on line ${this.line}. Bad number: expected digit in exponent.
+${this.showPositionAt(this.line, this.column)}`, this.line, this.column, this.pos, this.input);
+      }
+      while (this.pos < this.input.length && /[0-9]/.test(this.peek())) {
+        numStr += this.advance();
+      }
+    }
+    return {
+      type: "NUMBER" /* NUMBER */,
+      value: numStr,
+      loc: {
+        first_line: startLine,
+        last_line: this.line,
+        first_column: startCol,
+        last_column: this.column
+      }
+    };
+  }
+  readKeyword(expected, tokenType) {
+    const startLine = this.line;
+    const startCol = this.column;
+    for (let i = 0;i < expected.length; i++) {
+      if (this.pos >= this.input.length || this.input[this.pos] !== expected[i]) {
+        throw new LexerError(`Lexical error on line ${this.line}. Unrecognized text.
+${this.showPositionAt(this.line, this.column)}`, this.line, this.column, this.pos, this.input);
+      }
+      this.advance();
+    }
+    return {
+      type: tokenType,
+      value: expected,
+      loc: {
+        first_line: startLine,
+        last_line: this.line,
+        first_column: startCol,
+        last_column: this.column
+      }
+    };
+  }
+  showPositionAt(line, col) {
+    const lines = this.input.split(`
+`);
+    const errorLine = lines[line - 1] || "";
+    const before = errorLine.substring(Math.max(0, col - 20), col);
+    const after = errorLine.substring(col, col + 20);
+    const pad = new Array(before.length + 1).join("-");
+    return before + after + `
+` + pad + "^";
+  }
+  nextToken() {
+    this.skipWhitespace();
+    if (this.pos >= this.input.length) {
+      return {
+        type: "EOF" /* EOF */,
+        value: "",
+        loc: {
+          first_line: this.line,
+          last_line: this.line,
+          first_column: this.column,
+          last_column: this.column
+        }
+      };
+    }
+    const ch = this.peek();
+    const startLine = this.line;
+    const startCol = this.column;
+    switch (ch) {
+      case "{":
+        this.advance();
+        return {
+          type: "{" /* LBRACE */,
+          value: "{",
+          loc: {
+            first_line: startLine,
+            last_line: this.line,
+            first_column: startCol,
+            last_column: this.column
+          }
+        };
+      case "}":
+        this.advance();
+        return {
+          type: "}" /* RBRACE */,
+          value: "}",
+          loc: {
+            first_line: startLine,
+            last_line: this.line,
+            first_column: startCol,
+            last_column: this.column
+          }
+        };
+      case "[":
+        this.advance();
+        return {
+          type: "[" /* LBRACKET */,
+          value: "[",
+          loc: {
+            first_line: startLine,
+            last_line: this.line,
+            first_column: startCol,
+            last_column: this.column
+          }
+        };
+      case "]":
+        this.advance();
+        return {
+          type: "]" /* RBRACKET */,
+          value: "]",
+          loc: {
+            first_line: startLine,
+            last_line: this.line,
+            first_column: startCol,
+            last_column: this.column
+          }
+        };
+      case ",":
+        this.advance();
+        return {
+          type: "," /* COMMA */,
+          value: ",",
+          loc: {
+            first_line: startLine,
+            last_line: this.line,
+            first_column: startCol,
+            last_column: this.column
+          }
+        };
+      case ":":
+        this.advance();
+        return {
+          type: ":" /* COLON */,
+          value: ":",
+          loc: {
+            first_line: startLine,
+            last_line: this.line,
+            first_column: startCol,
+            last_column: this.column
+          }
+        };
+      case '"':
+        return this.readString();
+      case "t":
+        return this.readKeyword("true", "TRUE" /* TRUE */);
+      case "f":
+        return this.readKeyword("false", "FALSE" /* FALSE */);
+      case "n":
+        return this.readKeyword("null", "NULL" /* NULL */);
+      case "-":
+        return this.readNumber();
+      default:
+        if (/[0-9]/.test(ch)) {
+          return this.readNumber();
+        }
+        throw new LexerError(`Lexical error on line ${this.line}. Unrecognized text.
+${this.showPositionAt(this.line, this.column)}`, this.line, this.column, this.pos, this.input);
+    }
+  }
+}
+
+// src/parser.ts
+class ParseError extends Error {
+  hash;
+  constructor(message, hash) {
+    super(message);
+    this.name = "ParseError";
+    this.hash = hash;
+  }
+}
+
+class JsonParser {
+  lexer;
+  currentToken;
+  previousToken = null;
+  input = "";
+  yy = {};
+  parseError = null;
+  constructor() {
+    this.lexer = new Lexer;
+  }
+  parse(input) {
+    this.input = input;
+    this.lexer.setInput(input);
+    this.currentToken = this.lexer.nextToken();
+    const result = this.parseValue();
+    this.expect("EOF" /* EOF */);
+    return result;
+  }
+  advance() {
+    this.previousToken = this.currentToken;
+    this.currentToken = this.lexer.nextToken();
+    return this.previousToken;
+  }
+  expect(type) {
+    if (this.currentToken.type !== type) {
+      this.throwParseError(type);
+    }
+    return this.advance();
+  }
+  throwParseError(...expected) {
+    const token = this.currentToken;
+    const hash = {
+      text: token.value,
+      token: token.type,
+      line: token.loc.first_line,
+      loc: token.loc,
+      expected: expected.map((t) => `'${t}'`)
+    };
+    if (this.parseError) {
+      this.parseError(this.formatError(token, expected), hash);
+    }
+    const msg = this.formatError(token, expected);
+    throw new ParseError(msg, hash);
+  }
+  formatError(token, expected) {
+    const line = token.loc.first_line;
+    const position = this.showPosition(token);
+    const expectedStr = expected.map((t) => `'${t}'`).join(", ");
+    const got = token.type === "EOF" /* EOF */ ? "'EOF'" : `'${token.value || token.type}'`;
+    return `Parse error on line ${line}:
+${position}
+Expecting ${expectedStr}, got ${got}`;
+  }
+  showPosition(token) {
+    const lines = this.input.split(`
+`);
+    const lineIdx = token.loc.first_line - 1;
+    const errorLine = lines[lineIdx] || "";
+    const col = token.loc.first_column;
+    const before = errorLine.substring(Math.max(0, col - 20), col);
+    const after = errorLine.substring(col, col + 20);
+    const pad = new Array(before.length + 1).join("-");
+    return before + after + `
+` + pad + "^";
+  }
+  parseValue() {
+    switch (this.currentToken.type) {
+      case "STRING" /* STRING */:
+        return this.advance().value;
+      case "NUMBER" /* NUMBER */:
+        return Number(this.advance().value);
+      case "TRUE" /* TRUE */:
+        this.advance();
+        return true;
+      case "FALSE" /* FALSE */:
+        this.advance();
+        return false;
+      case "NULL" /* NULL */:
+        this.advance();
+        return null;
+      case "{" /* LBRACE */:
+        return this.parseObject();
+      case "[" /* LBRACKET */:
+        return this.parseArray();
+      default:
+        this.throwParseError("STRING" /* STRING */, "NUMBER" /* NUMBER */, "NULL" /* NULL */, "TRUE" /* TRUE */, "FALSE" /* FALSE */, "{" /* LBRACE */, "[" /* LBRACKET */);
+    }
+  }
+  parseObject() {
+    this.expect("{" /* LBRACE */);
+    const obj = {};
+    if (this.currentToken.type === "}" /* RBRACE */) {
+      this.advance();
+      return obj;
+    }
+    this.parseMember(obj);
+    while (this.currentToken.type === "," /* COMMA */) {
+      this.advance();
+      this.parseMember(obj);
+    }
+    this.expect("}" /* RBRACE */);
+    return obj;
+  }
+  parseMember(obj) {
+    if (this.currentToken.type !== "STRING" /* STRING */) {
+      this.throwParseError("STRING" /* STRING */);
+    }
+    const key = this.advance().value;
+    this.expect(":" /* COLON */);
+    obj[key] = this.parseValue();
+  }
+  parseArray() {
+    this.expect("[" /* LBRACKET */);
+    const arr = [];
+    if (this.currentToken.type === "]" /* RBRACKET */) {
+      this.advance();
+      return arr;
+    }
+    arr.push(this.parseValue());
+    while (this.currentToken.type === "," /* COMMA */) {
+      this.advance();
+      arr.push(this.parseValue());
+    }
+    this.expect("]" /* RBRACKET */);
+    return arr;
+  }
+}
+var defaultParser = new JsonParser;
+function parse(input) {
+  return defaultParser.parse(input);
+}
+// src/formatter.ts
+function formatJson(json, indent = "  ") {
+  let result = "";
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  let i = 0;
+  const newline = () => {
+    return `
+` + indent.repeat(depth);
+  };
+  while (i < json.length) {
+    const ch = json[i];
+    if (escaped) {
+      result += ch;
+      escaped = false;
+      i++;
+      continue;
+    }
+    if (ch === "\\" && inString) {
+      result += ch;
+      escaped = true;
+      i++;
+      continue;
+    }
+    if (ch === '"' && !escaped) {
+      inString = !inString;
+      result += ch;
+      i++;
+      continue;
+    }
+    if (inString) {
+      result += ch;
+      i++;
+      continue;
+    }
+    switch (ch) {
+      case "{":
+      case "[":
+        result += ch;
+        depth++;
+        if (!isEmptyBracket(json, i)) {
+          result += newline();
+        }
+        break;
+      case "}":
+      case "]":
+        depth = Math.max(0, depth - 1);
+        if (!isPrecededByOpen(result, ch)) {
+          result += newline();
+        }
+        result += ch;
+        break;
+      case ",":
+        result += ch;
+        result += newline();
+        break;
+      case ":":
+        result += ": ";
+        break;
+      case " ":
+      case "\t":
+      case `
+`:
+      case "\r":
+        break;
+      default:
+        result += ch;
+        break;
+    }
+    i++;
+  }
+  return result;
+}
+function isEmptyBracket(json, openPos) {
+  const openChar = json[openPos];
+  const closeChar = openChar === "{" ? "}" : "]";
+  let j = openPos + 1;
+  while (j < json.length) {
+    const ch = json[j];
+    if (ch === " " || ch === "\t" || ch === `
+` || ch === "\r") {
+      j++;
+      continue;
+    }
+    return ch === closeChar;
+  }
+  return false;
+}
+function isPrecededByOpen(result, closeChar) {
+  const openChar = closeChar === "}" ? "{" : "[";
+  for (let i = result.length - 1;i >= 0; i--) {
+    const ch = result[i];
+    if (ch === " " || ch === "\t" || ch === `
+` || ch === "\r") {
+      continue;
+    }
+    return ch === openChar;
+  }
+  return false;
+}
+// src/schema.ts
+function getType(value) {
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return "array";
+  return typeof value;
+}
+function deepEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a === null || b === null)
+    return false;
+  if (typeof a !== typeof b)
+    return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length)
+      return false;
+    for (let i = 0;i < a.length; i++) {
+      if (!deepEqual(a[i], b[i]))
+        return false;
+    }
+    return true;
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const aObj = a;
+    const bObj = b;
+    const aKeys = Object.keys(aObj);
+    const bKeys = Object.keys(bObj);
+    if (aKeys.length !== bKeys.length)
+      return false;
+    for (const key of aKeys) {
+      if (!deepEqual(aObj[key], bObj[key]))
+        return false;
+    }
+    return true;
+  }
+  return false;
+}
+
+class SchemaValidator {
+  schemas = new Map;
+  errors = [];
+  validate(instance, schema, path = "") {
+    this.errors = [];
+    this.collectSchemas(schema, "");
+    this.doValidate(instance, schema, path);
+    return this.errors;
+  }
+  collectSchemas(schema, basePath) {
+    if (schema.id) {
+      this.schemas.set(schema.id, schema);
+    }
+    if (schema.properties) {
+      for (const [key, prop] of Object.entries(schema.properties)) {
+        this.collectSchemas(prop, `${basePath}/properties/${key}`);
+      }
+    }
+    if (schema.items && !Array.isArray(schema.items)) {
+      this.collectSchemas(schema.items, `${basePath}/items`);
+    }
+  }
+  resolveRef(ref) {
+    return this.schemas.get(ref) || null;
+  }
+  addError(path, message) {
+    this.errors.push({ property: path, message });
+  }
+  doValidate(instance, schema, path) {
+    if (schema.$ref) {
+      const resolved = this.resolveRef(schema.$ref);
+      if (resolved) {
+        this.doValidate(instance, resolved, path);
+      }
+      return;
+    }
+    if (schema.extends) {
+      const extList = Array.isArray(schema.extends) ? schema.extends : [schema.extends];
+      for (const ext of extList) {
+        this.doValidate(instance, ext, path);
+      }
+    }
+    if (schema.type !== undefined) {
+      const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+      const actualType = getType(instance);
+      const typeMatch = types.some((t) => {
+        if (t === "any")
+          return true;
+        if (t === "integer")
+          return actualType === "number" && Number.isInteger(instance);
+        if (t === "number")
+          return actualType === "number";
+        return t === actualType;
+      });
+      if (!typeMatch) {
+        this.addError(path, `Expected type ${types.join(" or ")} but found type ${actualType}`);
+        return;
+      }
+    }
+    if (schema.disallow !== undefined) {
+      const disallowed = Array.isArray(schema.disallow) ? schema.disallow : [schema.disallow];
+      const actualType = getType(instance);
+      if (disallowed.some((t) => {
+        if (t === "integer")
+          return actualType === "number" && Number.isInteger(instance);
+        return t === actualType;
+      })) {
+        this.addError(path, `Type ${actualType} is disallowed`);
+      }
+    }
+    if (schema.enum !== undefined) {
+      if (!schema.enum.some((e) => deepEqual(e, instance))) {
+        this.addError(path, `Value ${JSON.stringify(instance)} is not one of the allowed enum values`);
+      }
+    }
+    if (typeof instance === "string") {
+      if (schema.minLength !== undefined && instance.length < schema.minLength) {
+        this.addError(path, `String is too short (${instance.length} < ${schema.minLength})`);
+      }
+      if (schema.maxLength !== undefined && instance.length > schema.maxLength) {
+        this.addError(path, `String is too long (${instance.length} > ${schema.maxLength})`);
+      }
+      if (schema.pattern !== undefined) {
+        const re = new RegExp(schema.pattern);
+        if (!re.test(instance)) {
+          this.addError(path, `String does not match pattern: ${schema.pattern}`);
+        }
+      }
+    }
+    if (typeof instance === "number") {
+      if (schema.minimum !== undefined) {
+        if (schema.exclusiveMinimum) {
+          if (instance <= schema.minimum) {
+            this.addError(path, `Value ${instance} must be greater than ${schema.minimum}`);
+          }
+        } else {
+          if (instance < schema.minimum) {
+            this.addError(path, `Value ${instance} must be at least ${schema.minimum}`);
+          }
+        }
+      }
+      if (schema.maximum !== undefined) {
+        if (schema.exclusiveMaximum) {
+          if (instance >= schema.maximum) {
+            this.addError(path, `Value ${instance} must be less than ${schema.maximum}`);
+          }
+        } else {
+          if (instance > schema.maximum) {
+            this.addError(path, `Value ${instance} must be at most ${schema.maximum}`);
+          }
+        }
+      }
+      if (schema.divisibleBy !== undefined && schema.divisibleBy !== 0) {
+        if (instance % schema.divisibleBy !== 0) {
+          this.addError(path, `Value ${instance} is not divisible by ${schema.divisibleBy}`);
+        }
+      }
+    }
+    if (typeof instance === "object" && instance !== null && !Array.isArray(instance)) {
+      const obj = instance;
+      const objKeys = Object.keys(obj);
+      if (schema.properties) {
+        for (const [key, propSchema] of Object.entries(schema.properties)) {
+          const propPath = path ? `${path}.${key}` : key;
+          if (key in obj) {
+            this.doValidate(obj[key], propSchema, propPath);
+          } else if (propSchema.required === true) {
+            this.addError(propPath, `Property is required`);
+          }
+        }
+      }
+      if (schema.patternProperties) {
+        for (const [pattern, propSchema] of Object.entries(schema.patternProperties)) {
+          const re = new RegExp(pattern);
+          for (const key of objKeys) {
+            if (re.test(key)) {
+              const propPath = path ? `${path}.${key}` : key;
+              this.doValidate(obj[key], propSchema, propPath);
+            }
+          }
+        }
+      }
+      if (schema.additionalProperties !== undefined) {
+        const knownKeys = new Set;
+        if (schema.properties) {
+          for (const key of Object.keys(schema.properties)) {
+            knownKeys.add(key);
+          }
+        }
+        if (schema.patternProperties) {
+          for (const pattern of Object.keys(schema.patternProperties)) {
+            const re = new RegExp(pattern);
+            for (const key of objKeys) {
+              if (re.test(key))
+                knownKeys.add(key);
+            }
+          }
+        }
+        for (const key of objKeys) {
+          if (!knownKeys.has(key)) {
+            if (schema.additionalProperties === false) {
+              const propPath = path ? `${path}.${key}` : key;
+              this.addError(propPath, `Additional property not allowed`);
+            } else if (typeof schema.additionalProperties === "object") {
+              const propPath = path ? `${path}.${key}` : key;
+              this.doValidate(obj[key], schema.additionalProperties, propPath);
+            }
+          }
+        }
+      }
+      if (schema.dependencies) {
+        for (const [key, dep] of Object.entries(schema.dependencies)) {
+          if (key in obj) {
+            if (typeof dep === "string") {
+              if (!(dep in obj)) {
+                this.addError(path, `Property ${key} requires ${dep}`);
+              }
+            } else if (Array.isArray(dep)) {
+              for (const d of dep) {
+                if (!(d in obj)) {
+                  this.addError(path, `Property ${key} requires ${d}`);
+                }
+              }
+            } else {
+              this.doValidate(instance, dep, path);
+            }
+          }
+        }
+      }
+    }
+    if (Array.isArray(instance)) {
+      if (schema.minItems !== undefined && instance.length < schema.minItems) {
+        this.addError(path, `Array has too few items (${instance.length} < ${schema.minItems})`);
+      }
+      if (schema.maxItems !== undefined && instance.length > schema.maxItems) {
+        this.addError(path, `Array has too many items (${instance.length} > ${schema.maxItems})`);
+      }
+      if (schema.uniqueItems === true) {
+        for (let i = 0;i < instance.length; i++) {
+          for (let j = i + 1;j < instance.length; j++) {
+            if (deepEqual(instance[i], instance[j])) {
+              this.addError(path, `Array items must be unique (duplicate at index ${j})`);
+            }
+          }
+        }
+      }
+      if (schema.items) {
+        if (Array.isArray(schema.items)) {
+          for (let i = 0;i < instance.length; i++) {
+            if (i < schema.items.length) {
+              this.doValidate(instance[i], schema.items[i], `${path}[${i}]`);
+            }
+          }
+        } else {
+          for (let i = 0;i < instance.length; i++) {
+            this.doValidate(instance[i], schema.items, `${path}[${i}]`);
+          }
+        }
+      }
+    }
+  }
+}
+// src/cli.ts
+import { readFileSync, writeFileSync } from "fs";
+
+// src/version.ts
+var VERSION = "0.0.3";
+
+// src/cli.ts
+function printVersion() {
+  process.stdout.write(`${VERSION}
+`);
+}
+function printUsage() {
+  process.stdout.write(`Usage: jsonlint [OPTIONS] [FILE]
+
+Options:
+  -v, --version            Print version and exit
+  -s, --sort-keys          Sort object keys in output
+  -i, --in-place           Overwrite the input file with formatted output
+  -t, --indent CHAR        Character(s) to use for indentation (default: "  ")
+  -c, --compact            Compact error display
+  -V, --validate FILE      Validate against a JSON Schema file
+  -e, --environment ENV    JSON Schema spec version (default: json-schema-draft-03)
+  -q, --quiet              Do not print parsed JSON to stdout
+  -p, --pretty-print       Force pretty printing (even if invalid)
+  -h, --help               Show this help message
+
+If FILE is omitted, reads from stdin.
+`);
+}
+function parseArgs(args) {
+  const opts = {
+    file: null,
+    sortKeys: false,
+    inPlace: false,
+    indent: "  ",
+    compact: false,
+    validate: null,
+    environment: "json-schema-draft-03",
+    quiet: false,
+    prettyPrint: false,
+    version: false
+  };
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    switch (arg) {
+      case "-v":
+      case "--version":
+        opts.version = true;
+        break;
+      case "-s":
+      case "--sort-keys":
+        opts.sortKeys = true;
+        break;
+      case "-i":
+      case "--in-place":
+        opts.inPlace = true;
+        break;
+      case "-t":
+      case "--indent":
+        i++;
+        opts.indent = args[i] ?? "  ";
+        break;
+      case "-c":
+      case "--compact":
+        opts.compact = true;
+        break;
+      case "-V":
+      case "--validate":
+        i++;
+        opts.validate = args[i] ?? null;
+        break;
+      case "-e":
+      case "--environment":
+        i++;
+        opts.environment = args[i] ?? "json-schema-draft-03";
+        break;
+      case "-q":
+      case "--quiet":
+        opts.quiet = true;
+        break;
+      case "-p":
+      case "--pretty-print":
+        opts.prettyPrint = true;
+        break;
+      case "-h":
+      case "--help":
+        printUsage();
+        process.exit(0);
+        break;
+      default:
+        if (arg.startsWith("-")) {
+          process.stderr.write(`Unknown option: ${arg}
+`);
+          process.exit(1);
+        }
+        opts.file = arg;
+        break;
+    }
+    i++;
+  }
+  return opts;
+}
+function sortObject(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map(sortObject);
+  }
+  if (obj !== null && typeof obj === "object") {
+    const sorted = {};
+    const keys = Object.keys(obj).sort();
+    for (const key of keys) {
+      sorted[key] = sortObject(obj[key]);
+    }
+    return sorted;
+  }
+  return obj;
+}
+function readStdin() {
+  try {
+    return readFileSync("/dev/stdin", "utf-8");
+  } catch {
+    process.stderr.write(`Error reading from stdin
+`);
+    process.exit(1);
+  }
+}
+function main(args) {
+  const cliArgs = args ?? process.argv.slice(2);
+  const opts = parseArgs(cliArgs);
+  if (opts.version) {
+    printVersion();
+    return;
+  }
+  let input;
+  let filename;
+  if (opts.file) {
+    try {
+      input = readFileSync(opts.file, "utf-8");
+    } catch {
+      process.stderr.write(`Error: could not open file '${opts.file}'
+`);
+      process.exit(1);
+      return;
+    }
+    filename = opts.file;
+  } else {
+    input = readStdin();
+    filename = "<stdin>";
+  }
+  const parser = new JsonParser;
+  if (opts.compact) {
+    parser.parseError = (str, hash) => {
+      const line = hash.line;
+      const col = hash.loc.last_column;
+      const found = hash.token === "EOF" ? "EOF" : hash.text || hash.token;
+      const expected = hash.expected.join(", ");
+      const msg = `${filename}: line ${line}, col ${col}, found: '${found}' - expected: ${expected}.`;
+      throw new ParseError(msg, hash);
+    };
+  }
+  function formatCompactError(e) {
+    if (opts.compact && e instanceof LexerError) {
+      return `${filename}: line ${e.line}, col ${e.column}, ${e.message.split(`
+`)[0]}`;
+    }
+    return e instanceof Error ? e.message : String(e);
+  }
+  let parsed;
+  try {
+    parsed = parser.parse(input);
+  } catch (e) {
+    if (opts.prettyPrint) {
+      const formatted = formatJson(input, opts.indent);
+      process.stdout.write(formatted + `
+`);
+      try {
+        const reformatParser = new JsonParser;
+        if (opts.compact) {
+          reformatParser.parseError = parser.parseError;
+        }
+        reformatParser.parse(formatted);
+      } catch (e2) {
+        process.stderr.write(formatCompactError(e2) + `
+`);
+      }
+      process.exit(1);
+      return;
+    }
+    process.stderr.write(formatCompactError(e) + `
+`);
+    process.exit(1);
+    return;
+  }
+  if (opts.validate) {
+    let schemaInput;
+    try {
+      schemaInput = readFileSync(opts.validate, "utf-8");
+    } catch {
+      process.stderr.write(`Error: could not open schema file '${opts.validate}'
+`);
+      process.exit(1);
+      return;
+    }
+    let schema;
+    try {
+      schema = JSON.parse(schemaInput);
+    } catch {
+      process.stderr.write(`Error: invalid JSON in schema file '${opts.validate}'
+`);
+      process.exit(1);
+      return;
+    }
+    const validator = new SchemaValidator;
+    const errors = validator.validate(parsed, schema);
+    if (errors.length > 0) {
+      for (const err of errors) {
+        process.stderr.write(`Schema validation error: property '${err.property}': ${err.message}
+`);
+      }
+      process.exit(1);
+      return;
+    }
+  }
+  if (opts.sortKeys) {
+    parsed = sortObject(parsed);
+  }
+  const output = JSON.stringify(parsed, null, opts.indent);
+  if (opts.inPlace && opts.file) {
+    writeFileSync(opts.file, output + `
+`, "utf-8");
+  } else if (!opts.quiet) {
+    process.stdout.write(output + `
+`);
+  }
+}
+// src/index.ts
+var parser = new JsonParser;
+var formatter = { formatJson };
+export {
+  parser,
+  parse,
+  main,
+  formatter,
+  formatJson,
+  TokenType,
+  SchemaValidator,
+  ParseError,
+  LexerError,
+  Lexer,
+  JsonParser
+};

package/build/lexer.d.ts

@@ -0,0 +1,49 @@
+export declare enum TokenType {
+    STRING = "STRING",
+    NUMBER = "NUMBER",
+    TRUE = "TRUE",
+    FALSE = "FALSE",
+    NULL = "NULL",
+    LBRACE = "{",
+    RBRACE = "}",
+    LBRACKET = "[",
+    RBRACKET = "]",
+    COMMA = ",",
+    COLON = ":",
+    EOF = "EOF",
+    INVALID = "INVALID"
+}
+export interface SourceLocation {
+    first_line: number;
+    last_line: number;
+    first_column: number;
+    last_column: number;
+}
+export interface Token {
+    type: TokenType;
+    value: string;
+    loc: SourceLocation;
+}
+export declare class LexerError extends Error {
+    line: number;
+    column: number;
+    position: number;
+    input: string;
+    constructor(message: string, line: number, column: number, position: number, input: string);
+    showPosition(): string;
+}
+export declare class Lexer {
+    private input;
+    private pos;
+    private line;
+    private column;
+    setInput(input: string): void;
+    private peek;
+    private advance;
+    private skipWhitespace;
+    private readString;
+    private readNumber;
+    private readKeyword;
+    private showPositionAt;
+    nextToken(): Token;
+}

package/build/parser.d.ts

@@ -0,0 +1,34 @@
+import { Lexer, LexerError } from "./lexer.js";
+import type { SourceLocation } from "./lexer.js";
+export { LexerError };
+export interface ParseErrorHash {
+    text: string;
+    token: string;
+    line: number;
+    loc: SourceLocation;
+    expected: string[];
+}
+export declare class ParseError extends Error {
+    hash: ParseErrorHash;
+    constructor(message: string, hash: ParseErrorHash);
+}
+export declare class JsonParser {
+    lexer: Lexer;
+    private currentToken;
+    private previousToken;
+    private input;
+    yy: Record<string, unknown>;
+    parseError: ((str: string, hash: ParseErrorHash) => never) | null;
+    constructor();
+    parse(input: string): unknown;
+    private advance;
+    private expect;
+    private throwParseError;
+    private formatError;
+    private showPosition;
+    private parseValue;
+    private parseObject;
+    private parseMember;
+    private parseArray;
+}
+export declare function parse(input: string): unknown;

package/build/schema.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Minimal JSON Schema Draft-03 validator.
+ * Zero dependencies — implements the subset needed for feature parity with jsonlint.
+ */
+export interface SchemaError {
+    property: string;
+    message: string;
+}
+export interface JsonSchema {
+    type?: string | string[];
+    properties?: Record<string, JsonSchema>;
+    items?: JsonSchema | JsonSchema[];
+    required?: boolean;
+    additionalProperties?: boolean | JsonSchema;
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: boolean;
+    exclusiveMaximum?: boolean;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    enum?: unknown[];
+    default?: unknown;
+    description?: string;
+    title?: string;
+    $ref?: string;
+    id?: string;
+    extends?: JsonSchema | JsonSchema[];
+    disallow?: string | string[];
+    divisibleBy?: number;
+    format?: string;
+    patternProperties?: Record<string, JsonSchema>;
+    dependencies?: Record<string, string | string[] | JsonSchema>;
+    [key: string]: unknown;
+}
+export declare class SchemaValidator {
+    private schemas;
+    private errors;
+    validate(instance: unknown, schema: JsonSchema, path?: string): SchemaError[];
+    private collectSchemas;
+    private resolveRef;
+    private addError;
+    private doValidate;
+}

package/build/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION = "0.0.3";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asymmetric-effort/jsonlint",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "A pure JavaScript/TypeScript JSON parser and validator with detailed error reporting — zero dependencies",
   "type": "module",
   "main": "build/index.js",
@@ -20,6 +20,9 @@
     "LICENSE.txt",
     "README.md"
   ],
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "clean": "make clean",
     "lint": "make lint",