@yesiree/jsonq 1.0.0

package/dist/index.mjs

@@ -0,0 +1,390 @@
+const METHODS = ['map', 'filter', 'join', 'sort', 'unique', 'first', 'last', 'count', 'sum', 'avg', 'min', 'max'];
+
+function query(expression, data) {
+  const tokens = tokenizePipeline(expression);
+  return evaluatePipeline(tokens, data);
+}
+
+function tokenizePipeline(expr) {
+  const tokens = [];
+  let i = 0;
+  
+  while (i < expr.length) {
+    while (i < expr.length && /\s/.test(expr[i])) i++;
+    if (i >= expr.length) break;
+    
+    if (expr[i] === '$') {
+      tokens.push({ type: 'root' });
+      i++;
+      continue;
+    }
+    
+    if (expr[i] === '.') {
+      i++;
+      let name = '';
+      while (i < expr.length && /[a-zA-Z0-9_]/.test(expr[i])) {
+        name += expr[i++];
+      }
+      
+      while (i < expr.length && /\s/.test(expr[i])) i++;
+      if (i < expr.length && expr[i] === '(' && METHODS.includes(name)) {
+        i++;
+        let depth = 1;
+        let params = '';
+        while (i < expr.length && depth > 0) {
+          if (expr[i] === '(') depth++;
+          else if (expr[i] === ')') depth--;
+          if (depth > 0) params += expr[i];
+          i++;
+        }
+        tokens.push({ type: 'method', method: name, params });
+      } else {
+        tokens.push({ type: 'prop', name });
+      }
+      continue;
+    }
+    
+    if (expr[i] === '[') {
+      i++;
+      let num = '';
+      while (i < expr.length && /\d/.test(expr[i])) {
+        num += expr[i++];
+      }
+      i++;
+      tokens.push({ type: 'index', value: parseInt(num) });
+      continue;
+    }
+    
+    let methodMatch = false;
+    for (const method of METHODS) {
+      if (expr.substr(i, method.length) === method) {
+        const afterMethod = i + method.length;
+        let j = afterMethod;
+        while (j < expr.length && /\s/.test(expr[j])) j++;
+        if (j < expr.length && expr[j] === '(') {
+          i = j + 1;
+          let depth = 1;
+          let params = '';
+          while (i < expr.length && depth > 0) {
+            if (expr[i] === '(') depth++;
+            else if (expr[i] === ')') depth--;
+            if (depth > 0) params += expr[i];
+            i++;
+          }
+          tokens.push({ type: 'method', method, params });
+          methodMatch = true;
+          break;
+        }
+      }
+    }
+    if (methodMatch) continue;
+    
+    i++;
+  }
+  
+  return tokens;
+}
+
+function evaluatePipeline(tokens, data) {
+  let result = data;
+
+  for (const token of tokens) {
+    switch (token.type) {
+      case 'root':
+        result = data;
+        break;
+      case 'prop':
+        result = result?.[token.name];
+        break;
+      case 'index':
+        result = result?.[token.value];
+        break;
+      case 'method':
+        result = applyMethod(token.method, token.params, result, data);
+        break;
+    }
+  }
+
+  return result;
+}
+
+function applyMethod(method, params, acc, data, bindings = {}) {
+  switch (method) {
+    case 'map':
+      return acc.map((item, index) => evalExpr(params, item, index, data, { ...bindings, $array: acc }));
+    case 'filter':
+      return acc.filter((item, index) => evalExpr(params, item, index, data, { ...bindings, $array: acc }));
+    case 'join':
+      return acc.join(evalLiteral(params));
+    case 'sort': {
+      const descending = params.trim().startsWith('-');
+      const sortExpr = descending ? params.trim().slice(1) : params;
+      return [...acc].sort((a, b) => {
+        const av = evalExpr(sortExpr, a, 0, data, { ...bindings, $array: acc });
+        const bv = evalExpr(sortExpr, b, 0, data, { ...bindings, $array: acc });
+        const comparison = av < bv ? -1 : av > bv ? 1 : 0;
+        return descending ? -comparison : comparison;
+      });
+    }
+    case 'unique':
+      return [...new Set(acc.map((item, index) => evalExpr(params || '$item', item, index, data, { ...bindings, $array: acc })))];
+    case 'first':
+      return acc[0];
+    case 'last':
+      return acc[acc.length - 1];
+    case 'count':
+      return acc.length;
+    case 'sum':
+      return acc.reduce((a, item, index) => a + evalExpr(params || '$item', item, index, data, { ...bindings, $array: acc }), 0);
+    case 'avg':
+      return acc.reduce((a, item, index) => a + evalExpr(params || '$item', item, index, data, { ...bindings, $array: acc }), 0) / acc.length;
+    case 'min':
+      return Math.min(...acc.map((item, index) => evalExpr(params || '$item', item, index, data, { ...bindings, $array: acc })));
+    case 'max':
+      return Math.max(...acc.map((item, index) => evalExpr(params || '$item', item, index, data, { ...bindings, $array: acc })));
+    default:
+      throw new Error(`Unknown method: ${method}`);
+  }
+}
+
+function evalLiteral(expr) {
+  const str = expr.match(/^["'](.*)["']$/);
+  if (str) return str[1];
+  if (!isNaN(expr)) return Number(expr);
+  if (expr === 'true') return true;
+  if (expr === 'false') return false;
+  if (expr === 'null') return null;
+  if (expr === 'undefined') return undefined;
+  throw new Error(`Invalid literal: ${expr}`);
+}
+
+function evalExpr(expr, $item, $index, $data, parentBindings = {}) {
+  expr = expr.trim();
+  
+  const arrowMatch = expr.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*=>\s*(.+)$/);
+  if (arrowMatch) {
+    const [, paramName, body] = arrowMatch;
+    const tokens = tokenizeExpr(body);
+    const parsed = parseExpr(tokens);
+    const bindings = { ...parentBindings, [paramName]: $item };
+    return evalNode(parsed, $item, $index, $data, bindings);
+  }
+  
+  const tokens = tokenizeExpr(expr);
+  const parsed = parseExpr(tokens);
+  return evalNode(parsed, $item, $index, $data, parentBindings);
+}
+
+function tokenizeExpr(expr) {
+  const tokens = [];
+  const regex = /(\$array|\$item|\$index|\$(?![a-zA-Z_])|\$[a-zA-Z_][a-zA-Z0-9_]*)|(_)|(@\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d{3})?(?:Z|[+-]\d{2}:?\d{2})?)?)|(-?\d+\.?\d*(?:e[+-]?\d+)?)|("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')|(&&|\|\||[!=<>]=?|=>|[+\-*/%!])|(\.)|(\[)|(\])|(\()|(\))|(\btrue\b|\bfalse\b|\bnull\b|\bundefined\b)|([a-zA-Z_][a-zA-Z0-9_]*)/g;
+  let match;
+  while ((match = regex.exec(expr)) !== null) {
+    const [full, variable, underscore, date, num, str, op, dot, lbracket, rbracket, lparen, rparen, keyword, ident] = match;
+    if (variable) tokens.push({ type: 'var', value: variable, pos: match.index });
+    else if (underscore) tokens.push({ type: 'var', value: '_', pos: match.index });
+    else if (date) tokens.push({ type: 'date', value: date.slice(1), pos: match.index });
+    else if (num) tokens.push({ type: 'num', value: Number(num), pos: match.index });
+    else if (str) tokens.push({ type: 'str', value: str.slice(1, -1), pos: match.index });
+    else if (op) tokens.push({ type: 'op', value: op, pos: match.index });
+    else if (dot) tokens.push({ type: 'dot', pos: match.index });
+    else if (lbracket) tokens.push({ type: 'lbracket', pos: match.index });
+    else if (rbracket) tokens.push({ type: 'rbracket', pos: match.index });
+    else if (lparen) tokens.push({ type: 'lparen', pos: match.index });
+    else if (rparen) tokens.push({ type: 'rparen', pos: match.index });
+    else if (keyword) tokens.push({ type: 'keyword', value: keyword, pos: match.index });
+    else if (ident) tokens.push({ type: 'ident', value: ident, pos: match.index });
+  }
+  tokens.expr = expr;
+  return tokens;
+}
+
+function parseExpr(tokens) {
+  let pos = 0;
+
+  function parseOr() {
+    let left = parseAnd();
+    while (tokens[pos]?.type === 'op' && tokens[pos].value === '||') {
+      pos++;
+      left = { type: 'binary', op: '||', left, right: parseAnd() };
+    }
+    return left;
+  }
+
+  function parseAnd() {
+    let left = parseComparison();
+    while (tokens[pos]?.type === 'op' && tokens[pos].value === '&&') {
+      pos++;
+      left = { type: 'binary', op: '&&', left, right: parseComparison() };
+    }
+    return left;
+  }
+
+  function parseComparison() {
+    let left = parseAddSub();
+    while (tokens[pos]?.type === 'op' && /^([!=<>]=?|==)$/.test(tokens[pos].value) && tokens[pos].value !== '!') {
+      const op = tokens[pos++].value;
+      left = { type: 'binary', op, left, right: parseAddSub() };
+    }
+    return left;
+  }
+
+  function parseAddSub() {
+    let left = parseMulDiv();
+    while (tokens[pos]?.type === 'op' && /^[+\-]$/.test(tokens[pos].value)) {
+      const op = tokens[pos++].value;
+      left = { type: 'binary', op, left, right: parseMulDiv() };
+    }
+    return left;
+  }
+
+  function parseMulDiv() {
+    let left = parseUnary();
+    while (tokens[pos]?.type === 'op' && /^[*/%]$/.test(tokens[pos].value)) {
+      const op = tokens[pos++].value;
+      left = { type: 'binary', op, left, right: parseUnary() };
+    }
+    return left;
+  }
+
+  function parseUnary() {
+    if (tokens[pos]?.type === 'op' && (tokens[pos].value === '!' || tokens[pos].value === '-')) {
+      const op = tokens[pos++].value;
+      return { type: 'unary', op, arg: parseUnary() };
+    }
+    return parseAccess();
+  }
+
+  function parseAccess() {
+    let node = parsePrimary();
+    while (tokens[pos]?.type === 'dot' || tokens[pos]?.type === 'lbracket') {
+      if (tokens[pos].type === 'dot') {
+        pos++;
+        const prop = tokens[pos++];
+        if (tokens[pos]?.type === 'lparen' && METHODS.includes(prop.value)) {
+          const openParenPos = pos;
+          pos++;
+          let depth = 1;
+          let paramStart = pos;
+          while (depth > 0 && pos < tokens.length) {
+            if (tokens[pos].type === 'lparen') depth++;
+            else if (tokens[pos].type === 'rparen') depth--;
+            if (depth > 0) pos++;
+          }
+          const paramEnd = pos;
+          pos++;
+          
+          const paramExpr = tokens.expr.slice(
+            tokens[paramStart]?.pos || tokens[openParenPos].pos + 1,
+            tokens[paramEnd]?.pos || tokens[paramEnd - 1]?.pos + 1
+          );
+          
+          node = { type: 'methodCall', obj: node, method: prop.value, params: paramExpr };
+        } else {
+          node = { type: 'access', obj: node, prop: prop.value };
+        }
+      } else {
+        pos++;
+        const index = parseOr();
+        pos++;
+        node = { type: 'index', obj: node, index };
+      }
+    }
+    return node;
+  }
+
+  function parsePrimary() {
+    const t = tokens[pos++];
+    if (!t) throw new Error('Unexpected end of expression');
+    if (t.type === 'var') return { type: 'var', name: t.value };
+    if (t.type === 'num') return { type: 'literal', value: t.value };
+    if (t.type === 'str') return { type: 'literal', value: t.value };
+    if (t.type === 'date') return { type: 'literal', value: new Date(t.value) };
+    if (t.type === 'keyword') {
+      if (t.value === 'true') return { type: 'literal', value: true };
+      if (t.value === 'false') return { type: 'literal', value: false };
+      if (t.value === 'null') return { type: 'literal', value: null };
+      if (t.value === 'undefined') return { type: 'literal', value: undefined };
+    }
+    if (t.type === 'ident') return { type: 'ident', name: t.value };
+    if (t.type === 'lparen') {
+      const expr = parseOr();
+      pos++;
+      return expr;
+    }
+    throw new Error(`Unexpected token: ${JSON.stringify(t)}`);
+  }
+
+  return parseOr();
+}
+
+function evalNode(node, $item, $index, $data, bindings = {}) {
+  switch (node.type) {
+    case 'var':
+      if (node.name === '_') return $item;
+      if (node.name === '$item') return $item;
+      if (node.name === '$index') return $index;
+      if (node.name === '$') return $data;
+      if (node.name === '$array') return bindings.$array;
+      if (node.name in bindings) return bindings[node.name];
+      throw new Error(`Unknown variable: ${node.name}`);
+    case 'literal':
+      return node.value;
+    case 'ident':
+      if (node.name in bindings) return bindings[node.name];
+      if ($item && typeof $item === 'object' && node.name in $item) return $item[node.name];
+      throw new Error(`Unknown identifier: ${node.name}`);
+    case 'access': {
+      const obj = evalNode(node.obj, $item, $index, $data, bindings);
+      return obj?.[node.prop];
+    }
+    case 'index': {
+      const arr = evalNode(node.obj, $item, $index, $data, bindings);
+      const idx = evalNode(node.index, $item, $index, $data, bindings);
+      return arr?.[idx];
+    }
+    case 'methodCall': {
+      const obj = evalNode(node.obj, $item, $index, $data, bindings);
+      if (!obj) return undefined;
+      return applyMethod(node.method, node.params, obj, $data, bindings);
+    }
+    case 'unary': {
+      const arg = evalNode(node.arg, $item, $index, $data, bindings);
+      if (node.op === '!') return !arg;
+      if (node.op === '-') return -arg;
+      break;
+    }
+    case 'binary': {
+      let left = evalNode(node.left, $item, $index, $data, bindings);
+      let right = evalNode(node.right, $item, $index, $data, bindings);
+
+      if (left instanceof Date || right instanceof Date) {
+        if (!(left instanceof Date)) left = new Date(left);
+        if (!(right instanceof Date)) right = new Date(right);
+        left = left.getTime();
+        right = right.getTime();
+      }
+
+      switch (node.op) {
+        case '+': return left + right;
+        case '-': return left - right;
+        case '*': return left * right;
+        case '/': return left / right;
+        case '%': return left % right;
+        case '==': return left == right;
+        case '!=': return left != right;
+        case '<': return left < right;
+        case '>': return left > right;
+        case '<=': return left <= right;
+        case '>=': return left >= right;
+        case '&&': return left && right;
+        case '||': return left || right;
+      }
+      break;
+    }
+    default:
+      throw new Error(`Unknown node type: ${node.type}`);
+  }
+}
+
+export { evaluatePipeline as evaluate, query, tokenizePipeline as tokenize };

