@wener/common 1.0.1 → 1.0.2

package/lib/search/AdvanceSearch.js

@@ -0,0 +1,10 @@
+import { formatAdvanceSearch } from "./formatAdvanceSearch.js";
+import { optimizeAdvanceSearch } from "./optimizeAdvanceSearch.js";
+import { parseAdvanceSearch } from "./parseAdvanceSearch.js";
+(function (AdvanceSearch) {
+    AdvanceSearch.parse = parseAdvanceSearch;
+    AdvanceSearch.format = formatAdvanceSearch;
+    AdvanceSearch.optimize = optimizeAdvanceSearch;
+})(AdvanceSearch || (AdvanceSearch = {}));
+export var AdvanceSearch;
+//# sourceMappingURL=AdvanceSearch.js.map

package/lib/search/AdvanceSearch.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/search/AdvanceSearch.ts"],"sourcesContent":["import { formatAdvanceSearch } from './formatAdvanceSearch';\nimport { optimizeAdvanceSearch } from './optimizeAdvanceSearch';\nimport { parseAdvanceSearch } from './parseAdvanceSearch';\nimport type * as types from './types';\n\nexport namespace AdvanceSearch {\n  export type Exprs = types.Exprs;\n  export type Expr = types.Expr;\n  export type Value = types.Value;\n\n  export const parse = parseAdvanceSearch;\n  export const format = formatAdvanceSearch;\n  export const optimize = optimizeAdvanceSearch;\n}\n"],"names":["formatAdvanceSearch","optimizeAdvanceSearch","parseAdvanceSearch","AdvanceSearch","parse","format","optimize"],"mappings":"AAAA,SAASA,mBAAmB,QAAQ,wBAAwB;AAC5D,SAASC,qBAAqB,QAAQ,0BAA0B;AAChE,SAASC,kBAAkB,QAAQ,uBAAuB;UAGzCC;kBAKFC,QAAQF;kBACRG,SAASL;kBACTM,WAAWL;AAC1B,GARiBE,kBAAAA"}

package/lib/search/formatAdvanceSearch.js

@@ -0,0 +1,64 @@
+import { match } from "ts-pattern";
+export function formatAdvanceSearch(input) {
+    const OP = {
+        has: ':',
+        eq: ':=',
+        ne: ':!=',
+        gt: ':>',
+        lt: ':<',
+        gte: ':>=',
+        lte: ':<=',
+        range: ':'
+    };
+    const _exprs = (s)=>{
+        return s.map(_expr).join(' ');
+    };
+    const _expr = (s)=>{
+        return match(s).with({
+            type: 'keyword'
+        }, ({ value, exact, negative })=>{
+            return `${negative ? '-' : ''}${exact ? `"${value}"` : value}`;
+        }).with({
+            type: 'logical'
+        }, ({ operator, value })=>value.map(_expr).join(` ${operator.toLocaleUpperCase()} `)).with({
+            type: 'not'
+        }, ({ value })=>`NOT ${_expr(value)}`).with({
+            type: 'compare'
+        }, ({ field, operator, value, negative, mention })=>{
+            return `${negative ? '-' : ''}${mention ? '@' : ''}${field}${OP[operator]}${_value(value)}`;
+        }).with({
+            type: 'comment'
+        }, ({ value })=>`/* ${value} */`).with({
+            type: 'parentheses'
+        }, ({ value })=>`(${_exprs(value)})`).exhaustive();
+    };
+    const _literal = (s)=>{
+        if (typeof s === 'string') {
+            return s.includes(' ') ? `"${s}"` : s;
+        }
+        return JSON.stringify(s);
+    };
+    const _value = (v)=>{
+        return match(v).with({
+            type: 'range'
+        }, ({ minimum, maximum, minimumExclusive, maximumExclusive })=>{
+            if (minimumExclusive === undefined && maximumExclusive === undefined) {
+                let min = minimum === undefined ? '*' : _value(minimum);
+                let max = maximum === undefined ? '*' : _value(maximum);
+                return `${min}..${max}`;
+            }
+            let min = minimum === undefined ? '' : _value(minimum);
+            let max = maximum === undefined ? '' : _value(maximum);
+            return `${minimumExclusive ? '(' : '['}${min},${max}${maximumExclusive ? ')' : ']'}`;
+        }).with({
+            format: 'mention'
+        }, ({ value })=>{
+            return `@${value}`;
+        }).otherwise((value)=>{
+            return _literal(value.value);
+        });
+    };
+    return _exprs(input);
+}
+
+//# sourceMappingURL=formatAdvanceSearch.js.map

