lacspace-json 0.1.0

package/dist/lib.cjs

@@ -0,0 +1,1980 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib.ts
+var lib_exports = {};
+__export(lib_exports, {
+  JsonToolError: () => JsonToolError,
+  compareValues: () => compareValues,
+  compileQuery: () => compileQuery,
+  convert: () => convert,
+  deepClone: () => deepClone,
+  deepEqual: () => deepEqual,
+  detectFormat: () => detectFormat,
+  diff: () => diff,
+  formatFromExt: () => formatFromExt,
+  formatJson: () => formatJson,
+  getPath: () => getPath,
+  isEqual: () => isEqual,
+  isPlainObject: () => isPlainObject,
+  isValidQuery: () => isValidQuery,
+  merge: () => merge,
+  parseArrayStrategy: () => parseArrayStrategy,
+  parseCsv: () => parseCsv,
+  parseFormat: () => parseFormat,
+  parseNdjson: () => parseNdjson,
+  parsePath: () => parsePath,
+  parseToml: () => parseToml,
+  parseYaml: () => parseYaml,
+  query: () => query,
+  queryAll: () => queryAll,
+  sanitizeJson: () => sanitizeJson,
+  sortKeysDeep: () => sortKeysDeep,
+  stringifyCsv: () => stringifyCsv,
+  stringifyFormat: () => stringifyFormat,
+  stringifyNdjson: () => stringifyNdjson,
+  stringifyToml: () => stringifyToml,
+  stringifyYaml: () => stringifyYaml,
+  typeOf: () => typeOf,
+  validateSchema: () => validateSchema
+});
+module.exports = __toCommonJS(lib_exports);
+
+// src/util.ts
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isForbiddenKey(key) {
+  return FORBIDDEN_KEYS.has(key);
+}
+function safeSet(obj, key, value) {
+  if (isForbiddenKey(key)) return;
+  Object.defineProperty(obj, key, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function typeOf(v) {
+  if (v === null || v === void 0) return "null";
+  if (Array.isArray(v)) return "array";
+  const t = typeof v;
+  if (t === "boolean") return "boolean";
+  if (t === "number") return "number";
+  if (t === "string") return "string";
+  return "object";
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return a === b;
+  const ta = typeof a;
+  const tb = typeof b;
+  if (ta !== tb) return false;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b)) return false;
+    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 (ta === "object") {
+    const oa = a;
+    const ob = b;
+    const ka = Object.keys(oa);
+    const kb = Object.keys(ob);
+    if (ka.length !== kb.length) return false;
+    for (const k of ka) {
+      if (!Object.prototype.hasOwnProperty.call(ob, k)) return false;
+      if (!deepEqual(oa[k], ob[k])) return false;
+    }
+    return true;
+  }
+  return false;
+}
+function deepClone(v) {
+  if (v === null || typeof v !== "object") return v;
+  if (Array.isArray(v)) return v.map((x) => deepClone(x));
+  const out = {};
+  for (const k of Object.keys(v)) {
+    safeSet(out, k, deepClone(v[k]));
+  }
+  return out;
+}
+function compareValues(a, b) {
+  const rank = (v) => {
+    if (v === null || v === void 0) return 0;
+    if (v === false) return 1;
+    if (v === true) return 2;
+    if (typeof v === "number") return 3;
+    if (typeof v === "string") return 4;
+    if (Array.isArray(v)) return 5;
+    return 6;
+  };
+  const ra = rank(a);
+  const rb = rank(b);
+  if (ra !== rb) return ra - rb;
+  if (ra === 3) return a - b;
+  if (ra === 4) return a < b ? -1 : a > b ? 1 : 0;
+  if (ra === 5) {
+    const aa = a;
+    const bb = b;
+    const n = Math.min(aa.length, bb.length);
+    for (let i = 0; i < n; i++) {
+      const c = compareValues(aa[i], bb[i]);
+      if (c !== 0) return c;
+    }
+    return aa.length - bb.length;
+  }
+  if (ra === 6) {
+    const ka = Object.keys(a).sort();
+    const kb = Object.keys(b).sort();
+    const n = Math.min(ka.length, kb.length);
+    for (let i = 0; i < n; i++) {
+      if (ka[i] !== kb[i]) return ka[i] < kb[i] ? -1 : 1;
+    }
+    if (ka.length !== kb.length) return ka.length - kb.length;
+    for (const k of ka) {
+      const c = compareValues(a[k], b[k]);
+      if (c !== 0) return c;
+    }
+    return 0;
+  }
+  return 0;
+}
+function sortKeysDeep(v) {
+  if (Array.isArray(v)) return v.map(sortKeysDeep);
+  if (isPlainObject(v)) {
+    const out = {};
+    for (const k of Object.keys(v).sort()) safeSet(out, k, sortKeysDeep(v[k]));
+    return out;
+  }
+  return v;
+}
+var JsonToolError = class extends Error {
+  path;
+  constructor(message, path) {
+    super(message);
+    this.name = "JsonToolError";
+    if (path !== void 0) this.path = path;
+  }
+};
+
+// src/query.ts
+function tokenize(src) {
+  const toks = [];
+  let i = 0;
+  const n = src.length;
+  while (i < n) {
+    const ch = src[i];
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+      i++;
+      continue;
+    }
+    if (ch === ".") {
+      toks.push({ t: "dot" });
+      i++;
+      continue;
+    }
+    if (ch === "[") {
+      toks.push({ t: "lbracket" });
+      i++;
+      continue;
+    }
+    if (ch === "]") {
+      toks.push({ t: "rbracket" });
+      i++;
+      continue;
+    }
+    if (ch === "(") {
+      toks.push({ t: "lparen" });
+      i++;
+      continue;
+    }
+    if (ch === ")") {
+      toks.push({ t: "rparen" });
+      i++;
+      continue;
+    }
+    if (ch === "|") {
+      toks.push({ t: "pipe" });
+      i++;
+      continue;
+    }
+    if (ch === ",") {
+      toks.push({ t: "comma" });
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      const quote = ch;
+      let j = i + 1;
+      let s = "";
+      while (j < n && src[j] !== quote) {
+        if (src[j] === "\\" && j + 1 < n) {
+          const esc = src[j + 1];
+          s += esc === "n" ? "\n" : esc === "t" ? "	" : esc;
+          j += 2;
+        } else {
+          s += src[j];
+          j++;
+        }
+      }
+      if (j >= n) throw new JsonToolError(`Unterminated string in query near "${src.slice(i, i + 12)}"`);
+      toks.push({ t: "str", v: s });
+      i = j + 1;
+      continue;
+    }
+    if (ch === ">" || ch === "<" || ch === "=" || ch === "!") {
+      if (src[i + 1] === "=") {
+        toks.push({ t: "op", v: ch + "=" });
+        i += 2;
+      } else if (ch === "=" || ch === "!") throw new JsonToolError(`Use "==" / "!=" for comparison near "${src.slice(i)}"`);
+      else {
+        toks.push({ t: "op", v: ch });
+        i++;
+      }
+      continue;
+    }
+    if (/[0-9]/.test(ch) || ch === "-" && /[0-9]/.test(src[i + 1] ?? "")) {
+      let j = i + 1;
+      while (j < n && /[0-9.eE+-]/.test(src[j])) j++;
+      const raw = src.slice(i, j);
+      const num = Number(raw);
+      if (Number.isNaN(num)) throw new JsonToolError(`Invalid number "${raw}" in query`);
+      toks.push({ t: "num", v: num });
+      i = j;
+      continue;
+    }
+    if (/[A-Za-z_]/.test(ch)) {
+      let j = i + 1;
+      while (j < n && /[A-Za-z0-9_]/.test(src[j])) j++;
+      toks.push({ t: "ident", v: src.slice(i, j) });
+      i = j;
+      continue;
+    }
+    throw new JsonToolError(`Unexpected character "${ch}" in query near "${src.slice(i, i + 12)}"`);
+  }
+  return toks;
+}
+var FUNCS_NO_ARG = /* @__PURE__ */ new Set([
+  "keys",
+  "values",
+  "length",
+  "type",
+  "unique",
+  "reverse",
+  "first",
+  "last",
+  "min",
+  "max",
+  "sum",
+  "avg",
+  "add",
+  "flatten"
+]);
+var FUNCS_WITH_ARG = /* @__PURE__ */ new Set(["map", "sort_by", "group_by", "has", "select"]);
+var Parser = class {
+  toks;
+  pos = 0;
+  constructor(toks) {
+    this.toks = toks;
+  }
+  peek() {
+    return this.toks[this.pos];
+  }
+  next() {
+    return this.toks[this.pos++];
+  }
+  expect(t) {
+    const tk = this.next();
+    if (!tk || tk.t !== t) throw new JsonToolError(`Query parse error: expected ${t}`);
+    return tk;
+  }
+  parsePipeline(stopAtParen = false) {
+    const stages = [];
+    stages.push(this.parseStage());
+    while (this.peek()?.t === "pipe") {
+      this.next();
+      stages.push(this.parseStage());
+    }
+    if (stopAtParen && this.peek() && this.peek().t !== "rparen") {
+      throw new JsonToolError("Query parse error: expected ')'");
+    }
+    return { stages };
+  }
+  parseStage() {
+    const tk = this.peek();
+    if (!tk) throw new JsonToolError("Query parse error: unexpected end of expression");
+    if (tk.t === "dot" || tk.t === "lbracket") return this.parsePath();
+    if (tk.t === "ident") return this.parseFunc();
+    throw new JsonToolError(`Query parse error: unexpected token near "${describeTok(tk)}"`);
+  }
+  parsePath() {
+    const steps = [];
+    while (true) {
+      const tk = this.peek();
+      if (tk?.t === "dot") {
+        this.next();
+        const after = this.peek();
+        if (after?.t === "ident") {
+          this.next();
+          steps.push({ kind: "key", name: after.v });
+          continue;
+        }
+        if (after?.t === "str") {
+          this.next();
+          steps.push({ kind: "key", name: after.v });
+          continue;
+        }
+        if (after?.t === "lbracket") {
+          this.parseBracket(steps);
+          continue;
+        }
+        continue;
+      }
+      if (tk?.t === "lbracket") {
+        this.parseBracket(steps);
+        continue;
+      }
+      break;
+    }
+    return { kind: "path", steps };
+  }
+  parseBracket(steps) {
+    this.expect("lbracket");
+    const inner = this.peek();
+    if (inner?.t === "rbracket") {
+      this.next();
+      steps.push({ kind: "iterate" });
+      return;
+    }
+    if (inner?.t === "num") {
+      this.next();
+      this.expect("rbracket");
+      steps.push({ kind: "index", index: inner.v });
+      return;
+    }
+    if (inner?.t === "str") {
+      this.next();
+      this.expect("rbracket");
+      steps.push({ kind: "key", name: inner.v });
+      return;
+    }
+    if (inner?.t === "op" && inner.v === "<") {
+    }
+    throw new JsonToolError("Query parse error: expected number, string or empty in [ ]");
+  }
+  parseFunc() {
+    const nameTok = this.expect("ident");
+    const name = nameTok.v;
+    if (name === "select") {
+      this.expect("lparen");
+      const cond = this.parseCond();
+      this.expect("rparen");
+      return { kind: "select", cond };
+    }
+    if (FUNCS_WITH_ARG.has(name)) {
+      this.expect("lparen");
+      if (name === "has") {
+        const arg = this.next();
+        let key;
+        if (arg?.t === "str") key = arg.v;
+        else if (arg?.t === "num") key = arg.v;
+        else if (arg?.t === "ident") key = arg.v;
+        else throw new JsonToolError('has() needs a key, e.g. has("id")');
+        this.expect("rparen");
+        return { kind: "func", name, litKey: key };
+      }
+      const inner = this.parsePipeline(true);
+      this.expect("rparen");
+      return { kind: "func", name, arg: inner };
+    }
+    if (FUNCS_NO_ARG.has(name)) return { kind: "func", name };
+    throw new JsonToolError(`Unknown query function "${name}"`);
+  }
+  // --- conditions (inside select) ---
+  parseCond() {
+    return this.parseOr();
+  }
+  parseOr() {
+    let left = this.parseAnd();
+    while (this.peek()?.t === "ident" && this.peek().v === "or") {
+      this.next();
+      const right = this.parseAnd();
+      left = { kind: "or", l: left, r: right };
+    }
+    return left;
+  }
+  parseAnd() {
+    let left = this.parseCondAtom();
+    while (this.peek()?.t === "ident" && this.peek().v === "and") {
+      this.next();
+      const right = this.parseCondAtom();
+      left = { kind: "and", l: left, r: right };
+    }
+    return left;
+  }
+  parseCondAtom() {
+    const tk = this.peek();
+    if (tk?.t === "ident" && tk.v === "not") {
+      this.next();
+      return { kind: "not", c: this.parseCondAtom() };
+    }
+    if (tk?.t === "lparen") {
+      this.next();
+      const c = this.parseCond();
+      this.expect("rparen");
+      return c;
+    }
+    const left = this.parseCondPipeline();
+    const opTok = this.peek();
+    if (opTok?.t === "op") {
+      this.next();
+      const right = this.parseLiteral();
+      return { kind: "cmp", left, op: opTok.v, right };
+    }
+    return { kind: "truthy", expr: left };
+  }
+  parseCondPipeline() {
+    const stages = [this.parseStage()];
+    while (this.peek()?.t === "pipe") {
+      this.next();
+      stages.push(this.parseStage());
+    }
+    return { stages };
+  }
+  parseLiteral() {
+    const tk = this.next();
+    if (!tk) throw new JsonToolError("Query parse error: expected a value after operator");
+    if (tk.t === "num") return { lit: true, value: tk.v };
+    if (tk.t === "str") return { lit: true, value: tk.v };
+    if (tk.t === "ident") {
+      if (tk.v === "true") return { lit: true, value: true };
+      if (tk.v === "false") return { lit: true, value: false };
+      if (tk.v === "null") return { lit: true, value: null };
+      return { lit: true, value: tk.v };
+    }
+    throw new JsonToolError("Query parse error: expected a literal (number, string, true/false/null)");
+  }
+};
+function describeTok(t) {
+  if (t.t === "ident" || t.t === "str") return t.v;
+  if (t.t === "num") return String(t.v);
+  if (t.t === "op") return t.v;
+  return t.t;
+}
+function getKey(v, key) {
+  if (v === null || v === void 0) return void 0;
+  if (Array.isArray(v)) return void 0;
+  if (typeof v !== "object") return void 0;
+  if (!Object.prototype.hasOwnProperty.call(v, key)) return void 0;
+  return v[key];
+}
+function evalPath(steps, inputs) {
+  let cur = inputs;
+  for (const step of steps) {
+    if (step.kind === "key") {
+      cur = cur.map((v) => getKey(v, step.name));
+    } else if (step.kind === "index") {
+      cur = cur.map((v) => {
+        if (!Array.isArray(v)) return void 0;
+        const idx = step.index < 0 ? v.length + step.index : step.index;
+        return v[idx];
+      });
+    } else {
+      const out = [];
+      for (const v of cur) {
+        if (Array.isArray(v)) out.push(...v);
+        else if (v && typeof v === "object") out.push(...Object.values(v));
+      }
+      cur = out;
+    }
+  }
+  return cur;
+}
+function asNumbers(arr, fn) {
+  const out = [];
+  for (const v of arr) {
+    if (typeof v !== "number") throw new JsonToolError(`${fn}: expected an array of numbers, found ${typeOf(v)}`);
+    out.push(v);
+  }
+  return out;
+}
+function evalFunc(stage, inputs) {
+  const name = stage.name;
+  const litKey = stage.litKey;
+  const perValue = (fn) => inputs.map(fn);
+  switch (name) {
+    case "keys":
+      return perValue((v) => {
+        if (Array.isArray(v)) return v.map((_, i) => i);
+        if (v && typeof v === "object") return Object.keys(v).sort();
+        throw new JsonToolError(`keys: expected object or array, found ${typeOf(v)}`);
+      });
+    case "values":
+      return perValue((v) => {
+        if (Array.isArray(v)) return v;
+        if (v && typeof v === "object") return Object.values(v);
+        throw new JsonToolError(`values: expected object or array, found ${typeOf(v)}`);
+      });
+    case "length":
+      return perValue((v) => {
+        if (v === null || v === void 0) return 0;
+        if (typeof v === "string") return v.length;
+        if (Array.isArray(v)) return v.length;
+        if (typeof v === "number") return Math.abs(v);
+        if (typeof v === "object") return Object.keys(v).length;
+        throw new JsonToolError(`length: unsupported type ${typeOf(v)}`);
+      });
+    case "type":
+      return perValue((v) => typeOf(v));
+    case "has":
+      return perValue((v) => {
+        if (Array.isArray(v)) return typeof litKey === "number" && litKey >= 0 && litKey < v.length;
+        if (v && typeof v === "object") return Object.prototype.hasOwnProperty.call(v, String(litKey));
+        throw new JsonToolError(`has: expected object or array, found ${typeOf(v)}`);
+      });
+    case "unique":
+      return perValue((v) => {
+        if (!Array.isArray(v)) throw new JsonToolError(`unique: expected array, found ${typeOf(v)}`);
+        const sorted = [...v].sort(compareValues);
+        const out = [];
+        for (const x of sorted) if (out.length === 0 || !deepEqual(out[out.length - 1], x)) out.push(x);
+        return out;
+      });
+    case "reverse":
+      return perValue((v) => {
+        if (Array.isArray(v)) return [...v].reverse();
+        if (typeof v === "string") return [...v].reverse().join("");
+        throw new JsonToolError(`reverse: expected array or string, found ${typeOf(v)}`);
+      });
+    case "flatten":
+      return perValue((v) => {
+        if (!Array.isArray(v)) throw new JsonToolError(`flatten: expected array, found ${typeOf(v)}`);
+        const out = [];
+        const walk2 = (a) => {
+          for (const x of a) Array.isArray(x) ? walk2(x) : out.push(x);
+        };
+        walk2(v);
+        return out;
+      });
+    case "first":
+      return perValue((v) => {
+        if (!Array.isArray(v)) throw new JsonToolError(`first: expected array`);
+        return v.length ? v[0] : null;
+      });
+    case "last":
+      return perValue((v) => {
+        if (!Array.isArray(v)) throw new JsonToolError(`last: expected array`);
+        return v.length ? v[v.length - 1] : null;
+      });
+    case "min":
+      return perValue((v) => {
+        if (!Array.isArray(v)) throw new JsonToolError(`min: expected array`);
+        if (!v.length) return null;
+        return [...v].sort(compareValues)[0];
+      });
+    case "max":
+      return perValue((v) => {
+        if (!Array.isArray(v)) throw new JsonToolError(`max: expected array`);
+        if (!v.length) return null;
+        return [...v].sort(compareValues)[v.length - 1];
+      });
+    case "sum":
+      return perValue((v) => {
+        if (!Array.isArray(v)) throw new JsonToolError(`sum: expected array`);
+        return asNumbers(v, "sum").reduce((a, b) => a + b, 0);
+      });
+    case "avg":
+      return perValue((v) => {
+        if (!Array.isArray(v)) throw new JsonToolError(`avg: expected array`);
+        const nums = asNumbers(v, "avg");
+        return nums.length ? nums.reduce((a, b) => a + b, 0) / nums.length : null;
+      });
+    case "add":
+      return perValue((v) => {
+        if (!Array.isArray(v)) throw new JsonToolError(`add: expected array`);
+        if (!v.length) return null;
+        if (v.every((x) => typeof x === "number")) return v.reduce((a, b) => a + b, 0);
+        if (v.every((x) => typeof x === "string")) return v.join("");
+        if (v.every((x) => Array.isArray(x))) return [].concat(...v);
+        throw new JsonToolError("add: array must be all numbers, all strings, or all arrays");
+      });
+    case "map": {
+      const inner = stage.arg;
+      return perValue((v) => {
+        if (!Array.isArray(v)) throw new JsonToolError(`map: expected array, found ${typeOf(v)}`);
+        return v.map((el) => firstOf(evalPipeline(inner, [el])));
+      });
+    }
+    case "sort_by": {
+      const inner = stage.arg;
+      return perValue((v) => {
+        if (!Array.isArray(v)) throw new JsonToolError(`sort_by: expected array, found ${typeOf(v)}`);
+        return [...v].sort((a, b) => compareValues(firstOf(evalPipeline(inner, [a])), firstOf(evalPipeline(inner, [b]))));
+      });
+    }
+    case "group_by": {
+      const inner = stage.arg;
+      return perValue((v) => {
+        if (!Array.isArray(v)) throw new JsonToolError(`group_by: expected array, found ${typeOf(v)}`);
+        const withKey = v.map((el) => ({ el, key: firstOf(evalPipeline(inner, [el])) }));
+        withKey.sort((a, b) => compareValues(a.key, b.key));
+        const groups = [];
+        let curKey = /* @__PURE__ */ Symbol();
+        for (const { el, key } of withKey) {
+          if (groups.length === 0 || !deepEqual(curKey, key)) {
+            groups.push([]);
+            curKey = key;
+          }
+          groups[groups.length - 1].push(el);
+        }
+        return groups;
+      });
+    }
+    default:
+      throw new JsonToolError(`Unknown query function "${name}"`);
+  }
+}
+function truthy(v) {
+  return v !== null && v !== void 0 && v !== false;
+}
+function evalCond(cond, value) {
+  switch (cond.kind) {
+    case "or":
+      return evalCond(cond.l, value) || evalCond(cond.r, value);
+    case "and":
+      return evalCond(cond.l, value) && evalCond(cond.r, value);
+    case "not":
+      return !evalCond(cond.c, value);
+    case "truthy":
+      return truthy(firstOf(evalPipeline(cond.expr, [value])));
+    case "cmp": {
+      const left = firstOf(evalPipeline(cond.left, [value]));
+      const right = cond.right.value;
+      switch (cond.op) {
+        case "==":
+          return deepEqual(left, right);
+        case "!=":
+          return !deepEqual(left, right);
+        case ">":
+          return compareValues(left, right) > 0;
+        case "<":
+          return compareValues(left, right) < 0;
+        case ">=":
+          return compareValues(left, right) >= 0;
+        case "<=":
+          return compareValues(left, right) <= 0;
+        default:
+          throw new JsonToolError(`Unknown operator "${cond.op}"`);
+      }
+    }
+  }
+}
+function evalPipeline(pipe, inputs) {
+  let cur = inputs;
+  for (const stage of pipe.stages) {
+    if (stage.kind === "path") cur = evalPath(stage.steps, cur);
+    else if (stage.kind === "select") cur = cur.filter((v) => evalCond(stage.cond, v));
+    else cur = evalFunc(stage, cur);
+  }
+  return cur;
+}
+function firstOf(arr) {
+  return arr.length ? arr[0] : null;
+}
+function compileQuery(expr) {
+  const toks = tokenize(expr);
+  if (toks.length === 0) return (d) => [d];
+  const ast = new Parser(toks).parsePipeline();
+  return (data) => evalPipeline(ast, [data]);
+}
+function query(data, expr) {
+  const results = compileQuery(expr)(data);
+  const clean = results.map((v) => v === void 0 ? null : v);
+  return clean.length === 1 ? clean[0] : clean;
+}
+function queryAll(data, expr) {
+  return compileQuery(expr)(data).map((v) => v === void 0 ? null : v);
+}
+function isValidQuery(expr) {
+  try {
+    compileQuery(expr);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/yaml.ts
+function splitLines(src) {
+  const out = [];
+  const rawLines = src.split(/\r?\n/);
+  for (let i = 0; i < rawLines.length; i++) {
+    const raw = rawLines[i];
+    if (/^\s*$/.test(raw)) continue;
+    if (/^\s*#/.test(raw)) continue;
+    const trimmedRight = raw.replace(/\s+$/, "");
+    if (trimmedRight === "---" || trimmedRight === "...") continue;
+    const indent = raw.length - raw.replace(/^\s+/, "").length;
+    out.push({ indent, content: raw.trim(), raw, n: i + 1 });
+  }
+  return out;
+}
+function stripComment(s) {
+  let inS = false, inD = false;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (ch === "'" && !inD) inS = !inS;
+    else if (ch === '"' && !inS) inD = !inD;
+    else if (ch === "#" && !inS && !inD && (i === 0 || s[i - 1] === " " || s[i - 1] === "	")) {
+      return s.slice(0, i).replace(/\s+$/, "");
+    }
+  }
+  return s;
+}
+function parseScalar(raw) {
+  const s = raw.trim();
+  if (s === "" || s === "~" || s === "null" || s === "Null" || s === "NULL") return null;
+  if (s === "true" || s === "True" || s === "TRUE") return true;
+  if (s === "false" || s === "False" || s === "FALSE") return false;
+  if (s.length >= 2 && s[0] === '"' && s[s.length - 1] === '"') {
+    return s.slice(1, -1).replace(/\\(["\\/ntr])/g, (_m, c) => c === "n" ? "\n" : c === "t" ? "	" : c === "r" ? "\r" : c);
+  }
+  if (s.length >= 2 && s[0] === "'" && s[s.length - 1] === "'") {
+    return s.slice(1, -1).replace(/''/g, "'");
+  }
+  if (s[0] === "[" || s[0] === "{") return parseFlow(s);
+  if (/^[-+]?(0|[1-9][0-9]*)$/.test(s)) return parseInt(s, 10);
+  if (/^[-+]?(\d+\.?\d*|\.\d+)([eE][-+]?\d+)?$/.test(s) && /\d/.test(s)) {
+    const num = Number(s);
+    if (!Number.isNaN(num)) return num;
+  }
+  return s;
+}
+function parseFlow(s) {
+  let i = 0;
+  const parseValue2 = () => {
+    skipWs();
+    const ch = s[i];
+    if (ch === "[") return parseArr();
+    if (ch === "{") return parseObj();
+    return parseFlowScalar();
+  };
+  const skipWs = () => {
+    while (i < s.length && /\s/.test(s[i])) i++;
+  };
+  const parseArr = () => {
+    i++;
+    const arr = [];
+    skipWs();
+    if (s[i] === "]") {
+      i++;
+      return arr;
+    }
+    while (i < s.length) {
+      arr.push(parseValue2());
+      skipWs();
+      if (s[i] === ",") {
+        i++;
+        continue;
+      }
+      if (s[i] === "]") {
+        i++;
+        break;
+      }
+      throw new JsonToolError(`YAML: malformed flow sequence near "${s.slice(i)}"`);
+    }
+    return arr;
+  };
+  const parseObj = () => {
+    i++;
+    const obj = {};
+    skipWs();
+    if (s[i] === "}") {
+      i++;
+      return obj;
+    }
+    while (i < s.length) {
+      skipWs();
+      const key = parseFlowKey();
+      skipWs();
+      if (s[i] !== ":") throw new JsonToolError(`YAML: expected ':' in flow map near "${s.slice(i)}"`);
+      i++;
+      const val = parseValue2();
+      if (!isForbiddenKey(key)) safeSet(obj, key, val);
+      skipWs();
+      if (s[i] === ",") {
+        i++;
+        continue;
+      }
+      if (s[i] === "}") {
+        i++;
+        break;
+      }
+      throw new JsonToolError(`YAML: malformed flow map near "${s.slice(i)}"`);
+    }
+    return obj;
+  };
+  const parseFlowKey = () => {
+    skipWs();
+    if (s[i] === '"' || s[i] === "'") {
+      const v = parseFlowScalar();
+      return String(v);
+    }
+    let j = i;
+    while (j < s.length && s[j] !== ":" && s[j] !== "," && s[j] !== "}") j++;
+    const k = s.slice(i, j).trim();
+    i = j;
+    return k;
+  };
+  const parseFlowScalar = () => {
+    skipWs();
+    if (s[i] === '"' || s[i] === "'") {
+      const q = s[i];
+      let j2 = i + 1;
+      let str = "";
+      while (j2 < s.length && s[j2] !== q) {
+        if (q === '"' && s[j2] === "\\") {
+          str += s[j2 + 1] === "n" ? "\n" : s[j2 + 1];
+          j2 += 2;
+        } else {
+          str += s[j2];
+          j2++;
+        }
+      }
+      i = j2 + 1;
+      return str;
+    }
+    let j = i;
+    while (j < s.length && !",]}".includes(s[j])) j++;
+    const tok = s.slice(i, j).trim();
+    i = j;
+    return parseScalar(tok);
+  };
+  const result = parseValue2();
+  return result;
+}
+function parseBlock(lines, start, minIndent) {
+  const first = lines[start];
+  const indent = first.indent;
+  if (/^-(\s|$)/.test(first.content)) {
+    const arr = [];
+    let i2 = start;
+    while (i2 < lines.length && lines[i2].indent === indent && /^-(\s|$)/.test(lines[i2].content)) {
+      const line = lines[i2];
+      const after = line.content.slice(1).trim();
+      if (after === "") {
+        const inner = parseBlock(lines, i2 + 1, indent + 1);
+        arr.push(inner.value);
+        i2 = inner.next;
+      } else if (/^[^:\s][^:]*:(\s|$)/.test(after) || isInlineMapStart(after)) {
+        const synthetic = [{ indent: indent + 2, content: after, raw: line.raw, n: line.n }];
+        let j = i2 + 1;
+        while (j < lines.length && lines[j].indent > indent) {
+          synthetic.push(lines[j]);
+          j++;
+        }
+        const inner = parseBlock(synthetic, 0, indent + 2);
+        arr.push(inner.value);
+        i2 = j;
+      } else {
+        arr.push(parseScalar(stripComment(after)));
+        i2++;
+      }
+    }
+    return { value: arr, next: i2 };
+  }
+  const obj = {};
+  let i = start;
+  while (i < lines.length && lines[i].indent === indent) {
+    const line = lines[i];
+    if (/^-(\s|$)/.test(line.content)) break;
+    const { key, rest } = splitKey(line.content, line.n);
+    const restClean = stripComment(rest);
+    if (restClean === "") {
+      const child = lines[i + 1];
+      if (child && child.indent > indent) {
+        const inner = parseBlock(lines, i + 1, indent + 1);
+        if (!isForbiddenKey(key)) safeSet(obj, key, inner.value);
+        i = inner.next;
+      } else {
+        if (!isForbiddenKey(key)) safeSet(obj, key, null);
+        i++;
+      }
+    } else if (restClean === "|" || restClean === ">" || /^[|>][-+]?$/.test(restClean)) {
+      const { text, next } = readBlockScalar(lines, i + 1, indent, restClean);
+      if (!isForbiddenKey(key)) safeSet(obj, key, text);
+      i = next;
+    } else {
+      if (!isForbiddenKey(key)) safeSet(obj, key, parseScalar(restClean));
+      i++;
+    }
+  }
+  void minIndent;
+  return { value: obj, next: i };
+}
+function isInlineMapStart(s) {
+  return /^[^:]+:\s/.test(s);
+}
+function splitKey(content, n) {
+  let inS = false, inD = false;
+  for (let i = 0; i < content.length; i++) {
+    const ch = content[i];
+    if (ch === "'" && !inD) inS = !inS;
+    else if (ch === '"' && !inS) inD = !inD;
+    else if (ch === ":" && !inS && !inD && (i + 1 >= content.length || content[i + 1] === " ")) {
+      let key = content.slice(0, i).trim();
+      if (key.length >= 2 && (key[0] === '"' && key.endsWith('"') || key[0] === "'" && key.endsWith("'"))) {
+        key = key.slice(1, -1);
+      }
+      return { key, rest: content.slice(i + 1).trim() };
+    }
+  }
+  throw new JsonToolError(`YAML: expected "key: value" mapping at line ${n}: "${content}"`);
+}
+function readBlockScalar(lines, start, parentIndent, marker) {
+  const folded = marker[0] === ">";
+  const chomp = marker.includes("-") ? "strip" : marker.includes("+") ? "keep" : "clip";
+  const body = [];
+  let i = start;
+  let blockIndent = -1;
+  while (i < lines.length && lines[i].indent > parentIndent) {
+    if (blockIndent < 0) blockIndent = lines[i].indent;
+    body.push(lines[i].raw.slice(blockIndent));
+    i++;
+  }
+  let text = folded ? body.join(" ") : body.join("\n");
+  if (chomp === "strip") text = text.replace(/\n+$/, "");
+  else if (chomp === "clip") text = text.replace(/\n+$/, "") + (body.length ? "\n" : "");
+  return { text, next: i };
+}
+function parseYaml(src) {
+  const lines = splitLines(src);
+  if (lines.length === 0) return null;
+  if (lines.length === 1 && !/^-(\s|$)/.test(lines[0].content) && !/:\s|:$/.test(lines[0].content)) {
+    return parseScalar(stripComment(lines[0].content));
+  }
+  const { value } = parseBlock(lines, 0, 0);
+  return value;
+}
+function needsQuote(s) {
+  if (s === "") return true;
+  if (/^(true|false|null|~|yes|no|on|off)$/i.test(s)) return true;
+  if (/^[-+]?(\d+\.?\d*|\.\d+)([eE][-+]?\d+)?$/.test(s)) return true;
+  if (/^[\s]|[\s]$/.test(s)) return true;
+  if (/[:#\[\]{}&*!|>'"%@`,]/.test(s)) return true;
+  if (/^[?-]/.test(s)) return true;
+  return false;
+}
+function writeScalar(v) {
+  if (v === null) return "null";
+  if (typeof v === "boolean") return v ? "true" : "false";
+  if (typeof v === "number") return Number.isFinite(v) ? String(v) : "null";
+  const s = String(v);
+  if (needsQuote(s)) return JSON.stringify(s);
+  return s;
+}
+function writeYamlNode(v, indent) {
+  const pad = "  ".repeat(indent);
+  if (Array.isArray(v)) {
+    if (v.length === 0) return pad + "[]";
+    return v.map((item) => {
+      if (item !== null && typeof item === "object") {
+        const inner = writeYamlNode(item, indent + 1);
+        return pad + "-\n" + inner;
+      }
+      return pad + "- " + writeScalar(item);
+    }).join("\n");
+  }
+  if (v !== null && typeof v === "object") {
+    const keys = Object.keys(v);
+    if (keys.length === 0) return pad + "{}";
+    return keys.map((k) => {
+      const val = v[k];
+      const keyStr = needsQuote(k) ? JSON.stringify(k) : k;
+      if (val !== null && typeof val === "object" && (Array.isArray(val) ? val.length : Object.keys(val).length)) {
+        const nested = writeYamlNode(val, indent + 1);
+        return pad + keyStr + ":\n" + nested;
+      }
+      return pad + keyStr + ": " + writeScalar(val);
+    }).join("\n");
+  }
+  return pad + writeScalar(v);
+}
+function stringifyYaml(value) {
+  if (value === null || typeof value !== "object") return writeScalar(value) + "\n";
+  return writeYamlNode(value, 0) + "\n";
+}
+
+// src/toml.ts
+function parseValue(raw) {
+  const s = raw.trim();
+  if (s === "true") return true;
+  if (s === "false") return false;
+  if (s[0] === '"') return parseBasicString(s);
+  if (s[0] === "'") return parseLiteralString(s);
+  if (s[0] === "[") return parseArray(s);
+  if (s[0] === "{") return parseInline(s);
+  const numStr = s.replace(/_/g, "");
+  if (/^[-+]?(0|[1-9]\d*)$/.test(numStr)) return parseInt(numStr, 10);
+  if (/^[-+]?(\d+\.?\d*|\.\d+)([eE][-+]?\d+)?$/.test(numStr) && /\d/.test(numStr)) {
+    const n = Number(numStr);
+    if (!Number.isNaN(n)) return n;
+  }
+  if (/^0x[0-9a-fA-F]+$/.test(numStr)) return parseInt(numStr, 16);
+  return s;
+}
+function parseBasicString(s) {
+  if (s.length < 2 || s[s.length - 1] !== '"') throw new JsonToolError(`TOML: unterminated string ${s}`);
+  return s.slice(1, -1).replace(/\\(["\\/nrt]|u[0-9a-fA-F]{4})/g, (_m, c) => {
+    if (c[0] === "u") return String.fromCharCode(parseInt(c.slice(1), 16));
+    return c === "n" ? "\n" : c === "t" ? "	" : c === "r" ? "\r" : c;
+  });
+}
+function parseLiteralString(s) {
+  if (s.length < 2 || s[s.length - 1] !== "'") throw new JsonToolError(`TOML: unterminated literal string ${s}`);
+  return s.slice(1, -1);
+}
+function splitTop(s, open, close) {
+  const inner = s.slice(1, -1);
+  const items = [];
+  let depth = 0, inD = false, inSq = false, cur = "";
+  for (let i = 0; i < inner.length; i++) {
+    const ch = inner[i];
+    if (inD) {
+      cur += ch;
+      if (ch === '"' && inner[i - 1] !== "\\") inD = false;
+      continue;
+    }
+    if (inSq) {
+      cur += ch;
+      if (ch === "'") inSq = false;
+      continue;
+    }
+    if (ch === '"') {
+      inD = true;
+      cur += ch;
+      continue;
+    }
+    if (ch === "'") {
+      inSq = true;
+      cur += ch;
+      continue;
+    }
+    if (ch === "[" || ch === "{") depth++;
+    if (ch === "]" || ch === "}") depth--;
+    if (ch === "," && depth === 0) {
+      items.push(cur);
+      cur = "";
+      continue;
+    }
+    cur += ch;
+  }
+  if (cur.trim() !== "") items.push(cur);
+  void open;
+  void close;
+  return items;
+}
+function parseArray(s) {
+  const items = splitTop(s, "[", "]");
+  return items.map((it) => parseValue(it.trim()));
+}
+function parseInline(s) {
+  const items = splitTop(s, "{", "}");
+  const obj = {};
+  for (const it of items) {
+    const t = it.trim();
+    if (t === "") continue;
+    const eq = findEquals(t);
+    const key = t.slice(0, eq).trim();
+    const val = parseValue(t.slice(eq + 1).trim());
+    assignDotted(obj, splitKeyPath(key), val);
+  }
+  return obj;
+}
+function findEquals(line) {
+  let inD = false, inSq = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (inD) {
+      if (ch === '"' && line[i - 1] !== "\\") inD = false;
+      continue;
+    }
+    if (inSq) {
+      if (ch === "'") inSq = false;
+      continue;
+    }
+    if (ch === '"') {
+      inD = true;
+      continue;
+    }
+    if (ch === "'") {
+      inSq = true;
+      continue;
+    }
+    if (ch === "=") return i;
+  }
+  return -1;
+}
+function splitKeyPath(key) {
+  const parts = [];
+  let cur = "", inD = false, inSq = false;
+  for (let i = 0; i < key.length; i++) {
+    const ch = key[i];
+    if (inD) {
+      if (ch === '"') {
+        inD = false;
+      } else cur += ch;
+      continue;
+    }
+    if (inSq) {
+      if (ch === "'") {
+        inSq = false;
+      } else cur += ch;
+      continue;
+    }
+    if (ch === '"') {
+      inD = true;
+      continue;
+    }
+    if (ch === "'") {
+      inSq = true;
+      continue;
+    }
+    if (ch === ".") {
+      parts.push(cur.trim());
+      cur = "";
+      continue;
+    }
+    cur += ch;
+  }
+  parts.push(cur.trim());
+  return parts.filter((p) => p !== "");
+}
+function assignDotted(root, path, value) {
+  let cur = root;
+  for (let i = 0; i < path.length - 1; i++) {
+    const k = path[i];
+    if (isForbiddenKey(k)) return;
+    if (!isPlainObject(cur[k])) safeSet(cur, k, {});
+    cur = cur[k];
+  }
+  const last = path[path.length - 1];
+  if (!isForbiddenKey(last)) safeSet(cur, last, value);
+}
+function ensureTable(root, path) {
+  let cur = root;
+  for (const k of path) {
+    if (isForbiddenKey(k)) throw new JsonToolError(`TOML: forbidden key "${k}"`);
+    const existing = cur[k];
+    if (Array.isArray(existing)) {
+      const arr = existing;
+      cur = arr[arr.length - 1];
+    } else if (isPlainObject(existing)) {
+      cur = existing;
+    } else {
+      safeSet(cur, k, {});
+      cur = cur[k];
+    }
+  }
+  return cur;
+}
+function ensureArrayTable(root, path) {
+  const parent = ensureTable(root, path.slice(0, -1));
+  const last = path[path.length - 1];
+  if (isForbiddenKey(last)) throw new JsonToolError(`TOML: forbidden key "${last}"`);
+  if (!Array.isArray(parent[last])) safeSet(parent, last, []);
+  const arr = parent[last];
+  const tbl = {};
+  arr.push(tbl);
+  return tbl;
+}
+function parseToml(src) {
+  const root = {};
+  let cur = root;
+  const lines = src.split(/\r?\n/);
+  for (let li = 0; li < lines.length; li++) {
+    let line = lines[li];
+    line = stripComment2(line).trim();
+    if (line === "") continue;
+    if (line.startsWith("[[") && line.endsWith("]]")) {
+      const path = splitKeyPath(line.slice(2, -2).trim());
+      cur = ensureArrayTable(root, path);
+      continue;
+    }
+    if (line.startsWith("[") && line.endsWith("]")) {
+      const path = splitKeyPath(line.slice(1, -1).trim());
+      cur = ensureTable(root, path);
+      continue;
+    }
+    const eq = findEquals(line);
+    if (eq < 0) throw new JsonToolError(`TOML: expected "key = value" at line ${li + 1}: "${line}"`);
+    const key = line.slice(0, eq).trim();
+    const value = parseValue(line.slice(eq + 1).trim());
+    assignDotted(cur, splitKeyPath(key), value);
+  }
+  return root;
+}
+function stripComment2(line) {
+  let inD = false, inSq = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (inD) {
+      if (ch === '"' && line[i - 1] !== "\\") inD = false;
+      continue;
+    }
+    if (inSq) {
+      if (ch === "'") inSq = false;
+      continue;
+    }
+    if (ch === '"') {
+      inD = true;
+      continue;
+    }
+    if (ch === "'") {
+      inSq = true;
+      continue;
+    }
+    if (ch === "#") return line.slice(0, i);
+  }
+  return line;
+}
+function bareKey(k) {
+  return /^[A-Za-z0-9_-]+$/.test(k) ? k : JSON.stringify(k);
+}
+function writeInlineValue(v) {
+  if (v === null) return '""';
+  if (typeof v === "boolean") return v ? "true" : "false";
+  if (typeof v === "number") return Number.isFinite(v) ? String(v) : '"NaN"';
+  if (typeof v === "string") return JSON.stringify(v);
+  if (Array.isArray(v)) return "[" + v.map(writeInlineValue).join(", ") + "]";
+  const entries = Object.keys(v).map((k) => `${bareKey(k)} = ${writeInlineValue(v[k])}`);
+  return "{ " + entries.join(", ") + " }";
+}
+function isTableArray(v) {
+  return Array.isArray(v) && v.length > 0 && v.every((x) => isPlainObject(x));
+}
+function writeToml(obj, prefix, out) {
+  const scalars = [];
+  const tables = [];
+  const tableArrays = [];
+  for (const k of Object.keys(obj)) {
+    const v = obj[k];
+    if (isPlainObject(v)) tables.push([k, v]);
+    else if (isTableArray(v)) tableArrays.push([k, v]);
+    else scalars.push(`${bareKey(k)} = ${writeInlineValue(v)}`);
+  }
+  if (scalars.length) out.push(scalars.join("\n"));
+  for (const [k, v] of tables) {
+    const path = [...prefix, k];
+    out.push(`
+[${path.map(bareKey).join(".")}]`);
+    writeToml(v, path, out);
+  }
+  for (const [k, arr] of tableArrays) {
+    const path = [...prefix, k];
+    for (const item of arr) {
+      out.push(`
+[[${path.map(bareKey).join(".")}]]`);
+      writeToml(item, path, out);
+    }
+  }
+}
+function stringifyToml(value) {
+  if (!isPlainObject(value)) {
+    throw new JsonToolError("TOML output requires a top-level object/table");
+  }
+  const out = [];
+  writeToml(value, [], out);
+  return out.join("\n").replace(/^\n+/, "").replace(/\n{3,}/g, "\n\n") + "\n";
+}
+
+// src/csv.ts
+function coerce(raw) {
+  if (raw === "") return "";
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw === "null") return null;
+  if (/^[-+]?(0|[1-9]\d*)$/.test(raw)) {
+    const n = parseInt(raw, 10);
+    if (String(n) === raw.replace(/^\+/, "")) return n;
+  }
+  if (/^[-+]?(\d+\.\d+|\.\d+|\d+)([eE][-+]?\d+)?$/.test(raw)) {
+    const n = Number(raw);
+    if (!Number.isNaN(n)) return n;
+  }
+  return raw;
+}
+function parseCsv(src, opts = {}) {
+  const delim = opts.delimiter ?? ",";
+  const parseTypes = opts.parseTypes ?? true;
+  const rows = parseCsvRows(src, delim);
+  if (rows.length === 0) return [];
+  const header = rows[0];
+  const out = [];
+  for (let r = 1; r < rows.length; r++) {
+    const row = rows[r];
+    if (row.length === 1 && row[0] === "") continue;
+    const obj = {};
+    for (let c = 0; c < header.length; c++) {
+      const key = header[c] ?? `col${c}`;
+      if (isForbiddenKey(key)) continue;
+      const cell2 = row[c] ?? "";
+      safeSet(obj, key, parseTypes ? coerce(cell2) : cell2);
+    }
+    out.push(obj);
+  }
+  return out;
+}
+function parseCsvRows(src, delim) {
+  const rows = [];
+  let field = "";
+  let row = [];
+  let inQuotes = false;
+  let i = 0;
+  const n = src.length;
+  if (src.charCodeAt(0) === 65279) i = 1;
+  while (i < n) {
+    const ch = src[i];
+    if (inQuotes) {
+      if (ch === '"') {
+        if (src[i + 1] === '"') {
+          field += '"';
+          i += 2;
+          continue;
+        }
+        inQuotes = false;
+        i++;
+        continue;
+      }
+      field += ch;
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      inQuotes = true;
+      i++;
+      continue;
+    }
+    if (ch === delim) {
+      row.push(field);
+      field = "";
+      i++;
+      continue;
+    }
+    if (ch === "\r") {
+      i++;
+      continue;
+    }
+    if (ch === "\n") {
+      row.push(field);
+      rows.push(row);
+      row = [];
+      field = "";
+      i++;
+      continue;
+    }
+    field += ch;
+    i++;
+  }
+  if (field !== "" || row.length > 0) {
+    row.push(field);
+    rows.push(row);
+  }
+  return rows;
+}
+function needsQuote2(s, delim) {
+  return s.includes(delim) || s.includes('"') || s.includes("\n") || s.includes("\r");
+}
+function cell(v, delim) {
+  let s;
+  if (v === null || v === void 0) s = "";
+  else if (typeof v === "object") s = JSON.stringify(v);
+  else s = String(v);
+  if (needsQuote2(s, delim)) return '"' + s.replace(/"/g, '""') + '"';
+  return s;
+}
+function stringifyCsv(value, opts = {}) {
+  const delim = opts.delimiter ?? ",";
+  if (!Array.isArray(value)) {
+    throw new JsonToolError("CSV output requires an array of objects");
+  }
+  const rows = value;
+  let columns = opts.columns;
+  if (!columns) {
+    const seen = [];
+    const set = /* @__PURE__ */ new Set();
+    for (const r of rows) {
+      if (isPlainObject(r)) {
+        for (const k of Object.keys(r)) if (!set.has(k)) {
+          set.add(k);
+          seen.push(k);
+        }
+      }
+    }
+    columns = seen;
+  }
+  const lines = [];
+  lines.push(columns.map((c) => cell(c, delim)).join(delim));
+  for (const r of rows) {
+    if (isPlainObject(r)) {
+      lines.push(columns.map((c) => cell(r[c] ?? null, delim)).join(delim));
+    } else {
+      lines.push(cell(r, delim));
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function parseNdjson(src) {
+  const out = [];
+  const lines = src.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line === "") continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch (err) {
+      throw new JsonToolError(`NDJSON: invalid JSON on line ${i + 1}: ${err.message}`);
+    }
+  }
+  return out;
+}
+function stringifyNdjson(value) {
+  const arr = Array.isArray(value) ? value : [value];
+  return arr.map((v) => JSON.stringify(v)).join("\n") + "\n";
+}
+
+// src/convert.ts
+var EXT_MAP = {
+  json: "json",
+  json5: "json",
+  yaml: "yaml",
+  yml: "yaml",
+  toml: "toml",
+  csv: "csv",
+  tsv: "csv",
+  ndjson: "ndjson",
+  jsonl: "ndjson"
+};
+function formatFromExt(filename) {
+  const m = /\.([A-Za-z0-9]+)$/.exec(filename);
+  if (!m) return void 0;
+  return EXT_MAP[m[1].toLowerCase()];
+}
+function detectFormat(src) {
+  const trimmed = src.trim();
+  if (trimmed === "") return "json";
+  const lines = trimmed.split(/\r?\n/).filter((l) => l.trim() !== "");
+  if (lines.length > 1 && lines.every((l) => {
+    const t = l.trim();
+    return t.startsWith("{") && t.endsWith("}") || t.startsWith("[") && t.endsWith("]");
+  })) {
+    if (lines.every((l) => {
+      try {
+        JSON.parse(l);
+        return true;
+      } catch {
+        return false;
+      }
+    })) return "ndjson";
+  }
+  if (trimmed[0] === "{" || trimmed[0] === "[") {
+    try {
+      JSON.parse(trimmed);
+      return "json";
+    } catch {
+    }
+  }
+  if (/^\s*\[\[?[^\]]+\]\]?\s*$/m.test(trimmed) && /^\s*[A-Za-z0-9_."'-]+\s*=/m.test(trimmed)) return "toml";
+  const first = lines[0].trim();
+  if (first.includes(",") && !first.includes(": ") && !/^[\[{]/.test(first) && lines.length >= 1) {
+    if (!/^\s*-\s/.test(first)) return "csv";
+  }
+  if (/^\s*[A-Za-z0-9_."'-]+\s*=\s*/m.test(trimmed) && !/:\s/.test(trimmed)) return "toml";
+  return "yaml";
+}
+function parseFormat(src, format) {
+  switch (format) {
+    case "json": {
+      try {
+        return sanitizeJson(JSON.parse(src === "" ? "null" : src));
+      } catch (err) {
+        throw new JsonToolError(`Invalid JSON: ${err.message}`);
+      }
+    }
+    case "yaml":
+      return parseYaml(src);
+    case "toml":
+      return parseToml(src);
+    case "csv":
+      return parseCsv(src);
+    case "ndjson":
+      return parseNdjson(src);
+  }
+}
+function stringifyFormat(value, format, opts = {}) {
+  switch (format) {
+    case "json": {
+      const space = opts.minify ? void 0 : opts.indent ?? 2;
+      return JSON.stringify(value, null, space) + (opts.minify ? "" : "\n");
+    }
+    case "yaml":
+      return stringifyYaml(value);
+    case "toml":
+      return stringifyToml(value);
+    case "csv":
+      return stringifyCsv(value);
+    case "ndjson":
+      return stringifyNdjson(value);
+  }
+}
+function convert(src, from, to, opts = {}) {
+  const value = parseFormat(src, from);
+  return stringifyFormat(value, to, opts);
+}
+function sanitizeJson(v) {
+  if (v === null || typeof v !== "object") return v;
+  if (Array.isArray(v)) return v.map(sanitizeJson);
+  const out = {};
+  for (const k of Object.keys(v)) {
+    if (isForbiddenKey(k)) continue;
+    safeSet(out, k, sanitizeJson(v[k]));
+  }
+  return out;
+}
+
+// src/schema.ts
+var FORMATS = {
+  email: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+  uri: /^[A-Za-z][A-Za-z0-9+.-]*:\/\/\S+$/,
+  url: /^https?:\/\/\S+$/i,
+  uuid: /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+  date: /^\d{4}-\d{2}-\d{2}$/,
+  "date-time": /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:?\d{2})?$/,
+  time: /^\d{2}:\d{2}:\d{2}(\.\d+)?$/,
+  ipv4: /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/,
+  hostname: /^(?=.{1,253}$)([A-Za-z0-9]([A-Za-z0-9-]{0,61}[A-Za-z0-9])?)(\.[A-Za-z0-9]([A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*$/
+};
+var Validator = class _Validator {
+  root;
+  errors = [];
+  constructor(root) {
+    this.root = root;
+  }
+  validate(data, schema, path) {
+    if (schema === true || schema === void 0) return;
+    if (schema === false) {
+      this.err(path, "schema is `false` \u2014 no value is valid here");
+      return;
+    }
+    if (typeof schema !== "object") return;
+    if (typeof schema["$ref"] === "string") {
+      const resolved = this.resolveRef(schema["$ref"]);
+      if (resolved === void 0) this.err(path, `cannot resolve $ref "${schema["$ref"]}"`);
+      else this.validate(data, resolved, path);
+      return;
+    }
+    this.checkType(data, schema, path);
+    this.checkEnumConst(data, schema, path);
+    this.checkNumber(data, schema, path);
+    this.checkString(data, schema, path);
+    this.checkArray(data, schema, path);
+    this.checkObject(data, schema, path);
+    this.checkCombinators(data, schema, path);
+  }
+  err(path, message) {
+    this.errors.push({ path, message });
+  }
+  resolveRef(ref) {
+    if (!ref.startsWith("#/")) return void 0;
+    const parts = ref.slice(2).split("/").map((p) => p.replace(/~1/g, "/").replace(/~0/g, "~"));
+    let cur = this.root;
+    for (const p of parts) {
+      if (cur && typeof cur === "object") cur = cur[p];
+      else return void 0;
+    }
+    return cur;
+  }
+  checkType(data, schema, path) {
+    const t = schema["type"];
+    if (t === void 0) return;
+    const types = Array.isArray(t) ? t : [t];
+    const actual = typeOf(data);
+    const ok = types.some((want) => {
+      if (want === "integer") return actual === "number" && Number.isInteger(data);
+      return want === actual;
+    });
+    if (!ok) this.err(path, `expected type ${types.join(" | ")}, got ${actual}`);
+  }
+  checkEnumConst(data, schema, path) {
+    if ("const" in schema && !deepEqual(data, schema["const"])) {
+      this.err(path, `must equal const ${JSON.stringify(schema["const"])}`);
+    }
+    if (Array.isArray(schema["enum"])) {
+      const list = schema["enum"];
+      if (!list.some((e) => deepEqual(e, data))) {
+        this.err(path, `must be one of ${JSON.stringify(list)}`);
+      }
+    }
+  }
+  checkNumber(data, schema, path) {
+    if (typeof data !== "number") return;
+    if (typeof schema["minimum"] === "number" && data < schema["minimum"]) this.err(path, `must be >= ${schema["minimum"]}`);
+    if (typeof schema["maximum"] === "number" && data > schema["maximum"]) this.err(path, `must be <= ${schema["maximum"]}`);
+    if (typeof schema["exclusiveMinimum"] === "number" && data <= schema["exclusiveMinimum"]) this.err(path, `must be > ${schema["exclusiveMinimum"]}`);
+    if (typeof schema["exclusiveMaximum"] === "number" && data >= schema["exclusiveMaximum"]) this.err(path, `must be < ${schema["exclusiveMaximum"]}`);
+    if (typeof schema["multipleOf"] === "number" && schema["multipleOf"] > 0) {
+      const q = data / schema["multipleOf"];
+      if (Math.abs(q - Math.round(q)) > 1e-9) this.err(path, `must be a multiple of ${schema["multipleOf"]}`);
+    }
+  }
+  checkString(data, schema, path) {
+    if (typeof data !== "string") return;
+    if (typeof schema["minLength"] === "number" && data.length < schema["minLength"]) this.err(path, `must be at least ${schema["minLength"]} characters`);
+    if (typeof schema["maxLength"] === "number" && data.length > schema["maxLength"]) this.err(path, `must be at most ${schema["maxLength"]} characters`);
+    if (typeof schema["pattern"] === "string") {
+      let re = null;
+      try {
+        re = new RegExp(schema["pattern"]);
+      } catch {
+      }
+      if (re && !re.test(data)) this.err(path, `must match pattern /${schema["pattern"]}/`);
+    }
+    if (typeof schema["format"] === "string") {
+      const fmt = FORMATS[schema["format"]];
+      if (fmt && !fmt.test(data)) this.err(path, `must be a valid ${schema["format"]}`);
+      if (schema["format"] === "ipv4" && fmt && fmt.test(data)) {
+        if (!data.split(".").every((o) => Number(o) <= 255)) this.err(path, `must be a valid ipv4`);
+      }
+    }
+  }
+  checkArray(data, schema, path) {
+    if (!Array.isArray(data)) return;
+    if (typeof schema["minItems"] === "number" && data.length < schema["minItems"]) this.err(path, `must have at least ${schema["minItems"]} items`);
+    if (typeof schema["maxItems"] === "number" && data.length > schema["maxItems"]) this.err(path, `must have at most ${schema["maxItems"]} items`);
+    if (schema["uniqueItems"] === true) {
+      for (let i = 0; i < data.length; i++) {
+        for (let j = i + 1; j < data.length; j++) {
+          if (deepEqual(data[i], data[j])) {
+            this.err(path, `items must be unique (indexes ${i} and ${j})`);
+            break;
+          }
+        }
+      }
+    }
+    const items = schema["items"];
+    if (Array.isArray(items)) {
+      for (let i = 0; i < items.length && i < data.length; i++) {
+        this.validate(data[i], items[i], `${path}[${i}]`);
+      }
+      const additional = schema["additionalItems"];
+      if (additional !== void 0 && data.length > items.length) {
+        for (let i = items.length; i < data.length; i++) {
+          if (additional === false) this.err(`${path}[${i}]`, "additional items are not allowed");
+          else this.validate(data[i], additional, `${path}[${i}]`);
+        }
+      }
+    } else if (items !== void 0) {
+      for (let i = 0; i < data.length; i++) this.validate(data[i], items, `${path}[${i}]`);
+    }
+  }
+  checkObject(data, schema, path) {
+    if (data === null || typeof data !== "object" || Array.isArray(data)) return;
+    const obj = data;
+    const keys = Object.keys(obj);
+    if (Array.isArray(schema["required"])) {
+      for (const req of schema["required"]) {
+        if (!Object.prototype.hasOwnProperty.call(obj, req)) this.err(path, `missing required property "${req}"`);
+      }
+    }
+    if (typeof schema["minProperties"] === "number" && keys.length < schema["minProperties"]) this.err(path, `must have at least ${schema["minProperties"]} properties`);
+    if (typeof schema["maxProperties"] === "number" && keys.length > schema["maxProperties"]) this.err(path, `must have at most ${schema["maxProperties"]} properties`);
+    const props = schema["properties"] || {};
+    const patternProps = schema["patternProperties"] || {};
+    const additional = schema["additionalProperties"];
+    for (const key of keys) {
+      const childPath = `${path}.${key}`;
+      let matched = false;
+      if (Object.prototype.hasOwnProperty.call(props, key)) {
+        matched = true;
+        this.validate(obj[key], props[key], childPath);
+      }
+      for (const pat of Object.keys(patternProps)) {
+        let re = null;
+        try {
+          re = new RegExp(pat);
+        } catch {
+        }
+        if (re && re.test(key)) {
+          matched = true;
+          this.validate(obj[key], patternProps[pat], childPath);
+        }
+      }
+      if (!matched && additional !== void 0) {
+        if (additional === false) this.err(childPath, `additional property "${key}" is not allowed`);
+        else if (additional !== true) this.validate(obj[key], additional, childPath);
+      }
+    }
+  }
+  checkCombinators(data, schema, path) {
+    if (Array.isArray(schema["allOf"])) {
+      for (const sub of schema["allOf"]) this.validate(data, sub, path);
+    }
+    if (Array.isArray(schema["anyOf"])) {
+      const subs = schema["anyOf"];
+      const ok = subs.some((sub) => this.subValid(data, sub, path));
+      if (!ok) this.err(path, "must match at least one schema in anyOf");
+    }
+    if (Array.isArray(schema["oneOf"])) {
+      const subs = schema["oneOf"];
+      const count = subs.filter((sub) => this.subValid(data, sub, path)).length;
+      if (count !== 1) this.err(path, `must match exactly one schema in oneOf (matched ${count})`);
+    }
+    if (schema["not"] !== void 0) {
+      if (this.subValid(data, schema["not"], path)) this.err(path, "must not match the `not` schema");
+    }
+  }
+  subValid(data, schema, path) {
+    const probe = new _Validator(this.root);
+    probe.validate(data, schema, path);
+    return probe.errors.length === 0;
+  }
+  result() {
+    return { valid: this.errors.length === 0, errors: this.errors };
+  }
+};
+function validateSchema(data, schema) {
+  const v = new Validator(schema);
+  v.validate(data, schema, "$");
+  return v.result();
+}
+
+// src/diff.ts
+function join(base, key) {
+  if (typeof key === "number") return `${base}[${key}]`;
+  return base === "" ? key : `${base}.${key}`;
+}
+function walk(a, b, path, out) {
+  if (deepEqual(a, b)) return;
+  const aMissing = a === void 0;
+  const bMissing = b === void 0;
+  if (aMissing && !bMissing) {
+    out.push({ kind: "added", path, after: b });
+    return;
+  }
+  if (!aMissing && bMissing) {
+    out.push({ kind: "removed", path, before: a });
+    return;
+  }
+  if (isPlainObject(a) && isPlainObject(b)) {
+    const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+    for (const k of [...keys].sort()) {
+      walk(
+        Object.prototype.hasOwnProperty.call(a, k) ? a[k] : void 0,
+        Object.prototype.hasOwnProperty.call(b, k) ? b[k] : void 0,
+        join(path, k),
+        out
+      );
+    }
+    return;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    const max = Math.max(a.length, b.length);
+    for (let i = 0; i < max; i++) {
+      walk(i < a.length ? a[i] : void 0, i < b.length ? b[i] : void 0, join(path, i), out);
+    }
+    return;
+  }
+  out.push({ kind: "changed", path: path === "" ? "$" : path, before: a, after: b });
+}
+function diff(a, b) {
+  const out = [];
+  walk(a, b, "", out);
+  return out;
+}
+function isEqual(a, b) {
+  return deepEqual(a, b);
+}
+
+// src/merge.ts
+function mergeArrays(a, b, strat) {
+  if (strat.mode === "replace") return deepClone(b);
+  if (strat.mode === "concat") return [...deepClone(a), ...deepClone(b)];
+  const key = strat.key;
+  const out = deepClone(a);
+  const indexByKey = /* @__PURE__ */ new Map();
+  out.forEach((item, i) => {
+    if (isPlainObject(item) && item[key] !== void 0) indexByKey.set(JSON.stringify(item[key]), i);
+  });
+  for (const item of b) {
+    if (isPlainObject(item) && item[key] !== void 0) {
+      const id = JSON.stringify(item[key]);
+      if (indexByKey.has(id)) {
+        const idx = indexByKey.get(id);
+        out[idx] = mergeTwo(out[idx], item, { array: strat });
+      } else {
+        indexByKey.set(id, out.length);
+        out.push(deepClone(item));
+      }
+    } else {
+      out.push(deepClone(item));
+    }
+  }
+  return out;
+}
+function mergeTwo(a, b, opts) {
+  const strat = opts.array ?? { mode: "replace" };
+  if (Array.isArray(a) && Array.isArray(b)) return mergeArrays(a, b, strat);
+  if (isPlainObject(a) && isPlainObject(b)) {
+    const out = {};
+    for (const k of Object.keys(a)) {
+      if (isForbiddenKey(k)) continue;
+      safeSet(out, k, deepClone(a[k]));
+    }
+    for (const k of Object.keys(b)) {
+      if (isForbiddenKey(k)) continue;
+      if (Object.prototype.hasOwnProperty.call(out, k)) {
+        safeSet(out, k, mergeTwo(out[k], b[k], opts));
+      } else {
+        safeSet(out, k, deepClone(b[k]));
+      }
+    }
+    return out;
+  }
+  return deepClone(b);
+}
+function merge(values, opts = {}) {
+  if (values.length === 0) return null;
+  let acc = deepClone(values[0]);
+  for (let i = 1; i < values.length; i++) acc = mergeTwo(acc, values[i], opts);
+  return acc;
+}
+function parseArrayStrategy(spec, byKey) {
+  if (byKey) return { mode: "by-key", key: byKey };
+  if (spec === "concat") return { mode: "concat" };
+  if (spec === "replace") return { mode: "replace" };
+  if (spec && spec.startsWith("by-key")) {
+    const key = spec.split(/[:=]/)[1];
+    if (key) return { mode: "by-key", key };
+  }
+  return { mode: "replace" };
+}
+
+// src/format.ts
+function formatJson(value, opts = {}) {
+  const v = opts.sortKeys ? sortKeysDeep(value) : value;
+  if (opts.minify) return JSON.stringify(v);
+  const indent = opts.indent ?? 2;
+  return JSON.stringify(v, null, indent);
+}
+function getPath(data, path) {
+  const segments = parsePath(path);
+  let cur = data;
+  for (const seg of segments) {
+    if (cur === null || cur === void 0) return void 0;
+    if (typeof seg === "number") {
+      if (!Array.isArray(cur)) return void 0;
+      const idx = seg < 0 ? cur.length + seg : seg;
+      cur = cur[idx];
+    } else {
+      if (Array.isArray(cur) || typeof cur !== "object") return void 0;
+      if (!Object.prototype.hasOwnProperty.call(cur, seg)) return void 0;
+      cur = cur[seg];
+    }
+  }
+  return cur;
+}
+function parsePath(path) {
+  const out = [];
+  let i = 0;
+  const n = path.length;
+  if (path[0] === ".") i = 1;
+  let cur = "";
+  const flush = () => {
+    if (cur !== "") {
+      out.push(cur);
+      cur = "";
+    }
+  };
+  while (i < n) {
+    const ch = path[i];
+    if (ch === ".") {
+      flush();
+      i++;
+      continue;
+    }
+    if (ch === "[") {
+      flush();
+      const close = path.indexOf("]", i);
+      if (close < 0) throw new JsonToolError(`Unbalanced [ in path "${path}"`);
+      const inner = path.slice(i + 1, close).trim();
+      if (inner[0] === '"' && inner.endsWith('"') || inner[0] === "'" && inner.endsWith("'")) {
+        out.push(inner.slice(1, -1));
+      } else if (/^-?\d+$/.test(inner)) {
+        out.push(parseInt(inner, 10));
+      } else {
+        out.push(inner);
+      }
+      i = close + 1;
+      continue;
+    }
+    cur += ch;
+    i++;
+  }
+  flush();
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JsonToolError,
+  compareValues,
+  compileQuery,
+  convert,
+  deepClone,
+  deepEqual,
+  detectFormat,
+  diff,
+  formatFromExt,
+  formatJson,
+  getPath,
+  isEqual,
+  isPlainObject,
+  isValidQuery,
+  merge,
+  parseArrayStrategy,
+  parseCsv,
+  parseFormat,
+  parseNdjson,
+  parsePath,
+  parseToml,
+  parseYaml,
+  query,
+  queryAll,
+  sanitizeJson,
+  sortKeysDeep,
+  stringifyCsv,
+  stringifyFormat,
+  stringifyNdjson,
+  stringifyToml,
+  stringifyYaml,
+  typeOf,
+  validateSchema
+});