package/dist/index.umd.js

@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).JsonQueryPipe={})}(this,function(e){"use strict";const t=["map","filter","join","sort","unique","first","last","count","sum","avg","min","max"];function r(e){const r=[];let n=0;for(;n<e.length;){for(;n<e.length&&/\s/.test(e[n]);)n++;if(n>=e.length)break;if("$"===e[n]){r.push({type:"root"}),n++;continue}if("."===e[n]){n++;let a="";for(;n<e.length&&/[a-zA-Z0-9_]/.test(e[n]);)a+=e[n++];for(;n<e.length&&/\s/.test(e[n]);)n++;if(n<e.length&&"("===e[n]&&t.includes(a)){n++;let t=1,u="";for(;n<e.length&&t>0;)"("===e[n]?t++:")"===e[n]&&t--,t>0&&(u+=e[n]),n++;r.push({type:"method",method:a,params:u})}else r.push({type:"prop",name:a});continue}if("["===e[n]){n++;let t="";for(;n<e.length&&/\d/.test(e[n]);)t+=e[n++];n++,r.push({type:"index",value:parseInt(t)});continue}let a=!1;for(const u of t)if(e.substr(n,u.length)===u){let t=n+u.length;for(;t<e.length&&/\s/.test(e[t]);)t++;if(t<e.length&&"("===e[t]){n=t+1;let o=1,i="";for(;n<e.length&&o>0;)"("===e[n]?o++:")"===e[n]&&o--,o>0&&(i+=e[n]),n++;r.push({type:"method",method:u,params:i}),a=!0;break}}a||n++}return r}function n(e,t){let r=t;for(const n of e)switch(n.type){case"root":r=t;break;case"prop":r=r?.[n.name];break;case"index":r=r?.[n.value];break;case"method":r=a(n.method,n.params,r,t)}return r}function a(e,t,r,n,a={}){switch(e){case"map":return r.map((e,o)=>u(t,e,o,n,{...a,$array:r}));case"filter":return r.filter((e,o)=>u(t,e,o,n,{...a,$array:r}));case"join":return r.join(function(e){const t=e.match(/^["'](.*)["']$/);if(t)return t[1];if(!isNaN(e))return Number(e);if("true"===e)return!0;if("false"===e)return!1;if("null"===e)return null;if("undefined"===e)return;throw new Error(`Invalid literal: ${e}`)}(t));case"sort":{const e=t.trim().startsWith("-"),o=e?t.trim().slice(1):t;return[...r].sort((t,i)=>{const s=u(o,t,0,n,{...a,$array:r}),l=u(o,i,0,n,{...a,$array:r}),p=s<l?-1:s>l?1:0;return e?-p:p})}case"unique":return[...new Set(r.map((e,o)=>u(t||"$item",e,o,n,{...a,$array:r})))];case"first":return r[0];case"last":return r[r.length-1];case"count":return r.length;case"sum":return r.reduce((e,o,i)=>e+u(t||"$item",o,i,n,{...a,$array:r}),0);case"avg":return r.reduce((e,o,i)=>e+u(t||"$item",o,i,n,{...a,$array:r}),0)/r.length;case"min":return Math.min(...r.map((e,o)=>u(t||"$item",e,o,n,{...a,$array:r})));case"max":return Math.max(...r.map((e,o)=>u(t||"$item",e,o,n,{...a,$array:r})));default:throw new Error(`Unknown method: ${e}`)}}function u(e,t,r,n,a={}){const u=(e=e.trim()).match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*=>\s*(.+)$/);if(u){const[,e,l]=u;return s(i(o(l)),t,r,n,{...a,[e]:t})}return s(i(o(e)),t,r,n,a)}function o(e){const t=[],r=/(\$array|\$item|\$index|\$(?![a-zA-Z_])|\$[a-zA-Z_][a-zA-Z0-9_]*)|(_)|(@\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d{3})?(?:Z|[+-]\d{2}:?\d{2})?)?)|(-?\d+\.?\d*(?:e[+-]?\d+)?)|("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')|(&&|\|\||[!=<>]=?|=>|[+\-*/%!])|(\.)|(\[)|(\])|(\()|(\))|(\btrue\b|\bfalse\b|\bnull\b|\bundefined\b)|([a-zA-Z_][a-zA-Z0-9_]*)/g;let n;for(;null!==(n=r.exec(e));){const[e,r,a,u,o,i,s,l,p,f,c,y,d,h]=n;r?t.push({type:"var",value:r,pos:n.index}):a?t.push({type:"var",value:"_",pos:n.index}):u?t.push({type:"date",value:u.slice(1),pos:n.index}):o?t.push({type:"num",value:Number(o),pos:n.index}):i?t.push({type:"str",value:i.slice(1,-1),pos:n.index}):s?t.push({type:"op",value:s,pos:n.index}):l?t.push({type:"dot",pos:n.index}):p?t.push({type:"lbracket",pos:n.index}):f?t.push({type:"rbracket",pos:n.index}):c?t.push({type:"lparen",pos:n.index}):y?t.push({type:"rparen",pos:n.index}):d?t.push({type:"keyword",value:d,pos:n.index}):h&&t.push({type:"ident",value:h,pos:n.index})}return t.expr=e,t}function i(e){let r=0;function n(){let t=a();for(;"op"===e[r]?.type&&"||"===e[r].value;)r++,t={type:"binary",op:"||",left:t,right:a()};return t}function a(){let t=u();for(;"op"===e[r]?.type&&"&&"===e[r].value;)r++,t={type:"binary",op:"&&",left:t,right:u()};return t}function u(){let t=o();for(;"op"===e[r]?.type&&/^([!=<>]=?|==)$/.test(e[r].value)&&"!"!==e[r].value;){t={type:"binary",op:e[r++].value,left:t,right:o()}}return t}function o(){let t=i();for(;"op"===e[r]?.type&&/^[+\-]$/.test(e[r].value);){t={type:"binary",op:e[r++].value,left:t,right:i()}}return t}function i(){let t=s();for(;"op"===e[r]?.type&&/^[*/%]$/.test(e[r].value);){t={type:"binary",op:e[r++].value,left:t,right:s()}}return t}function s(){if("op"===e[r]?.type&&("!"===e[r].value||"-"===e[r].value)){return{type:"unary",op:e[r++].value,arg:s()}}return function(){let a=function(){const t=e[r++];if(!t)throw new Error("Unexpected end of expression");if("var"===t.type)return{type:"var",name:t.value};if("num"===t.type)return{type:"literal",value:t.value};if("str"===t.type)return{type:"literal",value:t.value};if("date"===t.type)return{type:"literal",value:new Date(t.value)};if("keyword"===t.type){if("true"===t.value)return{type:"literal",value:!0};if("false"===t.value)return{type:"literal",value:!1};if("null"===t.value)return{type:"literal",value:null};if("undefined"===t.value)return{type:"literal",value:void 0}}if("ident"===t.type)return{type:"ident",name:t.value};if("lparen"===t.type){const e=n();return r++,e}throw new Error(`Unexpected token: ${JSON.stringify(t)}`)}();for(;"dot"===e[r]?.type||"lbracket"===e[r]?.type;)if("dot"===e[r].type){r++;const n=e[r++];if("lparen"===e[r]?.type&&t.includes(n.value)){const t=r;r++;let u=1,o=r;for(;u>0&&r<e.length;)"lparen"===e[r].type?u++:"rparen"===e[r].type&&u--,u>0&&r++;const i=r;r++;const s=e.expr.slice(e[o]?.pos||e[t].pos+1,e[i]?.pos||e[i-1]?.pos+1);a={type:"methodCall",obj:a,method:n.value,params:s}}else a={type:"access",obj:a,prop:n.value}}else{r++;const e=n();r++,a={type:"index",obj:a,index:e}}return a}()}return n()}function s(e,t,r,n,u={}){switch(e.type){case"var":if("_"===e.name)return t;if("$item"===e.name)return t;if("$index"===e.name)return r;if("$"===e.name)return n;if("$array"===e.name)return u.$array;if(e.name in u)return u[e.name];throw new Error(`Unknown variable: ${e.name}`);case"literal":return e.value;case"ident":if(e.name in u)return u[e.name];if(t&&"object"==typeof t&&e.name in t)return t[e.name];throw new Error(`Unknown identifier: ${e.name}`);case"access":{const a=s(e.obj,t,r,n,u);return a?.[e.prop]}case"index":{const a=s(e.obj,t,r,n,u),o=s(e.index,t,r,n,u);return a?.[o]}case"methodCall":{const o=s(e.obj,t,r,n,u);if(!o)return;return a(e.method,e.params,o,n,u)}case"unary":{const a=s(e.arg,t,r,n,u);if("!"===e.op)return!a;if("-"===e.op)return-a;break}case"binary":{let a=s(e.left,t,r,n,u),o=s(e.right,t,r,n,u);switch((a instanceof Date||o instanceof Date)&&(a instanceof Date||(a=new Date(a)),o instanceof Date||(o=new Date(o)),a=a.getTime(),o=o.getTime()),e.op){case"+":return a+o;case"-":return a-o;case"*":return a*o;case"/":return a/o;case"%":return a%o;case"==":return a==o;case"!=":return a!=o;case"<":return a<o;case">":return a>o;case"<=":return a<=o;case">=":return a>=o;case"&&":return a&&o;case"||":return a||o}break}default:throw new Error(`Unknown node type: ${e.type}`)}}e.evaluate=n,e.query=function(e,t){return n(r(e),t)},e.tokenize=r});

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@yesiree/jsonq",
+  "version": "1.0.0",
+  "description": "A lightweight library for querying and transforming JSON data using a simple expression syntax.",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "browser": "dist/index.umd.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "browser": "./dist/index.umd.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "bin": {
+    "jsonq": "dist/cli.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "build": "rollup -c",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@rollup/plugin-terser": "^0.4.4",
+    "jest": "^30.2.0",
+    "rollup": "^4.9.0"
+  },
+  "keywords": [
+    "json",
+    "query",
+    "filter",
+    "map",
+    "pipe",
+    "expression",
+    "parser"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/trevorhreed/jsonq.git"
+  }
+}