package/lib/search/formatAdvanceSearch.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/search/formatAdvanceSearch.ts"],"sourcesContent":["import { match } from 'ts-pattern';\nimport { AdvanceSearch } from './AdvanceSearch';\n\nexport function formatAdvanceSearch(input: AdvanceSearch.Expr[]) {\n  const OP = {\n    has: ':',\n    eq: ':=',\n    ne: ':!=',\n    gt: ':>',\n    lt: ':<',\n    gte: ':>=',\n    lte: ':<=',\n    range: ':',\n  } as const;\n\n  const _exprs = (s: AdvanceSearch.Expr[]): string => {\n    return s.map(_expr).join(' ');\n  };\n  const _expr = (s: AdvanceSearch.Expr): string => {\n    return match(s)\n      .with({ type: 'keyword' }, ({ value, exact, negative }) => {\n        return `${negative ? '-' : ''}${exact ? `\"${value}\"` : value}`;\n      })\n      .with({ type: 'logical' }, ({ operator, value }) => value.map(_expr).join(` ${operator.toLocaleUpperCase()} `))\n      .with({ type: 'not' }, ({ value }) => `NOT ${_expr(value)}`)\n      .with({ type: 'compare' }, ({ field, operator, value, negative, mention }) => {\n        return `${negative ? '-' : ''}${mention ? '@' : ''}${field}${OP[operator]}${_value(value)}`;\n      })\n      .with({ type: 'comment' }, ({ value }) => `/* ${value} */`)\n      .with({ type: 'parentheses' }, ({ value }) => `(${_exprs(value)})`)\n      .exhaustive();\n  };\n\n  const _literal = (s: string | null | number) => {\n    if (typeof s === 'string') {\n      return s.includes(' ') ? `\"${s}\"` : s;\n    }\n    return JSON.stringify(s);\n  };\n  const _value = (v: AdvanceSearch.Value): string => {\n    return match(v)\n      .with({ type: 'range' }, ({ minimum, maximum, minimumExclusive, maximumExclusive }) => {\n        if (minimumExclusive === undefined && maximumExclusive === undefined) {\n          let min = minimum === undefined ? '*' : _value(minimum);\n          let max = maximum === undefined ? '*' : _value(maximum);\n          return `${min}..${max}`;\n        }\n        let min = minimum === undefined ? '' : _value(minimum);\n        let max = maximum === undefined ? '' : _value(maximum);\n        return `${minimumExclusive ? '(' : '['}${min},${max}${maximumExclusive ? ')' : ']'}`;\n      })\n      .with({ format: 'mention' }, ({ value }) => {\n        return `@${value}`;\n      })\n      .otherwise((value) => {\n        return _literal(value.value);\n      });\n  };\n\n  return _exprs(input);\n}\n"],"names":["match","formatAdvanceSearch","input","OP","has","eq","ne","gt","lt","gte","lte","range","_exprs","s","map","_expr","join","with","type","value","exact","negative","operator","toLocaleUpperCase","field","mention","_value","exhaustive","_literal","includes","JSON","stringify","v","minimum","maximum","minimumExclusive","maximumExclusive","undefined","min","max","format","otherwise"],"mappings":"AAAA,SAASA,KAAK,QAAQ,aAAa;AAGnC,OAAO,SAASC,oBAAoBC,KAA2B;IAC7D,MAAMC,KAAK;QACTC,KAAK;QACLC,IAAI;QACJC,IAAI;QACJC,IAAI;QACJC,IAAI;QACJC,KAAK;QACLC,KAAK;QACLC,OAAO;IACT;IAEA,MAAMC,SAAS,CAACC;QACd,OAAOA,EAAEC,GAAG,CAACC,OAAOC,IAAI,CAAC;IAC3B;IACA,MAAMD,QAAQ,CAACF;QACb,OAAOb,MAAMa,GACVI,IAAI,CAAC;YAAEC,MAAM;QAAU,GAAG,CAAC,EAAEC,KAAK,EAAEC,KAAK,EAAEC,QAAQ,EAAE;YACpD,OAAO,GAAGA,WAAW,MAAM,KAAKD,QAAQ,CAAC,CAAC,EAAED,MAAM,CAAC,CAAC,GAAGA,OAAO;QAChE,GACCF,IAAI,CAAC;YAAEC,MAAM;QAAU,GAAG,CAAC,EAAEI,QAAQ,EAAEH,KAAK,EAAE,GAAKA,MAAML,GAAG,CAACC,OAAOC,IAAI,CAAC,CAAC,CAAC,EAAEM,SAASC,iBAAiB,GAAG,CAAC,CAAC,GAC5GN,IAAI,CAAC;YAAEC,MAAM;QAAM,GAAG,CAAC,EAAEC,KAAK,EAAE,GAAK,CAAC,IAAI,EAAEJ,MAAMI,QAAQ,EAC1DF,IAAI,CAAC;YAAEC,MAAM;QAAU,GAAG,CAAC,EAAEM,KAAK,EAAEF,QAAQ,EAAEH,KAAK,EAAEE,QAAQ,EAAEI,OAAO,EAAE;YACvE,OAAO,GAAGJ,WAAW,MAAM,KAAKI,UAAU,MAAM,KAAKD,QAAQrB,EAAE,CAACmB,SAAS,GAAGI,OAAOP,QAAQ;QAC7F,GACCF,IAAI,CAAC;YAAEC,MAAM;QAAU,GAAG,CAAC,EAAEC,KAAK,EAAE,GAAK,CAAC,GAAG,EAAEA,MAAM,GAAG,CAAC,EACzDF,IAAI,CAAC;YAAEC,MAAM;QAAc,GAAG,CAAC,EAAEC,KAAK,EAAE,GAAK,CAAC,CAAC,EAAEP,OAAOO,OAAO,CAAC,CAAC,EACjEQ,UAAU;IACf;IAEA,MAAMC,WAAW,CAACf;QAChB,IAAI,OAAOA,MAAM,UAAU;YACzB,OAAOA,EAAEgB,QAAQ,CAAC,OAAO,CAAC,CAAC,EAAEhB,EAAE,CAAC,CAAC,GAAGA;QACtC;QACA,OAAOiB,KAAKC,SAAS,CAAClB;IACxB;IACA,MAAMa,SAAS,CAACM;QACd,OAAOhC,MAAMgC,GACVf,IAAI,CAAC;YAAEC,MAAM;QAAQ,GAAG,CAAC,EAAEe,OAAO,EAAEC,OAAO,EAAEC,gBAAgB,EAAEC,gBAAgB,EAAE;YAChF,IAAID,qBAAqBE,aAAaD,qBAAqBC,WAAW;gBACpE,IAAIC,MAAML,YAAYI,YAAY,MAAMX,OAAOO;gBAC/C,IAAIM,MAAML,YAAYG,YAAY,MAAMX,OAAOQ;gBAC/C,OAAO,GAAGI,IAAI,EAAE,EAAEC,KAAK;YACzB;YACA,IAAID,MAAML,YAAYI,YAAY,KAAKX,OAAOO;YAC9C,IAAIM,MAAML,YAAYG,YAAY,KAAKX,OAAOQ;YAC9C,OAAO,GAAGC,mBAAmB,MAAM,MAAMG,IAAI,CAAC,EAAEC,MAAMH,mBAAmB,MAAM,KAAK;QACtF,GACCnB,IAAI,CAAC;YAAEuB,QAAQ;QAAU,GAAG,CAAC,EAAErB,KAAK,EAAE;YACrC,OAAO,CAAC,CAAC,EAAEA,OAAO;QACpB,GACCsB,SAAS,CAAC,CAACtB;YACV,OAAOS,SAAST,MAAMA,KAAK;QAC7B;IACJ;IAEA,OAAOP,OAAOV;AAChB"}

package/lib/search/index.js

@@ -0,0 +1,2 @@
+export { AdvanceSearch } from "./AdvanceSearch.js";
+//# sourceMappingURL=index.js.map

package/lib/search/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/search/index.ts"],"sourcesContent":["export { AdvanceSearch } from './AdvanceSearch';\n"],"names":["AdvanceSearch"],"mappings":"AAAA,SAASA,aAAa,QAAQ,kBAAkB"}

package/lib/search/optimizeAdvanceSearch.js

@@ -0,0 +1,89 @@
+import { arrayOfMaybeArray, deepEqual } from "@wener/utils";
+import { match } from "ts-pattern";
+export function optimizeAdvanceSearch(expr) {
+    const NEG = {
+        eq: 'ne',
+        ne: 'eq',
+        gt: 'lte',
+        lt: 'gte',
+        gte: 'lt',
+        lte: 'gt'
+    };
+    const _expr = (e)=>{
+        // merge Exprs to AND ?
+        return match(e)// (EXPR) -> EXPR
+        // TODO (EXPR EXPR) -> EXPR AND EXPR
+        .with({
+            type: 'parentheses'
+        }, (expr)=>{
+            // unwrap
+            if (expr.value.length < 2) {
+                return expr.value[0];
+            }
+            expr.value = expr.value.flatMap(_expr);
+            return expr;
+        }).with({
+            type: 'comment'
+        }, (expr)=>{
+            // remove empty comment
+            if (!expr.value.length) {
+                return [];
+            }
+            return expr;
+        })// NOT
+        .with({
+            type: 'not'
+        }, (expr)=>{
+            let out = arrayOfMaybeArray(_expr(expr.value));
+            if (!out.length) {
+                return [];
+            } else if (out.length === 1) {
+                expr.value = out[0];
+            } else {
+                throw new Error('NOT should have only one value');
+            }
+            return match(expr.value)// NOT NOT EXPR -> EXPR
+            .with({
+                type: 'not'
+            }, (expr)=>expr.value)// NOT EXPR -> -EXPR
+            .with({
+                type: 'compare'
+            }, (expr)=>{
+                return {
+                    ...expr,
+                    negative: !expr.negative
+                };
+            }).with({
+                type: 'keyword'
+            }, (expr)=>{
+                return {
+                    ...expr,
+                    negative: !expr.negative
+                };
+            }).otherwise(()=>expr);
+        }).with({
+            type: 'compare'
+        }, (expr)=>{
+            // negative by swap operator
+            if (expr.negative) {
+                const ne = NEG[expr.operator];
+                if (ne) {
+                    expr.operator = ne;
+                    expr.negative = false;
+                }
+            }
+            if (expr.operator === 'range') {}
+            return expr;
+        }).otherwise((e)=>e);
+    };
+    let last = expr;
+    while(true){
+        let next = structuredClone(last).flatMap(_expr);
+        if (deepEqual(last, next)) {
+            return last;
+        }
+        last = next;
+    }
+}
+
+//# sourceMappingURL=optimizeAdvanceSearch.js.map

package/lib/search/optimizeAdvanceSearch.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/search/optimizeAdvanceSearch.ts"],"sourcesContent":["import { arrayOfMaybeArray, deepEqual, type MaybeArray } from '@wener/utils';\nimport { match } from 'ts-pattern';\nimport { AdvanceSearch } from './AdvanceSearch';\n\nexport function optimizeAdvanceSearch(expr: AdvanceSearch.Exprs): AdvanceSearch.Exprs {\n  const NEG = {\n    eq: 'ne',\n    ne: 'eq',\n    gt: 'lte',\n    lt: 'gte',\n    gte: 'lt',\n    lte: 'gt',\n  } as const;\n  const _expr = (e: AdvanceSearch.Expr): MaybeArray<AdvanceSearch.Expr> => {\n    // merge Exprs to AND ?\n    return (\n      match(e)\n        // (EXPR) -> EXPR\n        // TODO (EXPR EXPR) -> EXPR AND EXPR\n        .with({ type: 'parentheses' }, (expr) => {\n          // unwrap\n          if (expr.value.length < 2) {\n            return expr.value[0];\n          }\n          expr.value = expr.value.flatMap(_expr);\n          return expr;\n        })\n        .with({ type: 'comment' }, (expr) => {\n          // remove empty comment\n          if (!expr.value.length) {\n            return [];\n          }\n          return expr;\n        })\n        // NOT\n        .with({ type: 'not' }, (expr) => {\n          let out = arrayOfMaybeArray(_expr(expr.value));\n          if (!out.length) {\n            return [];\n          } else if (out.length === 1) {\n            expr.value = out[0];\n          } else {\n            throw new Error('NOT should have only one value');\n          }\n          return (\n            match(expr.value)\n              // NOT NOT EXPR -> EXPR\n              .with({ type: 'not' }, (expr) => expr.value)\n              // NOT EXPR -> -EXPR\n              .with({ type: 'compare' }, (expr) => {\n                return {\n                  ...expr,\n                  negative: !expr.negative,\n                };\n              })\n              .with({ type: 'keyword' }, (expr) => {\n                return {\n                  ...expr,\n                  negative: !expr.negative,\n                };\n              })\n              .otherwise(() => expr)\n          );\n        })\n        .with({ type: 'compare' }, (expr) => {\n          // negative by swap operator\n          if (expr.negative) {\n            const ne = NEG[expr.operator as keyof typeof NEG];\n            if (ne) {\n              expr.operator = ne;\n              expr.negative = false;\n            }\n          }\n          if (expr.operator === 'range') {\n          }\n          return expr;\n        })\n        .otherwise((e) => e)\n    );\n  };\n\n  let last = expr;\n  while (true) {\n    let next = structuredClone(last).flatMap(_expr);\n    if (deepEqual(last, next)) {\n      return last;\n    }\n    last = next;\n  }\n}\n"],"names":["arrayOfMaybeArray","deepEqual","match","optimizeAdvanceSearch","expr","NEG","eq","ne","gt","lt","gte","lte","_expr","e","with","type","value","length","flatMap","out","Error","negative","otherwise","operator","last","next","structuredClone"],"mappings":"AAAA,SAASA,iBAAiB,EAAEC,SAAS,QAAyB,eAAe;AAC7E,SAASC,KAAK,QAAQ,aAAa;AAGnC,OAAO,SAASC,sBAAsBC,IAAyB;IAC7D,MAAMC,MAAM;QACVC,IAAI;QACJC,IAAI;QACJC,IAAI;QACJC,IAAI;QACJC,KAAK;QACLC,KAAK;IACP;IACA,MAAMC,QAAQ,CAACC;QACb,uBAAuB;QACvB,OACEX,MAAMW,EACJ,iBAAiB;QACjB,oCAAoC;SACnCC,IAAI,CAAC;YAAEC,MAAM;QAAc,GAAG,CAACX;YAC9B,SAAS;YACT,IAAIA,KAAKY,KAAK,CAACC,MAAM,GAAG,GAAG;gBACzB,OAAOb,KAAKY,KAAK,CAAC,EAAE;YACtB;YACAZ,KAAKY,KAAK,GAAGZ,KAAKY,KAAK,CAACE,OAAO,CAACN;YAChC,OAAOR;QACT,GACCU,IAAI,CAAC;YAAEC,MAAM;QAAU,GAAG,CAACX;YAC1B,uBAAuB;YACvB,IAAI,CAACA,KAAKY,KAAK,CAACC,MAAM,EAAE;gBACtB,OAAO,EAAE;YACX;YACA,OAAOb;QACT,EACA,MAAM;SACLU,IAAI,CAAC;YAAEC,MAAM;QAAM,GAAG,CAACX;YACtB,IAAIe,MAAMnB,kBAAkBY,MAAMR,KAAKY,KAAK;YAC5C,IAAI,CAACG,IAAIF,MAAM,EAAE;gBACf,OAAO,EAAE;YACX,OAAO,IAAIE,IAAIF,MAAM,KAAK,GAAG;gBAC3Bb,KAAKY,KAAK,GAAGG,GAAG,CAAC,EAAE;YACrB,OAAO;gBACL,MAAM,IAAIC,MAAM;YAClB;YACA,OACElB,MAAME,KAAKY,KAAK,CACd,uBAAuB;aACtBF,IAAI,CAAC;gBAAEC,MAAM;YAAM,GAAG,CAACX,OAASA,KAAKY,KAAK,CAC3C,oBAAoB;aACnBF,IAAI,CAAC;gBAAEC,MAAM;YAAU,GAAG,CAACX;gBAC1B,OAAO;oBACL,GAAGA,IAAI;oBACPiB,UAAU,CAACjB,KAAKiB,QAAQ;gBAC1B;YACF,GACCP,IAAI,CAAC;gBAAEC,MAAM;YAAU,GAAG,CAACX;gBAC1B,OAAO;oBACL,GAAGA,IAAI;oBACPiB,UAAU,CAACjB,KAAKiB,QAAQ;gBAC1B;YACF,GACCC,SAAS,CAAC,IAAMlB;QAEvB,GACCU,IAAI,CAAC;YAAEC,MAAM;QAAU,GAAG,CAACX;YAC1B,4BAA4B;YAC5B,IAAIA,KAAKiB,QAAQ,EAAE;gBACjB,MAAMd,KAAKF,GAAG,CAACD,KAAKmB,QAAQ,CAAqB;gBACjD,IAAIhB,IAAI;oBACNH,KAAKmB,QAAQ,GAAGhB;oBAChBH,KAAKiB,QAAQ,GAAG;gBAClB;YACF;YACA,IAAIjB,KAAKmB,QAAQ,KAAK,SAAS,CAC/B;YACA,OAAOnB;QACT,GACCkB,SAAS,CAAC,CAACT,IAAMA;IAExB;IAEA,IAAIW,OAAOpB;IACX,MAAO,KAAM;QACX,IAAIqB,OAAOC,gBAAgBF,MAAMN,OAAO,CAACN;QACzC,IAAIX,UAAUuB,MAAMC,OAAO;YACzB,OAAOD;QACT;QACAA,OAAOC;IACT;AACF"}

package/lib/search/parseAdvanceSearch.js

@@ -0,0 +1,20 @@
+import { parse } from "./parser.js";
+export function parseAdvanceSearch(s) {
+    s = s?.trim();
+    if (!s) {
+        return [];
+    }
+    // no Logical, no Compare, no Quote, no Comment
+    if (!/AND|OR|NOT|[-"():]|\/\*/.test(s)) {
+        // fast path
+        return s.split(/\s+/).map((v)=>v.trim()).filter(Boolean).map((v)=>{
+            return {
+                type: 'keyword',
+                value: v
+            };
+        });
+    }
+    return parse(s);
+}
+
+//# sourceMappingURL=parseAdvanceSearch.js.map

package/lib/search/parseAdvanceSearch.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/search/parseAdvanceSearch.ts"],"sourcesContent":["import { AdvanceSearch } from './AdvanceSearch';\nimport { parse } from './parser';\n\nexport function parseAdvanceSearch(s: string | undefined | null): AdvanceSearch.Expr[] {\n  s = s?.trim();\n  if (!s) {\n    return [];\n  }\n\n  // no Logical, no Compare, no Quote, no Comment\n  if (!/AND|OR|NOT|[-\"():]|\\/\\*/.test(s)) {\n    // fast path\n    return s\n      .split(/\\s+/)\n      .map((v) => v.trim())\n      .filter(Boolean)\n      .map((v) => {\n        return {\n          type: 'keyword',\n          value: v,\n        };\n      });\n  }\n\n  return parse(s);\n}\n"],"names":["parse","parseAdvanceSearch","s","trim","test","split","map","v","filter","Boolean","type","value"],"mappings":"AACA,SAASA,KAAK,QAAQ,cAAW;AAEjC,OAAO,SAASC,mBAAmBC,CAA4B;IAC7DA,IAAIA,GAAGC;IACP,IAAI,CAACD,GAAG;QACN,OAAO,EAAE;IACX;IAEA,+CAA+C;IAC/C,IAAI,CAAC,0BAA0BE,IAAI,CAACF,IAAI;QACtC,YAAY;QACZ,OAAOA,EACJG,KAAK,CAAC,OACNC,GAAG,CAAC,CAACC,IAAMA,EAAEJ,IAAI,IACjBK,MAAM,CAACC,SACPH,GAAG,CAAC,CAACC;YACJ,OAAO;gBACLG,MAAM;gBACNC,OAAOJ;YACT;QACF;IACJ;IAEA,OAAOP,MAAME;AACf"}

package/lib/search/parser.d.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=parser.d.js.map

package/lib/search/parser.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/search/parser.d.ts"],"sourcesContent":["export function parse(input: string, options?: ParseOptions): any;\n\nexport interface ParseOptions {\n  grammarSource?: string;\n  startRule?: string;\n\n  [k: string]: any;\n}\n"],"names":[],"mappings":"AAEA,WAKC"}