novac 2.0.1 → 2.2.0

package/kits/kitparse/kitdef.js

@@ -0,0 +1,1688 @@
+// kitparse — novac standard parsing kit
+// Covers: CSV, TOML, INI, query strings, XML, JSON, YAML, HJSON, NDJSON,
+//         dotenv, simple tokenizer/lexer helpers, custom expression resolvers
+
+// ─── CSV ─────────────────────────────────────────────────────────────────────
+
+function csvParse(input, opts = {}) {
+  const sep       = opts.separator  ?? ',';
+  const quote     = opts.quote      ?? '"';
+  const headers   = opts.headers    ?? true;
+  const skipEmpty = opts.skipEmpty  ?? true;
+  const trim      = opts.trim       ?? false;
+
+  const lines = splitLines(input);
+  const rows  = [];
+
+  for (const raw of lines) {
+    if (skipEmpty && raw.trim() === '') continue;
+    const row = [];
+    let i = 0, cur = '';
+    let inQ = false;
+
+    while (i < raw.length) {
+      const ch = raw[i];
+      if (inQ) {
+        if (ch === quote) {
+          if (raw[i + 1] === quote) { cur += quote; i += 2; }
+          else                       { inQ = false; i++; }
+        } else { cur += ch; i++; }
+      } else {
+        if (ch === quote)     { inQ = true; i++; }
+        else if (ch === sep)  { row.push(trim ? cur.trim() : cur); cur = ''; i++; }
+        else                  { cur += ch; i++; }
+      }
+    }
+    row.push(trim ? cur.trim() : cur);
+    rows.push(row);
+  }
+
+  if (!headers || rows.length === 0) return rows;
+
+  const keys   = rows[0];
+  const result = [];
+  for (let r = 1; r < rows.length; r++) {
+    const obj = {};
+    for (let c = 0; c < keys.length; c++) obj[keys[c]] = rows[r][c] ?? '';
+    result.push(obj);
+  }
+  return result;
+}
+
+function csvStringify(data, opts = {}) {
+  const sep   = opts.separator ?? ',';
+  const quote = opts.quote     ?? '"';
+  const crlf  = opts.crlf      ?? false;
+  const nl    = crlf ? '\r\n' : '\n';
+
+  const needsQuote = (v) => {
+    const s = String(v);
+    let i = 0;
+    while (i < s.length) {
+      const c = s[i];
+      if (c === sep[0] || c === quote || c === '\n') return true;
+      i++;
+    }
+    return false;
+  };
+  const cell = (v) => {
+    const s = v == null ? '' : String(v);
+    if (needsQuote(s)) {
+      let escaped = '';
+      for (let i = 0; i < s.length; i++) {
+        escaped += s[i] === quote ? quote + quote : s[i];
+      }
+      return quote + escaped + quote;
+    }
+    return s;
+  };
+
+  if (data.length === 0) return '';
+
+  if (Array.isArray(data[0])) {
+    return data.map(row => row.map(cell).join(sep)).join(nl);
+  }
+
+  const keys   = Object.keys(data[0]);
+  const header = keys.map(cell).join(sep);
+  const body   = data.map(row => keys.map(k => cell(row[k])).join(sep));
+  return [header, ...body].join(nl);
+}
+
+// ─── TOML ────────────────────────────────────────────────────────────────────
+
+function tomlParse(input) {
+  const lines  = splitLines(input);
+  const root   = {};
+  let current  = root;
+
+  // manual integer check: optional leading minus, then all digits
+  function isInt(s) {
+    let i = 0;
+    if (s[i] === '-') i++;
+    if (i === s.length) return false;
+    while (i < s.length) { if (s[i] < '0' || s[i] > '9') return false; i++; }
+    return true;
+  }
+
+  // manual float check: optional minus, digits, dot, digits
+  function isFloat(s) {
+    let i = 0;
+    if (s[i] === '-') i++;
+    let hasDot = false;
+    let hasDigit = false;
+    while (i < s.length) {
+      const c = s[i];
+      if (c >= '0' && c <= '9') { hasDigit = true; i++; }
+      else if (c === '.' && !hasDot) { hasDot = true; i++; }
+      else return false;
+    }
+    return hasDot && hasDigit;
+  }
+
+  function coerce(s) {
+    s = s.trim();
+    if (s === 'true')  return true;
+    if (s === 'false') return false;
+    if (isInt(s))   return parseInt(s, 10);
+    if (isFloat(s)) return parseFloat(s);
+    const q = s[0];
+    if ((q === '"' || q === "'") && s[s.length - 1] === q) return s.slice(1, -1);
+    if (s[0] === '[') {
+      // simple inline array — split by comma, trim, coerce each
+      const inner = s.slice(1, s.length - 1);
+      return splitCommaRespectingQuotes(inner).map(v => coerce(v.trim())).filter(v => v !== '');
+    }
+    return s;
+  }
+
+  function splitCommaRespectingQuotes(s) {
+    const parts = [];
+    let cur = '', depth = 0;
+    let inQ = false, q = '';
+    for (let i = 0; i < s.length; i++) {
+      const c = s[i];
+      if (inQ) {
+        cur += c;
+        if (c === q) inQ = false;
+      } else if (c === '"' || c === "'") {
+        inQ = true; q = c; cur += c;
+      } else if (c === '[') { depth++; cur += c; }
+      else if (c === ']') { depth--; cur += c; }
+      else if (c === ',' && depth === 0) { parts.push(cur); cur = ''; }
+      else cur += c;
+    }
+    if (cur.trim()) parts.push(cur);
+    return parts;
+  }
+
+  const nav = (obj, parts) => {
+    let cur = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+      if (!(parts[i] in cur)) cur[parts[i]] = {};
+      cur = cur[parts[i]];
+    }
+    return cur;
+  };
+
+  let i = 0;
+  while (i < lines.length) {
+    // strip comment: find first # not inside a quoted string
+    let line = stripTomlComment(lines[i]).trim();
+    i++;
+    if (!line) continue;
+
+    // [[array table]]
+    if (line[0] === '[' && line[1] === '[' && line[line.length - 1] === ']' && line[line.length - 2] === ']') {
+      const key   = line.slice(2, -2).trim();
+      const parts = key.split('.');
+      const last  = parts.pop();
+      const p     = nav(root, parts.length ? [...parts, last] : [last]);
+      const k     = parts.length ? last : key.split('.')[0];
+      const arr   = nav(root, parts.length ? parts : []);
+      const target = parts.length ? arr[last] : root[key];
+      if (!Array.isArray(target)) {
+        const container = parts.length ? nav(root, parts) : root;
+        if (!Array.isArray(container[last])) container[last] = [];
+        container[last].push({});
+        current = container[last][container[last].length - 1];
+      }
+      continue;
+    }
+
+    // [table]
+    if (line[0] === '[' && line[line.length - 1] === ']') {
+      const key   = line.slice(1, -1).trim();
+      const parts = key.split('.');
+      current = root;
+      for (const part of parts) {
+        if (!(part in current)) current[part] = {};
+        current = current[part];
+      }
+      continue;
+    }
+
+    // key = value
+    const eq = line.indexOf('=');
+    if (eq === -1) continue;
+    const key = line.slice(0, eq).trim();
+    const val = line.slice(eq + 1).trim();
+    current[key] = coerce(val);
+  }
+
+  return root;
+}
+
+function stripTomlComment(line) {
+  let inQ = false, q = '';
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+    if (inQ) { if (c === q) inQ = false; }
+    else if (c === '"' || c === "'") { inQ = true; q = c; }
+    else if (c === '#') return line.slice(0, i);
+  }
+  return line;
+}
+
+function tomlStringify(obj, indent = '') {
+  const lines  = [];
+  const nested = [];
+
+  for (const [k, v] of Object.entries(obj)) {
+    if (v === null || v === undefined) continue;
+    if (typeof v === 'object' && !Array.isArray(v)) {
+      nested.push([k, v]);
+    } else if (Array.isArray(v) && v.length > 0 && typeof v[0] === 'object') {
+      for (const item of v) {
+        lines.push(`[[${k}]]`);
+        lines.push(tomlStringify(item, ''));
+      }
+    } else if (typeof v === 'string') {
+      lines.push(`${k} = "${escapeTomlString(v)}"`);
+    } else if (Array.isArray(v)) {
+      const items = v.map(x => typeof x === 'string' ? `"${x}"` : String(x));
+      lines.push(`${k} = [${items.join(', ')}]`);
+    } else {
+      lines.push(`${k} = ${v}`);
+    }
+  }
+
+  for (const [k, v] of nested) {
+    lines.push(`\n[${indent ? indent + '.' : ''}${k}]`);
+    lines.push(tomlStringify(v, indent ? indent + '.' + k : k));
+  }
+
+  return lines.join('\n');
+}
+
+function escapeTomlString(s) {
+  let out = '';
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (c === '"')  out += '\\"';
+    else if (c === '\\') out += '\\\\';
+    else out += c;
+  }
+  return out;
+}
+
+// ─── INI ─────────────────────────────────────────────────────────────────────
+
+function iniParse(input, opts = {}) {
+  const comment   = opts.comment   ?? [';', '#'];
+  const delim     = opts.delim     ?? '=';
+  const lowercase = opts.lowercase ?? false;
+
+  const isComment = (line) => {
+    for (const c of comment) if (line.startsWith(c)) return true;
+    return false;
+  };
+
+  const lines   = splitLines(input);
+  const result  = { __global__: {} };
+  let section   = '__global__';
+
+  for (let raw of lines) {
+    raw = raw.trim();
+    if (!raw || isComment(raw)) continue;
+
+    if (raw[0] === '[' && raw[raw.length - 1] === ']') {
+      section = raw.slice(1, -1).trim();
+      if (lowercase) section = section.toLowerCase();
+      if (!(section in result)) result[section] = {};
+      continue;
+    }
+
+    const idx = raw.indexOf(delim);
+    if (idx === -1) continue;
+
+    let key = raw.slice(0, idx).trim();
+    let val = raw.slice(idx + 1).trim();
+    if (lowercase) key = key.toLowerCase();
+
+    // strip inline comments
+    for (const c of comment) {
+      const ci = val.indexOf(' ' + c);
+      if (ci !== -1) val = val.slice(0, ci).trim();
+    }
+
+    // strip surrounding quotes
+    const q = val[0];
+    if ((q === '"' || q === "'") && val[val.length - 1] === q) val = val.slice(1, -1);
+
+    result[section][key] = val;
+  }
+
+  return result;
+}
+
+function iniStringify(obj, opts = {}) {
+  const delim = opts.delim ?? '=';
+  const lines = [];
+
+  const global = obj['__global__'] ?? {};
+  for (const [k, v] of Object.entries(global)) lines.push(`${k} ${delim} ${v}`);
+  if (lines.length) lines.push('');
+
+  for (const [section, entries] of Object.entries(obj)) {
+    if (section === '__global__') continue;
+    lines.push(`[${section}]`);
+    for (const [k, v] of Object.entries(entries)) lines.push(`${k} ${delim} ${v}`);
+    lines.push('');
+  }
+
+  return lines.join('\n').trimEnd();
+}
+
+// ─── QUERY STRING ────────────────────────────────────────────────────────────
+
+function qsParse(input, opts = {}) {
+  const sep    = opts.separator ?? '&';
+  const eq     = opts.eq        ?? '=';
+  const decode = opts.decode    ?? true;
+  const arrays = opts.arrays    ?? true;
+
+  const str = input[0] === '?' ? input.slice(1) : input;
+  if (!str) return {};
+
+  const result = {};
+  for (const pair of str.split(sep)) {
+    const idx = pair.indexOf(eq);
+    let key = idx === -1 ? pair : pair.slice(0, idx);
+    let val = idx === -1 ? '' : pair.slice(idx + 1);
+    if (decode) { try { key = decodeURIComponent(key.split('+').join(' ')); } catch {} }
+    if (decode) { try { val = decodeURIComponent(val.split('+').join(' ')); } catch {} }
+
+    if (arrays && key in result) {
+      if (!Array.isArray(result[key])) result[key] = [result[key]];
+      result[key].push(val);
+    } else {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+
+function qsStringify(obj, opts = {}) {
+  const sep    = opts.separator ?? '&';
+  const eq     = opts.eq        ?? '=';
+  const encode = opts.encode    ?? true;
+
+  const enc   = encode ? encodeURIComponent : (x) => String(x);
+  const pairs = [];
+
+  for (const [k, v] of Object.entries(obj)) {
+    if (Array.isArray(v)) {
+      for (const item of v) pairs.push(`${enc(k)}${eq}${enc(item)}`);
+    } else if (v !== null && v !== undefined) {
+      pairs.push(`${enc(k)}${eq}${enc(v)}`);
+    }
+  }
+
+  return pairs.join(sep);
+}
+
+// ─── TOKENIZER / LEXER HELPER ─────────────────────────────────────────────────
+
+class TokenStream {
+  constructor(tokens) {
+    this._tokens = tokens;
+    this._pos    = 0;
+  }
+  get pos()        { return this._pos; }
+  get length()     { return this._tokens.length; }
+  peek(offset = 0) { return this._tokens[this._pos + offset] ?? null; }
+  next()           { return this._tokens[this._pos++] ?? null; }
+  back()           { if (this._pos > 0) this._pos--; }
+  done()           { return this._pos >= this._tokens.length; }
+  expect(type) {
+    const t = this.next();
+    if (!t) throw new Error(`Expected token type '${type}' but reached end of stream`);
+    if (t.type !== type) throw new Error(`Expected '${type}' but got '${t.type}' ("${t.value}") at pos ${t.pos ?? this._pos}`);
+    return t;
+  }
+  consume(type) {
+    if (this.peek()?.type === type) return this.next();
+    return null;
+  }
+  takeWhile(pred) {
+    const out = [];
+    while (!this.done() && pred(this.peek())) out.push(this.next());
+    return out;
+  }
+  rest()  { return this._tokens.slice(this._pos); }
+  reset() { this._pos = 0; }
+  clone() { const s = new TokenStream(this._tokens); s._pos = this._pos; return s; }
+}
+
+function tokenize(input, rules, opts = {}) {
+  // rules: [ { type: string, pattern: RegExp, skip?: bool, transform?: fn } ]
+  // opts.onUnknown: 'throw' | 'skip' | 'raw' (default 'throw')
+  const onUnknown = opts.onUnknown ?? 'throw';
+  const tokens    = [];
+  let pos         = 0;
+
+  outer: while (pos < input.length) {
+    for (const rule of rules) {
+      const re = new RegExp(rule.pattern.source, 'y');
+      re.lastIndex = pos;
+      const match = re.exec(input);
+      if (!match) continue;
+
+      const raw = match[0];
+      if (!rule.skip) {
+        const value = rule.transform ? rule.transform(raw, match) : raw;
+        tokens.push({ type: rule.type, value, pos });
+      }
+      pos += raw.length;
+      continue outer;
+    }
+
+    if (onUnknown === 'throw') {
+      throw new Error(`Unexpected character '${input[pos]}' at position ${pos}`);
+    } else if (onUnknown === 'raw') {
+      tokens.push({ type: 'UNKNOWN', value: input[pos], pos });
+    }
+    pos++;
+  }
+
+  return new TokenStream(tokens);
+}
+
+// ─── EXPRESSION RESOLVER ─────────────────────────────────────────────────────
+// Parses and evaluates infix expressions with user-defined operators.
+//
+// Built-in ops: + - * / % ** ( )
+// Custom op definition:
+//   ExprResolver.define(symbol, precedence, fn(left, right))
+//   ExprResolver.defineUnary(symbol, fn(operand))
+//
+// Usage:
+//   const r = new ExprResolver()
+//   r.define('|>', 0, (a, b) => b(a))            // pipe
+//   r.define('??', 1, (a, b) => a ?? b)           // nullish coalesce
+//   r.defineUnary('!', (a) => !a)
+//   r.eval('3 + 4 * 2')  // → 11
+//   r.eval('(1 + 2) ** 3') // → 27
+
+class ExprResolver {
+  constructor() {
+    // ops: Map<symbol, { prec: number, assoc: 'left'|'right', fn: (l,r)=>any }>
+    this._ops    = new Map();
+    // unary: Map<symbol, fn>
+    this._unary  = new Map();
+
+    // built-in binary ops
+    this.define('+',  10, (a, b) => a + b);
+    this.define('-',  10, (a, b) => a - b);
+    this.define('*',  20, (a, b) => a * b);
+    this.define('/',  20, (a, b) => a / b);
+    this.define('%',  20, (a, b) => a % b);
+    this.define('**', 30, (a, b) => a ** b, 'right');
+
+    // built-in unary
+    this.defineUnary('-', (a) => -a);
+    this.defineUnary('!', (a) => !a);
+    this.defineUnary('~', (a) => ~a);
+  }
+
+  // define or override a binary infix operator
+  define(sym, prec, fn, assoc = 'left') {
+    this._ops.set(sym, { prec, assoc, fn });
+    return this;
+  }
+
+  // define or override a prefix unary operator
+  defineUnary(sym, fn) {
+    this._unary.set(sym, fn);
+    return this;
+  }
+
+  // remove an operator
+  undefine(sym) { this._ops.delete(sym); this._unary.delete(sym); return this; }
+
+  // list all defined binary ops
+  ops() { return [...this._ops.entries()].map(([sym, def]) => ({ sym, ...def })); }
+
+  // evaluate an expression string, optionally with a variable scope object
+  eval(input, scope = {}) {
+    const tokens = this._lex(input.trim());
+    const stream = new TokenStream(tokens);
+    const result = this._parseInfix(stream, 0, scope);
+    if (!stream.done()) {
+      const t = stream.peek();
+      throw new Error(`Unexpected token '${t.value}' at pos ${t.pos}`);
+    }
+    return result;
+  }
+
+  // parse an expression and return the AST without evaluating
+  parse(input) {
+    const tokens = this._lex(input.trim());
+    const stream = new TokenStream(tokens);
+    return this._parseASTInfix(stream, 0);
+  }
+
+  _lex(input) {
+    // collect all operator symbols (longest first to handle ** before *)
+    const symsSorted = [...this._ops.keys(), ...this._unary.keys()]
+      .filter((v, i, a) => a.indexOf(v) === i)
+      .sort((a, b) => b.length - a.length);
+
+    const tokens = [];
+    let pos = 0;
+
+    while (pos < input.length) {
+      // skip whitespace
+      if (isWS(input[pos])) { pos++; continue; }
+
+      // number literal: digits, optional dot, optional e/E exponent
+      if (isDigit(input[pos]) || (input[pos] === '.' && isDigit(input[pos + 1] ?? ''))) {
+        let raw = '';
+        while (pos < input.length && (isDigit(input[pos]) || input[pos] === '.')) raw += input[pos++];
+        if ((input[pos] === 'e' || input[pos] === 'E') && pos < input.length) {
+          raw += input[pos++];
+          if (input[pos] === '+' || input[pos] === '-') raw += input[pos++];
+          while (pos < input.length && isDigit(input[pos])) raw += input[pos++];
+        }
+        tokens.push({ type: 'NUM', value: parseFloat(raw), pos: pos - raw.length });
+        continue;
+      }
+
+      // string literal
+      if (input[pos] === '"' || input[pos] === "'") {
+        const q = input[pos++];
+        let s = '';
+        while (pos < input.length && input[pos] !== q) {
+          if (input[pos] === '\\') { pos++; s += escSeq(input[pos++]); }
+          else s += input[pos++];
+        }
+        pos++; // closing quote
+        tokens.push({ type: 'STR', value: s, pos: pos - s.length - 2 });
+        continue;
+      }
+
+      // parens
+      if (input[pos] === '(') { tokens.push({ type: 'LPAREN', value: '(', pos }); pos++; continue; }
+      if (input[pos] === ')') { tokens.push({ type: 'RPAREN', value: ')', pos }); pos++; continue; }
+
+      // booleans / null / identifiers
+      if (isAlpha(input[pos]) || input[pos] === '_') {
+        let name = '';
+        while (pos < input.length && (isAlpha(input[pos]) || isDigit(input[pos]) || input[pos] === '_')) name += input[pos++];
+        if (name === 'true')  { tokens.push({ type: 'BOOL', value: true,  pos: pos - name.length }); continue; }
+        if (name === 'false') { tokens.push({ type: 'BOOL', value: false, pos: pos - name.length }); continue; }
+        if (name === 'null' || name === 'nil') { tokens.push({ type: 'NULL', value: null, pos: pos - name.length }); continue; }
+        tokens.push({ type: 'IDENT', value: name, pos: pos - name.length });
+        continue;
+      }
+
+      // operators (longest match first)
+      let matched = false;
+      for (const sym of symsSorted) {
+        if (input.startsWith(sym, pos)) {
+          tokens.push({ type: 'OP', value: sym, pos });
+          pos += sym.length;
+          matched = true;
+          break;
+        }
+      }
+      if (!matched) throw new Error(`Unexpected character '${input[pos]}' at position ${pos}`);
+    }
+
+    return tokens;
+  }
+
+  _parseAtom(stream, scope) {
+    const t = stream.next();
+    if (!t) throw new Error('Unexpected end of expression');
+
+    if (t.type === 'NUM' || t.type === 'STR' || t.type === 'BOOL' || t.type === 'NULL') return t.value;
+
+    if (t.type === 'IDENT') {
+      const val = scope[t.value];
+      if (val === undefined && !(t.value in scope)) throw new Error(`Undefined variable '${t.value}'`);
+      return val;
+    }
+
+    if (t.type === 'LPAREN') {
+      const val = this._parseInfix(stream, 0, scope);
+      stream.expect('RPAREN');
+      return val;
+    }
+
+    if (t.type === 'OP') {
+      const unary = this._unary.get(t.value);
+      if (unary) {
+        // unary binds tighter than any binary; use max prec
+        const operand = this._parseAtom(stream, scope);
+        return unary(operand);
+      }
+      throw new Error(`Operator '${t.value}' used in prefix position but not defined as unary`);
+    }
+
+    throw new Error(`Unexpected token '${t.value}' (type: ${t.type})`);
+  }
+
+  _parseInfix(stream, minPrec, scope) {
+    let left = this._parseAtom(stream, scope);
+
+    while (true) {
+      const op = stream.peek();
+      if (!op || op.type !== 'OP') break;
+      const def = this._ops.get(op.value);
+      if (!def) break;
+      const { prec, assoc, fn } = def;
+      if (prec < minPrec) break;
+      if (prec === minPrec && assoc === 'left') break;
+      stream.next();
+      const nextMinPrec = assoc === 'right' ? prec : prec + 1;
+      const right = this._parseInfix(stream, nextMinPrec, scope);
+      left = fn(left, right);
+    }
+
+    return left;
+  }
+
+  // AST-only parse (no eval) — returns node objects
+  _parseASTAtom(stream) {
+    const t = stream.next();
+    if (!t) throw new Error('Unexpected end of expression');
+
+    if (t.type === 'NUM')   return { type: 'Literal', kind: 'number', value: t.value };
+    if (t.type === 'STR')   return { type: 'Literal', kind: 'string', value: t.value };
+    if (t.type === 'BOOL')  return { type: 'Literal', kind: 'boolean', value: t.value };
+    if (t.type === 'NULL')  return { type: 'Literal', kind: 'null', value: null };
+    if (t.type === 'IDENT') return { type: 'Identifier', name: t.value };
+
+    if (t.type === 'LPAREN') {
+      const expr = this._parseASTInfix(stream, 0);
+      stream.expect('RPAREN');
+      return { type: 'Group', expr };
+    }
+
+    if (t.type === 'OP' && this._unary.has(t.value)) {
+      const operand = this._parseASTAtom(stream);
+      return { type: 'UnaryExpr', op: t.value, operand };
+    }
+
+    throw new Error(`Unexpected token '${t.value}'`);
+  }
+
+  _parseASTInfix(stream, minPrec) {
+    let left = this._parseASTAtom(stream);
+
+    while (true) {
+      const op = stream.peek();
+      if (!op || op.type !== 'OP') break;
+      const def = this._ops.get(op.value);
+      if (!def) break;
+      const { prec, assoc } = def;
+      if (prec < minPrec) break;
+      if (prec === minPrec && assoc === 'left') break;
+      stream.next();
+      const nextMinPrec = assoc === 'right' ? prec : prec + 1;
+      const right = this._parseASTInfix(stream, nextMinPrec);
+      left = { type: 'BinaryExpr', op: op.value, left, right };
+    }
+
+    return left;
+  }
+}
+
+// legacy single-function wrapper (built-in arithmetic only)
+function parseExpr(input) {
+  return new ExprResolver().eval(input);
+}
+
+// ─── XML ─────────────────────────────────────────────────────────────────────
+
+function xmlParse(input) {
+  const s = input.trim();
+  let pos = 0;
+
+  function skipWS() { while (pos < s.length && isWS(s[pos])) pos++; }
+
+  function parseAttr() {
+    const attrs = {};
+    while (pos < s.length && s[pos] !== '>' && s[pos] !== '/') {
+      skipWS();
+      if (s[pos] === '>' || s[pos] === '/') break;
+      let name = '';
+      while (pos < s.length && !isWS(s[pos]) && s[pos] !== '=' && s[pos] !== '>' && s[pos] !== '/') name += s[pos++];
+      if (!name) { pos++; continue; }
+      skipWS();
+      if (s[pos] === '=') {
+        pos++;
+        skipWS();
+        const q = s[pos++];
+        let val = '';
+        while (pos < s.length && s[pos] !== q) val += s[pos++];
+        pos++; // closing quote
+        attrs[name] = xmlDecodeEntities(val);
+      } else {
+        attrs[name] = true;
+      }
+      skipWS();
+    }
+    return attrs;
+  }
+
+  function parseNode() {
+    skipWS();
+    // processing instruction / doctype — skip
+    if (s[pos] === '<' && (s[pos + 1] === '?' || s[pos + 1] === '!')) {
+      while (pos < s.length && s[pos] !== '>') pos++;
+      pos++;
+      return parseNode();
+    }
+    if (s[pos] !== '<') throw new Error(`Expected '<' at pos ${pos}, got '${s[pos]}'`);
+    pos++;
+    let tag = '';
+    while (pos < s.length && !isWS(s[pos]) && s[pos] !== '>' && s[pos] !== '/') tag += s[pos++];
+    skipWS();
+    const attrs = parseAttr();
+    skipWS();
+    // self-closing
+    if (s[pos] === '/') { pos += 2; return { tag, attrs, children: [], text: '' }; }
+    pos++; // skip >
+    const children = [];
+    let text = '';
+    while (pos < s.length) {
+      if (s[pos] === '<' && s[pos + 1] === '/') { // closing tag
+        pos += 2;
+        while (pos < s.length && s[pos] !== '>') pos++;
+        pos++;
+        break;
+      }
+      if (s[pos] === '<') {
+        if (s[pos + 1] === '!' && s[pos + 2] === '-' && s[pos + 3] === '-') {
+          // comment
+          const end = indexOfStr(s, '-->', pos);
+          pos = end === -1 ? s.length : end + 3;
+          continue;
+        }
+        const child = parseNode();
+        if (child) children.push(child);
+      } else {
+        let raw = '';
+        while (pos < s.length && s[pos] !== '<') raw += s[pos++];
+        text += xmlDecodeEntities(raw);
+      }
+    }
+    return { tag, attrs, children, text: text.trim() };
+  }
+
+  return parseNode();
+}
+
+function xmlDecodeEntities(s) {
+  let out = '';
+  let i = 0;
+  while (i < s.length) {
+    if (s[i] === '&') {
+      let entity = '';
+      i++;
+      while (i < s.length && s[i] !== ';') entity += s[i++];
+      i++; // skip ;
+      if (entity === 'amp')  out += '&';
+      else if (entity === 'lt')   out += '<';
+      else if (entity === 'gt')   out += '>';
+      else if (entity === 'quot') out += '"';
+      else if (entity === 'apos') out += "'";
+      else out += '&' + entity + ';';
+    } else {
+      out += s[i++];
+    }
+  }
+  return out;
+}
+
+function xmlStringify(node, indent = '', opts = {}) {
+  const pretty = opts.pretty ?? true;
+  const nl     = pretty ? '\n' : '';
+  const step   = opts.indent ?? '  ';
+
+  const escape = (s) => {
+    let out = '';
+    for (let i = 0; i < String(s).length; i++) {
+      const c = String(s)[i];
+      if (c === '&') out += '&amp;';
+      else if (c === '<') out += '&lt;';
+      else if (c === '>') out += '&gt;';
+      else if (c === '"') out += '&quot;';
+      else out += c;
+    }
+    return out;
+  };
+
+  const attrStr = Object.entries(node.attrs ?? {})
+    .map(([k, v]) => v === true ? ` ${k}` : ` ${k}="${escape(v)}"`)
+    .join('');
+
+  const next = indent + step;
+
+  if (!node.children?.length && !node.text) return `${indent}<${node.tag}${attrStr}/>${nl}`;
+  if (!node.children?.length) return `${indent}<${node.tag}${attrStr}>${escape(node.text)}</${node.tag}>${nl}`;
+
+  const body = node.children.map(c => xmlStringify(c, next, opts)).join('');
+  return `${indent}<${node.tag}${attrStr}>${nl}${body}${indent}</${node.tag}>${nl}`;
+}
+
+// xmlQuery: CSS-like selector on the parsed tree.
+// Supports: tag, tag > child, descendant, [attr], [attr=val]
+function xmlQuery(node, selector) {
+  // manual selector tokenizer: split on ' > ' for child combinator, ' ' for descendant
+  const results = [];
+  const parts   = splitSelectorParts(selector.trim());
+
+  function matchSingle(n, part) {
+    // parse tag name (up to '[' or end)
+    let i = 0;
+    let tag = '';
+    while (i < part.length && part[i] !== '[') tag += part[i++];
+    tag = tag.trim() || '*';
+    if (tag !== '*' && n.tag !== tag) return false;
+
+    // parse attribute selectors [key] or [key=val]
+    while (i < part.length && part[i] === '[') {
+      i++; // skip [
+      let key = '';
+      while (i < part.length && part[i] !== '=' && part[i] !== ']') key += part[i++];
+      key = key.trim();
+      if (part[i] === '=') {
+        i++; // skip =
+        let val = '';
+        // optional quotes
+        const q = (part[i] === '"' || part[i] === "'") ? part[i++] : null;
+        while (i < part.length && part[i] !== (q ?? ']') && part[i] !== ']') val += part[i++];
+        if (q && part[i] === q) i++;
+        if (part[i] === ']') i++;
+        if (!(key in (n.attrs ?? {}))) return false;
+        if (n.attrs[key] !== val) return false;
+      } else {
+        if (part[i] === ']') i++;
+        if (!(key in (n.attrs ?? {}))) return false;
+      }
+    }
+    return true;
+  }
+
+  function walk(n, sels, isChild) {
+    if (!sels.length) { results.push(n); return; }
+    const { sel, combinator } = sels[0];
+    const rest = sels.slice(1);
+    if (matchSingle(n, sel)) {
+      if (!rest.length) results.push(n);
+      else for (const c of (n.children ?? [])) walk(c, rest, rest[0]?.combinator === '>');
+    }
+    // descendant: recurse into children even if this node didn't match
+    if (!isChild) {
+      for (const c of (n.children ?? [])) walk(c, sels, false);
+    }
+  }
+
+  walk(node, parts, false);
+  return results;
+}
+
+function splitSelectorParts(selector) {
+  // returns [{ sel: string, combinator: '>'|' ' }]
+  const parts = [];
+  let i = 0;
+  let current = '';
+  while (i <= selector.length) {
+    const c = selector[i];
+    if (i === selector.length || (isWS(c) && selector[i - 1] !== ']')) {
+      // look ahead for >
+      while (i < selector.length && isWS(selector[i])) i++;
+      const comb = selector[i] === '>' ? '>' : ' ';
+      if (comb === '>') i++;
+      while (i < selector.length && isWS(selector[i])) i++;
+      if (current.trim()) parts.push({ sel: current.trim(), combinator: comb });
+      current = '';
+    } else {
+      current += c;
+      i++;
+    }
+  }
+  return parts;
+}
+
+// ─── JSON (extended) ──────────────────────────────────────────────────────────
+
+function jsonParse(input, opts = {}) {
+  const { dates = false, bigints = false } = opts;
+  return JSON.parse(input, (key, val) => {
+    if (dates && typeof val === 'string' && isDateString(val)) return new Date(val);
+    if (bigints && typeof val === 'string' && isBigIntString(val)) { try { return BigInt(val); } catch {} }
+    return val;
+  });
+}
+
+function jsonStringify(val, opts = {}) {
+  const { pretty = false, sorted = false, indent = 2 } = opts;
+  const replacer = sorted
+    ? (key, v) => (v && typeof v === 'object' && !Array.isArray(v)
+        ? Object.fromEntries(Object.entries(v).sort(([a], [b]) => a.localeCompare(b)))
+        : v)
+    : undefined;
+  return JSON.stringify(val, replacer, pretty ? indent : undefined);
+}
+
+function jsonMerge(base, ...patches) {
+  const out = Array.isArray(base) ? [...base] : { ...base };
+  for (const patch of patches) {
+    for (const [k, v] of Object.entries(patch ?? {})) {
+      if (v && typeof v === 'object' && !Array.isArray(v) && out[k] && typeof out[k] === 'object') {
+        out[k] = jsonMerge(out[k], v);
+      } else {
+        out[k] = v;
+      }
+    }
+  }
+  return out;
+}
+
+function jsonDiff(a, b, path = '') {
+  const added = {}, removed = {}, changed = {};
+  const allKeys = new Set([...Object.keys(a ?? {}), ...Object.keys(b ?? {})]);
+  for (const k of allKeys) {
+    const full = path ? `${path}.${k}` : k;
+    if (!(k in (a ?? {}))) { added[full] = b[k]; continue; }
+    if (!(k in (b ?? {}))) { removed[full] = a[k]; continue; }
+    if (typeof a[k] === 'object' && typeof b[k] === 'object' && a[k] !== null && b[k] !== null) {
+      const sub = jsonDiff(a[k], b[k], full);
+      Object.assign(added, sub.added); Object.assign(removed, sub.removed); Object.assign(changed, sub.changed);
+    } else if (a[k] !== b[k]) {
+      changed[full] = { from: a[k], to: b[k] };
+    }
+  }
+  return { added, removed, changed };
+}
+
+// jsonPath: manual JSONPath-lite query ($.a.b, $[0], $.*, $..key)
+function jsonPath(obj, expr) {
+  // tokenize the path manually instead of regex replace
+  const tokens = tokenizeJsonPath(expr);
+
+  function traverse(node, toks) {
+    if (!toks.length) return [node];
+    const head = toks[0];
+    const rest = toks.slice(1);
+
+    if (head === '$') return traverse(node, rest);
+
+    if (head === '*') {
+      const vals = Array.isArray(node) ? node : Object.values(node ?? {});
+      return vals.flatMap(v => traverse(v, rest));
+    }
+
+    if (head === '..') {
+      const all = [];
+      function dig(n) {
+        all.push(n);
+        if (Array.isArray(n)) n.forEach(dig);
+        else if (n && typeof n === 'object') Object.values(n).forEach(dig);
+      }
+      dig(node);
+      return all.flatMap(n => traverse(n, rest));
+    }
+
+    const child = Array.isArray(node) ? node[parseInt(head, 10)] : (node ?? {})[head];
+    return child !== undefined ? traverse(child, rest) : [];
+  }
+
+  const result = traverse(obj, tokens);
+  return result.length === 1 ? result[0] : result;
+}
+
+function tokenizeJsonPath(expr) {
+  // parse $.a.b[0].c or $..key into tokens without regex
+  const tokens = [];
+  let i = 0;
+  while (i < expr.length) {
+    if (expr[i] === '$') { tokens.push('$'); i++; }
+    else if (expr[i] === '.' && expr[i + 1] === '.') { tokens.push('..'); i += 2; }
+    else if (expr[i] === '.') {
+      i++;
+      // collect identifier
+      let name = '';
+      while (i < expr.length && expr[i] !== '.' && expr[i] !== '[') name += expr[i++];
+      if (name) tokens.push(name);
+    }
+    else if (expr[i] === '[') {
+      i++;
+      let content = '';
+      while (i < expr.length && expr[i] !== ']') content += expr[i++];
+      i++; // skip ]
+      // strip quotes if any
+      const q = content[0];
+      if ((q === '"' || q === "'") && content[content.length - 1] === q) content = content.slice(1, -1);
+      tokens.push(content);
+    }
+    else {
+      i++; // skip unknown
+    }
+  }
+  return tokens;
+}
+
+// ─── YAML ─────────────────────────────────────────────────────────────────────
+
+function yamlParse(input) {
+  const lines  = splitLines(input);
+  const anchors = {};
+
+  function getIndent(line) {
+    let i = 0;
+    while (i < line.length && line[i] === ' ') i++;
+    return i;
+  }
+
+  function coerce(s) {
+    s = s.trim();
+    if (s === '' || s === 'null' || s === '~') return null;
+    if (s === 'true'  || s === 'yes' || s === 'on')  return true;
+    if (s === 'false' || s === 'no'  || s === 'off') return false;
+
+    // hex: 0x...
+    if (s.length > 2 && s[0] === '0' && (s[1] === 'x' || s[1] === 'X')) {
+      let valid = true;
+      for (let i = 2; i < s.length; i++) {
+        const c = s[i].toLowerCase();
+        if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f'))) { valid = false; break; }
+      }
+      if (valid) return parseInt(s, 16);
+    }
+
+    // octal: 0o...
+    if (s.length > 2 && s[0] === '0' && (s[1] === 'o' || s[1] === 'O')) {
+      let valid = true;
+      for (let i = 2; i < s.length; i++) {
+        if (s[i] < '0' || s[i] > '7') { valid = false; break; }
+      }
+      if (valid) return parseInt(s.slice(2), 8);
+    }
+
+    // integer
+    {
+      let i = 0;
+      if (s[i] === '-') i++;
+      let allDigits = i < s.length;
+      while (i < s.length) { if (s[i] < '0' || s[i] > '9') { allDigits = false; break; } i++; }
+      if (allDigits && s.length > (s[0] === '-' ? 1 : 0)) return parseInt(s, 10);
+    }
+
+    // float / scientific
+    {
+      const n = parseFloat(s);
+      if (!isNaN(n) && isNumericString(s)) return n;
+    }
+
+    // quoted strings
+    const q = s[0];
+    if ((q === '"' || q === "'") && s[s.length - 1] === q) {
+      const inner = s.slice(1, -1);
+      if (q === '"') return unescapeYaml(inner);
+      return inner;
+    }
+
+    return s;
+  }
+
+  function unescapeYaml(s) {
+    let out = '';
+    let i = 0;
+    while (i < s.length) {
+      if (s[i] === '\\') {
+        i++;
+        out += escSeq(s[i++]);
+      } else out += s[i++];
+    }
+    return out;
+  }
+
+  function isNumericString(s) {
+    // check if string looks like a float/sci notation without regex
+    let i = 0;
+    if (s[i] === '-') i++;
+    let hasDot = false, hasE = false, hasDigit = false;
+    while (i < s.length) {
+      const c = s[i];
+      if (c >= '0' && c <= '9') { hasDigit = true; i++; }
+      else if (c === '.' && !hasDot && !hasE) { hasDot = true; i++; }
+      else if ((c === 'e' || c === 'E') && !hasE && hasDigit) {
+        hasE = true; i++;
+        if (s[i] === '+' || s[i] === '-') i++;
+      }
+      else return false;
+    }
+    return hasDigit;
+  }
+
+  function parseBlock(startLine, baseIndent) {
+    let i = startLine;
+
+    function peekLine() {
+      while (i < lines.length) {
+        const l = lines[i];
+        const t = l.trim();
+        if (t === '' || t[0] === '#') { i++; continue; }
+        return l;
+      }
+      return null;
+    }
+
+    const first = peekLine();
+    if (first === null) return [null, i];
+    const ind = getIndent(first);
+    if (ind < baseIndent) return [null, i];
+
+    const trimFirst = first.trim();
+
+    // sequence
+    if (trimFirst[0] === '-' && (trimFirst[1] === ' ' || trimFirst.length === 1)) {
+      const arr = [];
+      while (i < lines.length) {
+        const l = peekLine();
+        if (l === null || getIndent(l) < ind) break;
+        if (l.trim()[0] !== '-') break;
+        i++;
+        const content = l.trim().slice(1).trim();
+        if (content === '' || content[0] === '#') {
+          const [val, ni] = parseBlock(i, ind + 2);
+          arr.push(val); i = ni;
+        } else if (content.includes(': ') || content[content.length - 1] === ':') {
+          const [val, ni] = parseBlock(i - 1, ind + 2);
+          arr.push(val); i = ni;
+        } else {
+          arr.push(coerce(content));
+        }
+      }
+      return [arr, i];
+    }
+
+    // mapping: line contains ': ' or ends with ':'
+    if (trimFirst.includes(': ') || trimFirst[trimFirst.length - 1] === ':') {
+      const obj = {};
+      while (i < lines.length) {
+        const l = peekLine();
+        if (l === null || getIndent(l) < ind) break;
+        const lt = l.trim();
+        // check if it looks like a key
+        const col = findMappingColon(lt);
+        if (col === -1) break;
+        i++;
+        let key = lt.slice(0, col).trim();
+        let val = lt.slice(col + 1).trim();
+
+        // anchor definition
+        let anchorName = null;
+        if (val[0] === '&') {
+          let ai = 1;
+          while (ai < val.length && !isWS(val[ai])) ai++;
+          anchorName = val.slice(1, ai);
+          val = val.slice(ai).trim();
+        }
+
+        // alias
+        if (val[0] === '*') {
+          const alias = val.slice(1).trim();
+          obj[key] = anchors[alias] ?? null;
+          continue;
+        }
+
+        // block scalar
+        if (val === '|' || val === '>') {
+          const fold = val === '>';
+          const blockLines = [];
+          const blockInd = ind + 2;
+          while (i < lines.length && (lines[i].trim() === '' || getIndent(lines[i]) >= blockInd)) {
+            blockLines.push(lines[i].slice(blockInd));
+            i++;
+          }
+          const text = fold
+            ? blockLines.join(' ').trimEnd()
+            : blockLines.join('\n').trimEnd() + '\n';
+          obj[key] = text;
+          if (anchorName) anchors[anchorName] = obj[key];
+          continue;
+        }
+
+        if (val === '' || val[0] === '#') {
+          const [child, ni] = parseBlock(i, ind + 2);
+          obj[key] = child; i = ni;
+        } else {
+          obj[key] = coerce(val);
+        }
+
+        if (anchorName) anchors[anchorName] = obj[key];
+      }
+      return [obj, i];
+    }
+
+    // scalar fallback
+    i++;
+    return [coerce(trimFirst), i];
+  }
+
+  function findMappingColon(line) {
+    // find first ':' that is followed by space or end-of-line, not inside quotes
+    let inQ = false, q = '';
+    for (let i = 0; i < line.length; i++) {
+      const c = line[i];
+      if (inQ) { if (c === q) inQ = false; }
+      else if (c === '"' || c === "'") { inQ = true; q = c; }
+      else if (c === ':' && (i + 1 >= line.length || isWS(line[i + 1]))) return i;
+    }
+    return -1;
+  }
+
+  const [result] = parseBlock(0, 0);
+  return result;
+}
+
+function yamlStringify(val, indent = 0, opts = {}) {
+  const step = opts.indent ?? 2;
+  const pad  = ' '.repeat(indent);
+  const next = ' '.repeat(indent + step);
+
+  if (val === null || val === undefined) return 'null';
+  if (typeof val === 'boolean') return val ? 'true' : 'false';
+  if (typeof val === 'number')  return String(val);
+  if (typeof val === 'string') {
+    if (needsYamlQuote(val)) return `"${val.split('\n').join('\\n').split('"').join('\\"')}"`;
+    return val;
+  }
+  if (Array.isArray(val)) {
+    if (!val.length) return '[]';
+    return val.map(v => {
+      const s = yamlStringify(v, indent + step, opts);
+      return `${pad}- ${s.trimStart()}`;
+    }).join('\n');
+  }
+  if (typeof val === 'object') {
+    const entries = Object.entries(val);
+    if (!entries.length) return '{}';
+    return entries.map(([k, v]) => {
+      const s = yamlStringify(v, indent + step, opts);
+      if (typeof v === 'object' && v !== null && !Array.isArray(v) && Object.keys(v).length) {
+        return `${pad}${k}:\n${s}`;
+      }
+      if (Array.isArray(v) && v.length) return `${pad}${k}:\n${s}`;
+      return `${pad}${k}: ${s.trimStart()}`;
+    }).join('\n');
+  }
+  return String(val);
+}
+
+function needsYamlQuote(s) {
+  // check for chars that require quoting in YAML
+  const special = ':#[]{}*&!|>\'",';
+  if (s !== s.trim()) return true;
+  for (let i = 0; i < s.length; i++) {
+    if (special.includes(s[i]) || s[i] === '\n') return true;
+  }
+  return false;
+}
+
+// ─── HJSON ────────────────────────────────────────────────────────────────────
+// Manual AST parse — no regex strip. Handles comments, trailing commas,
+// unquoted keys, multiline ''', bare string values.
+
+function hjsonParse(input) {
+  let pos = 0;
+  const s = input;
+
+  function skipWS() {
+    while (pos < s.length && isWS(s[pos])) pos++;
+  }
+
+  function skipLineComment() {
+    // skip to end of line
+    while (pos < s.length && s[pos] !== '\n') pos++;
+  }
+
+  function skipBlockComment() {
+    // already consumed /*
+    while (pos < s.length) {
+      if (s[pos] === '*' && s[pos + 1] === '/') { pos += 2; return; }
+      pos++;
+    }
+  }
+
+  function skipWsAndComments() {
+    while (pos < s.length) {
+      if (isWS(s[pos])) { pos++; continue; }
+      if (s[pos] === '/' && s[pos + 1] === '/') { pos += 2; skipLineComment(); continue; }
+      if (s[pos] === '/' && s[pos + 1] === '*') { pos += 2; skipBlockComment(); continue; }
+      break;
+    }
+  }
+
+  function parseString() {
+    const q = s[pos++]; // " or '
+    let out = '';
+    while (pos < s.length && s[pos] !== q) {
+      if (s[pos] === '\\') { pos++; out += escSeq(s[pos++]); }
+      else out += s[pos++];
+    }
+    pos++; // closing quote
+    return out;
+  }
+
+  function parseMultilineString() {
+    // consume '''
+    pos += 3;
+    let raw = '';
+    while (pos < s.length) {
+      if (s[pos] === "'" && s[pos + 1] === "'" && s[pos + 2] === "'") { pos += 3; break; }
+      raw += s[pos++];
+    }
+    // strip leading newline per HJSON spec
+    if (raw[0] === '\n') raw = raw.slice(1);
+    return raw;
+  }
+
+  function parseKey() {
+    skipWsAndComments();
+    // quoted key
+    if (s[pos] === '"' || s[pos] === "'") return parseString();
+    // unquoted key: read until colon or whitespace
+    let key = '';
+    while (pos < s.length && s[pos] !== ':' && s[pos] !== '\n' && !isWS(s[pos])) key += s[pos++];
+    return key;
+  }
+
+  function parseBareString() {
+    // read to end of line (minus inline comments)
+    let raw = '';
+    while (pos < s.length && s[pos] !== '\n' && s[pos] !== ',' && s[pos] !== '}' && s[pos] !== ']') {
+      if (s[pos] === '/' && (s[pos + 1] === '/' || s[pos + 1] === '*')) break;
+      raw += s[pos++];
+    }
+    return raw.trim();
+  }
+
+  function parseValue() {
+    skipWsAndComments();
+    const c = s[pos];
+
+    // multiline string
+    if (c === "'" && s[pos + 1] === "'" && s[pos + 2] === "'") return parseMultilineString();
+
+    // quoted string
+    if (c === '"' || c === "'") return parseString();
+
+    // array
+    if (c === '[') return parseArray();
+
+    // object
+    if (c === '{') return parseObject();
+
+    // true / false / null / number
+    // read a "word" or number
+    let word = '';
+    const start = pos;
+    while (pos < s.length && s[pos] !== ',' && s[pos] !== '\n' && s[pos] !== '}' && s[pos] !== ']') {
+      if (s[pos] === '/' && (s[pos + 1] === '/' || s[pos + 1] === '*')) break;
+      word += s[pos++];
+    }
+    word = word.trim();
+
+    if (word === 'true')  return true;
+    if (word === 'false') return false;
+    if (word === 'null')  return null;
+    const n = Number(word);
+    if (word !== '' && !isNaN(n)) return n;
+
+    // bare string
+    return word;
+  }
+
+  function parseArray() {
+    pos++; // skip [
+    const arr = [];
+    while (true) {
+      skipWsAndComments();
+      if (pos >= s.length || s[pos] === ']') { pos++; break; }
+      if (s[pos] === ',') { pos++; continue; } // skip comma / trailing comma
+      arr.push(parseValue());
+    }
+    return arr;
+  }
+
+  function parseObject() {
+    pos++; // skip {
+    const obj = {};
+    while (true) {
+      skipWsAndComments();
+      if (pos >= s.length || s[pos] === '}') { pos++; break; }
+      if (s[pos] === ',') { pos++; continue; }
+      const key = parseKey();
+      skipWsAndComments();
+      if (s[pos] === ':') pos++; // skip :
+      skipWsAndComments();
+      obj[key] = parseValue();
+    }
+    return obj;
+  }
+
+  skipWsAndComments();
+  return parseValue();
+}
+
+function hjsonStringify(val, indent = 2) {
+  return JSON.stringify(val, null, indent);
+}
+
+// ─── NDJSON ───────────────────────────────────────────────────────────────────
+
+function ndjsonParse(input) {
+  return splitLines(input)
+    .map(l => l.trim())
+    .filter(Boolean)
+    .map((l, i) => {
+      try { return JSON.parse(l); }
+      catch (e) { throw new Error(`NDJSON line ${i + 1}: ${e.message}`); }
+    });
+}
+
+function ndjsonStringify(arr) {
+  return arr.map(v => JSON.stringify(v)).join('\n');
+}
+
+// ─── DOTENV ───────────────────────────────────────────────────────────────────
+
+function dotenvParse(input, opts = {}) {
+  const expand = opts.expand ?? true;
+  const lines  = splitLines(input);
+  const env    = {};
+
+  for (let raw of lines) {
+    raw = raw.trim();
+    if (!raw || raw[0] === '#') continue;
+    if (raw.startsWith('export ')) raw = raw.slice(7).trim();
+
+    const eq = raw.indexOf('=');
+    if (eq === -1) continue;
+
+    const key = raw.slice(0, eq).trim();
+    let val   = raw.slice(eq + 1).trim();
+
+    const q = val[0];
+    if ((q === '"' || q === "'") && val[val.length - 1] === q) {
+      val = val.slice(1, -1);
+      if (q === '"') {
+        // manual escape expansion
+        let out = '';
+        let i = 0;
+        while (i < val.length) {
+          if (val[i] === '\\') { i++; out += escSeq(val[i++]); }
+          else out += val[i++];
+        }
+        val = out;
+      }
+    } else {
+      // strip inline comment
+      const ci = val.indexOf(' #');
+      if (ci !== -1) val = val.slice(0, ci).trim();
+    }
+
+    env[key] = val;
+  }
+
+  if (expand) {
+    for (const key of Object.keys(env)) {
+      env[key] = expandDotenvVars(env[key], env);
+    }
+  }
+
+  return env;
+}
+
+function expandDotenvVars(val, env) {
+  let out = '';
+  let i = 0;
+  while (i < val.length) {
+    if (val[i] === '$') {
+      i++;
+      if (val[i] === '{') {
+        i++; // skip {
+        let name = '';
+        while (i < val.length && val[i] !== '}') name += val[i++];
+        i++; // skip }
+        out += env[name] ?? (typeof process !== 'undefined' ? process?.env?.[name] : undefined) ?? '';
+      } else {
+        let name = '';
+        while (i < val.length && (isAlpha(val[i]) || isDigit(val[i]) || val[i] === '_')) name += val[i++];
+        out += env[name] ?? (typeof process !== 'undefined' ? process?.env?.[name] : undefined) ?? '';
+      }
+    } else {
+      out += val[i++];
+    }
+  }
+  return out;
+}
+
+function dotenvStringify(obj) {
+  return Object.entries(obj).map(([k, v]) => {
+    const val = String(v);
+    if (needsDotenvQuote(val)) {
+      let escaped = '';
+      for (let i = 0; i < val.length; i++) {
+        if (val[i] === '\n') escaped += '\\n';
+        else if (val[i] === '"') escaped += '\\"';
+        else escaped += val[i];
+      }
+      return `${k}="${escaped}"`;
+    }
+    return `${k}=${val}`;
+  }).join('\n');
+}
+
+function needsDotenvQuote(s) {
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (isWS(c) || c === '#' || c === '"' || c === "'" || c === '\\' || c === '\n') return true;
+  }
+  return false;
+}
+
+// ─── SHARED UTILITIES ─────────────────────────────────────────────────────────
+
+function splitLines(input) {
+  // normalize \r\n and \r to \n then split
+  const out = [];
+  let i = 0, start = 0;
+  while (i < input.length) {
+    if (input[i] === '\r') {
+      out.push(input.slice(start, i));
+      if (input[i + 1] === '\n') i++;
+      i++;
+      start = i;
+    } else if (input[i] === '\n') {
+      out.push(input.slice(start, i));
+      i++;
+      start = i;
+    } else {
+      i++;
+    }
+  }
+  out.push(input.slice(start));
+  return out;
+}
+
+function isWS(c)    { return c === ' ' || c === '\t' || c === '\r' || c === '\n'; }
+function isDigit(c) { return c >= '0' && c <= '9'; }
+function isAlpha(c) { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); }
+
+function indexOfStr(haystack, needle, start = 0) {
+  for (let i = start; i <= haystack.length - needle.length; i++) {
+    let match = true;
+    for (let j = 0; j < needle.length; j++) {
+      if (haystack[i + j] !== needle[j]) { match = false; break; }
+    }
+    if (match) return i;
+  }
+  return -1;
+}
+
+function escSeq(c) {
+  if (c === 'n')  return '\n';
+  if (c === 't')  return '\t';
+  if (c === 'r')  return '\r';
+  if (c === '"')  return '"';
+  if (c === "'")  return "'";
+  if (c === '\\') return '\\';
+  if (c === '0')  return '\0';
+  return c;
+}
+
+function isDateString(s) {
+  // YYYY-MM-DDTHH:MM check without regex
+  if (s.length < 10) return false;
+  return s[4] === '-' && s[7] === '-' && s[10] === 'T';
+}
+
+function isBigIntString(s) {
+  if (s.length < 16) return false;
+  for (let i = 0; i < s.length; i++) if (!isDigit(s[i])) return false;
+  return true;
+}
+
+// ─── EXPORTS ──────────────────────────────────────────────────────────────────
+
+module.exports = {
+  // ── CSV
+  csvParse,
+  csvStringify,
+
+  // ── TOML
+  tomlParse,
+  tomlStringify,
+
+  // ── INI
+  iniParse,
+  iniStringify,
+
+  // ── Query strings
+  qsParse,
+  qsStringify,
+
+  // ── XML
+  xmlParse,
+  xmlStringify,
+  xmlQuery,
+
+  // ── JSON extended
+  jsonParse,
+  jsonStringify,
+  jsonMerge,
+  jsonDiff,
+  jsonPath,
+
+  // ── YAML
+  yamlParse,
+  yamlStringify,
+
+  // ── HJSON
+  hjsonParse,
+  hjsonStringify,
+
+  // ── NDJSON
+  ndjsonParse,
+  ndjsonStringify,
+
+  // ── dotenv
+  dotenvParse,
+  dotenvStringify,
+
+  // ── Tokenizer / lexer helpers
+  tokenize,
+  TokenStream,
+
+  // ── Expression resolver (extensible)
+  ExprResolver,
+  parseExpr,
+
+  // ── kitdef namespace (backward compat)
+  kitdef: {
+    csv:   { parse: csvParse,   stringify: csvStringify   },
+    toml:  { parse: tomlParse,  stringify: tomlStringify  },
+    ini:   { parse: iniParse,   stringify: iniStringify   },
+    qs:    { parse: qsParse,    stringify: qsStringify    },
+    xml:   { parse: xmlParse,   stringify: xmlStringify, query: xmlQuery },
+    json:  { parse: jsonParse,  stringify: jsonStringify,
+             merge: jsonMerge,  diff: jsonDiff, path: jsonPath },
+    yaml:  { parse: yamlParse,  stringify: yamlStringify  },
+    hjson: { parse: hjsonParse, stringify: hjsonStringify },
+    ndjson:{ parse: ndjsonParse,stringify: ndjsonStringify},
+    dotenv:{ parse: dotenvParse,stringify: dotenvStringify},
+    tokenize,
+    TokenStream,
+    ExprResolver,
+    parseExpr,
+  }
+};