@langchain/core 1.2.0-dev-1765937705265 → 1.2.0

package/dist/structured_query/functional.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"functional.cjs","names":["BaseTranslator","Operators","Comparators","inputType: string","comparator: Comparator","a: string | number","b: ValueType[C]","operator: Operator","operation: Operation","document: Document","comparison: Comparison<string | number | boolean>","castValue","query: StructuredQuery","defaultFilter: FunctionFilter","generatedFilter: FunctionFilter","isFilterEmpty"],"sources":["../../src/structured_query/functional.ts"],"sourcesContent":["import { Document } from \"../documents/document.js\";\nimport {\n  Comparator,\n  Comparators,\n  Comparison,\n  Operation,\n  Operator,\n  Operators,\n  StructuredQuery,\n} from \"./ir.js\";\nimport { BaseTranslator } from \"./base.js\";\nimport { castValue, isFilterEmpty } from \"./utils.js\";\n\n/**\n * A type alias for an object that maps comparison operators to string or\n * number values. This is used in the comparison functions to determine\n * the result of a comparison operation.\n */\ntype ValueType = {\n  eq: string | number | boolean;\n  ne: string | number | boolean;\n  lt: string | number;\n  lte: string | number;\n  gt: string | number;\n  gte: string | number;\n};\n\n/**\n * A type alias for a function that takes a `Document` as an argument and\n * returns a boolean. This function is used as a filter for documents.\n */\nexport type FunctionFilter = (document: Document) => boolean;\n\n/**\n * A class that extends `BaseTranslator` to translate structured queries\n * into functional filters.\n * @example\n * ```typescript\n * const functionalTranslator = new FunctionalTranslator();\n * const relevantDocuments = await functionalTranslator.getRelevantDocuments(\n *   \"Which movies are rated higher than 8.5?\",\n * );\n * ```\n */\nexport class FunctionalTranslator extends BaseTranslator {\n  declare VisitOperationOutput: FunctionFilter;\n\n  declare VisitComparisonOutput: FunctionFilter;\n\n  declare VisitStructuredQueryOutput:\n    | { filter: FunctionFilter }\n    | { [k: string]: never };\n\n  allowedOperators: Operator[] = [Operators.and, Operators.or];\n\n  allowedComparators: Comparator[] = [\n    Comparators.eq,\n    Comparators.ne,\n    Comparators.gt,\n    Comparators.gte,\n    Comparators.lt,\n    Comparators.lte,\n  ];\n\n  formatFunction(): string {\n    throw new Error(\"Not implemented\");\n  }\n\n  /**\n   * Returns the allowed comparators for a given data type.\n   * @param input The input value to get the allowed comparators for.\n   * @returns An array of allowed comparators for the input data type.\n   */\n  getAllowedComparatorsForType(inputType: string): Comparator[] {\n    switch (inputType) {\n      case \"string\": {\n        return [\n          Comparators.eq,\n          Comparators.ne,\n          Comparators.gt,\n          Comparators.gte,\n          Comparators.lt,\n          Comparators.lte,\n        ];\n      }\n      case \"number\": {\n        return [\n          Comparators.eq,\n          Comparators.ne,\n          Comparators.gt,\n          Comparators.gte,\n          Comparators.lt,\n          Comparators.lte,\n        ];\n      }\n      case \"boolean\": {\n        return [Comparators.eq, Comparators.ne];\n      }\n      default: {\n        throw new Error(`Unsupported data type: ${inputType}`);\n      }\n    }\n  }\n\n  /**\n   * Returns a function that performs a comparison based on the provided\n   * comparator.\n   * @param comparator The comparator to base the comparison function on.\n   * @returns A function that takes two arguments and returns a boolean based on the comparison.\n   */\n  getComparatorFunction<C extends Comparator>(\n    comparator: Comparator\n  ): (a: string | number, b: ValueType[C]) => boolean {\n    switch (comparator) {\n      case Comparators.eq: {\n        return (a: string | number, b: ValueType[C]) => a === b;\n      }\n      case Comparators.ne: {\n        return (a: string | number, b: ValueType[C]) => a !== b;\n      }\n      case Comparators.gt: {\n        return (a: string | number, b: ValueType[C]) => a > b;\n      }\n      case Comparators.gte: {\n        return (a: string | number, b: ValueType[C]) => a >= b;\n      }\n      case Comparators.lt: {\n        return (a: string | number, b: ValueType[C]) => a < b;\n      }\n      case Comparators.lte: {\n        return (a: string | number, b: ValueType[C]) => a <= b;\n      }\n      default: {\n        throw new Error(\"Unknown comparator\");\n      }\n    }\n  }\n\n  /**\n   * Returns a function that performs an operation based on the provided\n   * operator.\n   * @param operator The operator to base the operation function on.\n   * @returns A function that takes two boolean arguments and returns a boolean based on the operation.\n   */\n  getOperatorFunction(operator: Operator): (a: boolean, b: boolean) => boolean {\n    switch (operator) {\n      case Operators.and: {\n        return (a, b) => a && b;\n      }\n      case Operators.or: {\n        return (a, b) => a || b;\n      }\n      default: {\n        throw new Error(\"Unknown operator\");\n      }\n    }\n  }\n\n  /**\n   * Visits the operation part of a structured query and translates it into\n   * a functional filter.\n   * @param operation The operation part of a structured query.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the operation.\n   */\n  visitOperation(operation: Operation): this[\"VisitOperationOutput\"] {\n    const { operator, args } = operation;\n    if (this.allowedOperators.includes(operator)) {\n      const operatorFunction = this.getOperatorFunction(operator);\n      return (document: Document) => {\n        if (!args) {\n          return true;\n        }\n\n        return args.reduce((acc, arg) => {\n          const result = arg.accept(this);\n          if (typeof result === \"function\") {\n            return operatorFunction(acc, result(document));\n          } else {\n            throw new Error(\"Filter is not a function\");\n          }\n        }, true);\n      };\n    } else {\n      throw new Error(\"Operator not allowed\");\n    }\n  }\n\n  /**\n   * Visits the comparison part of a structured query and translates it into\n   * a functional filter.\n   * @param comparison The comparison part of a structured query.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the comparison.\n   */\n  visitComparison(\n    comparison: Comparison<string | number | boolean>\n  ): this[\"VisitComparisonOutput\"] {\n    const { comparator, attribute, value } = comparison;\n    const undefinedTrue = [Comparators.ne];\n    if (this.allowedComparators.includes(comparator)) {\n      if (\n        !this.getAllowedComparatorsForType(typeof value).includes(comparator)\n      ) {\n        throw new Error(\n          `'${comparator}' comparator not allowed to be used with ${typeof value}`\n        );\n      }\n      const comparatorFunction = this.getComparatorFunction(comparator);\n      return (document: Document) => {\n        const documentValue = document.metadata[attribute];\n        if (documentValue === undefined) {\n          if (undefinedTrue.includes(comparator)) {\n            return true;\n          }\n          return false;\n        }\n        return comparatorFunction(documentValue, castValue(value));\n      };\n    } else {\n      throw new Error(\"Comparator not allowed\");\n    }\n  }\n\n  /**\n   * Visits a structured query and translates it into a functional filter.\n   * @param query The structured query to translate.\n   * @returns An object containing a `filter` property, which is a function that takes a `Document` as an argument and returns a boolean based on the structured query.\n   */\n  visitStructuredQuery(\n    query: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"] {\n    if (!query.filter) {\n      return {};\n    }\n    const filterFunction = query.filter?.accept(this);\n    if (typeof filterFunction !== \"function\") {\n      throw new Error(\"Structured query filter is not a function\");\n    }\n    return { filter: filterFunction as FunctionFilter };\n  }\n\n  /**\n   * Merges two filters into one, based on the specified merge type.\n   * @param defaultFilter The default filter function.\n   * @param generatedFilter The generated filter function.\n   * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'. Default is 'and'.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the merged filters, or `undefined` if both filters are empty.\n   */\n  mergeFilters(\n    defaultFilter: FunctionFilter,\n    generatedFilter: FunctionFilter,\n    mergeType = \"and\"\n  ): FunctionFilter | undefined {\n    if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) {\n      return undefined;\n    }\n    if (isFilterEmpty(defaultFilter) || mergeType === \"replace\") {\n      if (isFilterEmpty(generatedFilter)) {\n        return undefined;\n      }\n      return generatedFilter;\n    }\n    if (isFilterEmpty(generatedFilter)) {\n      if (mergeType === \"and\") {\n        return undefined;\n      }\n      return defaultFilter;\n    }\n\n    if (mergeType === \"and\") {\n      return (document: Document) =>\n        defaultFilter(document) && generatedFilter(document);\n    } else if (mergeType === \"or\") {\n      return (document: Document) =>\n        defaultFilter(document) || generatedFilter(document);\n    } else {\n      throw new Error(\"Unknown merge type\");\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA4CA,IAAa,uBAAb,cAA0CA,4BAAe;CASvD,mBAA+B,CAACC,qBAAU,KAAKA,qBAAU,EAAG;CAE5D,qBAAmC;EACjCC,uBAAY;EACZA,uBAAY;EACZA,uBAAY;EACZA,uBAAY;EACZA,uBAAY;EACZA,uBAAY;CACb;CAED,iBAAyB;AACvB,QAAM,IAAI,MAAM;CACjB;;;;;;CAOD,6BAA6BC,WAAiC;AAC5D,UAAQ,WAAR;GACE,KAAK,SACH,QAAO;IACLD,uBAAY;IACZA,uBAAY;IACZA,uBAAY;IACZA,uBAAY;IACZA,uBAAY;IACZA,uBAAY;GACb;GAEH,KAAK,SACH,QAAO;IACLA,uBAAY;IACZA,uBAAY;IACZA,uBAAY;IACZA,uBAAY;IACZA,uBAAY;IACZA,uBAAY;GACb;GAEH,KAAK,UACH,QAAO,CAACA,uBAAY,IAAIA,uBAAY,EAAG;GAEzC,QACE,OAAM,IAAI,MAAM,CAAC,uBAAuB,EAAE,WAAW;EAExD;CACF;;;;;;;CAQD,sBACEE,YACkD;AAClD,UAAQ,YAAR;GACE,KAAKF,uBAAY,GACf,QAAO,CAACG,GAAoBC,MAAoB,MAAM;GAExD,KAAKJ,uBAAY,GACf,QAAO,CAACG,GAAoBC,MAAoB,MAAM;GAExD,KAAKJ,uBAAY,GACf,QAAO,CAACG,GAAoBC,MAAoB,IAAI;GAEtD,KAAKJ,uBAAY,IACf,QAAO,CAACG,GAAoBC,MAAoB,KAAK;GAEvD,KAAKJ,uBAAY,GACf,QAAO,CAACG,GAAoBC,MAAoB,IAAI;GAEtD,KAAKJ,uBAAY,IACf,QAAO,CAACG,GAAoBC,MAAoB,KAAK;GAEvD,QACE,OAAM,IAAI,MAAM;EAEnB;CACF;;;;;;;CAQD,oBAAoBC,UAAyD;AAC3E,UAAQ,UAAR;GACE,KAAKN,qBAAU,IACb,QAAO,CAAC,GAAG,MAAM,KAAK;GAExB,KAAKA,qBAAU,GACb,QAAO,CAAC,GAAG,MAAM,KAAK;GAExB,QACE,OAAM,IAAI,MAAM;EAEnB;CACF;;;;;;;CAQD,eAAeO,WAAoD;EACjE,MAAM,EAAE,UAAU,MAAM,GAAG;AAC3B,MAAI,KAAK,iBAAiB,SAAS,SAAS,EAAE;GAC5C,MAAM,mBAAmB,KAAK,oBAAoB,SAAS;AAC3D,UAAO,CAACC,aAAuB;AAC7B,QAAI,CAAC,KACH,QAAO;AAGT,WAAO,KAAK,OAAO,CAAC,KAAK,QAAQ;KAC/B,MAAM,SAAS,IAAI,OAAO,KAAK;AAC/B,SAAI,OAAO,WAAW,WACpB,QAAO,iBAAiB,KAAK,OAAO,SAAS,CAAC;SAE9C,OAAM,IAAI,MAAM;IAEnB,GAAE,KAAK;GACT;EACF,MACC,OAAM,IAAI,MAAM;CAEnB;;;;;;;CAQD,gBACEC,YAC+B;EAC/B,MAAM,EAAE,YAAY,WAAW,OAAO,GAAG;EACzC,MAAM,gBAAgB,CAACR,uBAAY,EAAG;AACtC,MAAI,KAAK,mBAAmB,SAAS,WAAW,EAAE;AAChD,OACE,CAAC,KAAK,6BAA6B,OAAO,MAAM,CAAC,SAAS,WAAW,CAErE,OAAM,IAAI,MACR,CAAC,CAAC,EAAE,WAAW,yCAAyC,EAAE,OAAO,OAAO;GAG5E,MAAM,qBAAqB,KAAK,sBAAsB,WAAW;AACjE,UAAO,CAACO,aAAuB;IAC7B,MAAM,gBAAgB,SAAS,SAAS;AACxC,QAAI,kBAAkB,QAAW;AAC/B,SAAI,cAAc,SAAS,WAAW,CACpC,QAAO;AAET,YAAO;IACR;AACD,WAAO,mBAAmB,eAAeE,wBAAU,MAAM,CAAC;GAC3D;EACF,MACC,OAAM,IAAI,MAAM;CAEnB;;;;;;CAOD,qBACEC,OACoC;AACpC,MAAI,CAAC,MAAM,OACT,QAAO,CAAE;EAEX,MAAM,iBAAiB,MAAM,QAAQ,OAAO,KAAK;AACjD,MAAI,OAAO,mBAAmB,WAC5B,OAAM,IAAI,MAAM;AAElB,SAAO,EAAE,QAAQ,eAAkC;CACpD;;;;;;;;CASD,aACEC,eACAC,iBACA,YAAY,OACgB;AAC5B,MAAIC,4BAAc,cAAc,IAAIA,4BAAc,gBAAgB,CAChE,QAAO;AAET,MAAIA,4BAAc,cAAc,IAAI,cAAc,WAAW;AAC3D,OAAIA,4BAAc,gBAAgB,CAChC,QAAO;AAET,UAAO;EACR;AACD,MAAIA,4BAAc,gBAAgB,EAAE;AAClC,OAAI,cAAc,MAChB,QAAO;AAET,UAAO;EACR;AAED,MAAI,cAAc,MAChB,QAAO,CAACN,aACN,cAAc,SAAS,IAAI,gBAAgB,SAAS;WAC7C,cAAc,KACvB,QAAO,CAACA,aACN,cAAc,SAAS,IAAI,gBAAgB,SAAS;MAEtD,OAAM,IAAI,MAAM;CAEnB;AACF"}
+{"version":3,"file":"functional.cjs","names":["BaseTranslator","Operators","Comparators","castValue","isFilterEmpty"],"sources":["../../src/structured_query/functional.ts"],"sourcesContent":["import { Document } from \"../documents/document.js\";\nimport {\n  Comparator,\n  Comparators,\n  Comparison,\n  Operation,\n  Operator,\n  Operators,\n  StructuredQuery,\n} from \"./ir.js\";\nimport { BaseTranslator } from \"./base.js\";\nimport { castValue, isFilterEmpty } from \"./utils.js\";\n\n/**\n * A type alias for an object that maps comparison operators to string or\n * number values. This is used in the comparison functions to determine\n * the result of a comparison operation.\n */\ntype ValueType = {\n  eq: string | number | boolean;\n  ne: string | number | boolean;\n  lt: string | number;\n  lte: string | number;\n  gt: string | number;\n  gte: string | number;\n};\n\n/**\n * A type alias for a function that takes a `Document` as an argument and\n * returns a boolean. This function is used as a filter for documents.\n */\nexport type FunctionFilter = (document: Document) => boolean;\n\n/**\n * A class that extends `BaseTranslator` to translate structured queries\n * into functional filters.\n * @example\n * ```typescript\n * const functionalTranslator = new FunctionalTranslator();\n * const relevantDocuments = await functionalTranslator.getRelevantDocuments(\n *   \"Which movies are rated higher than 8.5?\",\n * );\n * ```\n */\nexport class FunctionalTranslator extends BaseTranslator {\n  declare VisitOperationOutput: FunctionFilter;\n\n  declare VisitComparisonOutput: FunctionFilter;\n\n  declare VisitStructuredQueryOutput:\n    | { filter: FunctionFilter }\n    | { [k: string]: never };\n\n  allowedOperators: Operator[] = [Operators.and, Operators.or];\n\n  allowedComparators: Comparator[] = [\n    Comparators.eq,\n    Comparators.ne,\n    Comparators.gt,\n    Comparators.gte,\n    Comparators.lt,\n    Comparators.lte,\n  ];\n\n  formatFunction(): string {\n    throw new Error(\"Not implemented\");\n  }\n\n  /**\n   * Returns the allowed comparators for a given data type.\n   * @param input The input value to get the allowed comparators for.\n   * @returns An array of allowed comparators for the input data type.\n   */\n  getAllowedComparatorsForType(inputType: string): Comparator[] {\n    switch (inputType) {\n      case \"string\": {\n        return [\n          Comparators.eq,\n          Comparators.ne,\n          Comparators.gt,\n          Comparators.gte,\n          Comparators.lt,\n          Comparators.lte,\n        ];\n      }\n      case \"number\": {\n        return [\n          Comparators.eq,\n          Comparators.ne,\n          Comparators.gt,\n          Comparators.gte,\n          Comparators.lt,\n          Comparators.lte,\n        ];\n      }\n      case \"boolean\": {\n        return [Comparators.eq, Comparators.ne];\n      }\n      default: {\n        throw new Error(`Unsupported data type: ${inputType}`);\n      }\n    }\n  }\n\n  /**\n   * Returns a function that performs a comparison based on the provided\n   * comparator.\n   * @param comparator The comparator to base the comparison function on.\n   * @returns A function that takes two arguments and returns a boolean based on the comparison.\n   */\n  getComparatorFunction<C extends Comparator>(\n    comparator: Comparator\n  ): (a: string | number, b: ValueType[C]) => boolean {\n    switch (comparator) {\n      case Comparators.eq: {\n        return (a: string | number, b: ValueType[C]) => a === b;\n      }\n      case Comparators.ne: {\n        return (a: string | number, b: ValueType[C]) => a !== b;\n      }\n      case Comparators.gt: {\n        return (a: string | number, b: ValueType[C]) => a > b;\n      }\n      case Comparators.gte: {\n        return (a: string | number, b: ValueType[C]) => a >= b;\n      }\n      case Comparators.lt: {\n        return (a: string | number, b: ValueType[C]) => a < b;\n      }\n      case Comparators.lte: {\n        return (a: string | number, b: ValueType[C]) => a <= b;\n      }\n      default: {\n        throw new Error(\"Unknown comparator\");\n      }\n    }\n  }\n\n  /**\n   * Returns a function that performs an operation based on the provided\n   * operator.\n   * @param operator The operator to base the operation function on.\n   * @returns A function that takes two boolean arguments and returns a boolean based on the operation.\n   */\n  getOperatorFunction(operator: Operator): (a: boolean, b: boolean) => boolean {\n    switch (operator) {\n      case Operators.and: {\n        return (a, b) => a && b;\n      }\n      case Operators.or: {\n        return (a, b) => a || b;\n      }\n      default: {\n        throw new Error(\"Unknown operator\");\n      }\n    }\n  }\n\n  /**\n   * Visits the operation part of a structured query and translates it into\n   * a functional filter.\n   * @param operation The operation part of a structured query.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the operation.\n   */\n  visitOperation(operation: Operation): this[\"VisitOperationOutput\"] {\n    const { operator, args } = operation;\n    if (this.allowedOperators.includes(operator)) {\n      const operatorFunction = this.getOperatorFunction(operator);\n      return (document: Document) => {\n        if (!args) {\n          return true;\n        }\n\n        return args.reduce((acc, arg) => {\n          const result = arg.accept(this);\n          if (typeof result === \"function\") {\n            return operatorFunction(acc, result(document));\n          } else {\n            throw new Error(\"Filter is not a function\");\n          }\n        }, true);\n      };\n    } else {\n      throw new Error(\"Operator not allowed\");\n    }\n  }\n\n  /**\n   * Visits the comparison part of a structured query and translates it into\n   * a functional filter.\n   * @param comparison The comparison part of a structured query.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the comparison.\n   */\n  visitComparison(\n    comparison: Comparison<string | number | boolean>\n  ): this[\"VisitComparisonOutput\"] {\n    const { comparator, attribute, value } = comparison;\n    const undefinedTrue = [Comparators.ne];\n    if (this.allowedComparators.includes(comparator)) {\n      if (\n        !this.getAllowedComparatorsForType(typeof value).includes(comparator)\n      ) {\n        throw new Error(\n          `'${comparator}' comparator not allowed to be used with ${typeof value}`\n        );\n      }\n      const comparatorFunction = this.getComparatorFunction(comparator);\n      return (document: Document) => {\n        const documentValue = document.metadata[attribute];\n        if (documentValue === undefined) {\n          if (undefinedTrue.includes(comparator)) {\n            return true;\n          }\n          return false;\n        }\n        return comparatorFunction(documentValue, castValue(value));\n      };\n    } else {\n      throw new Error(\"Comparator not allowed\");\n    }\n  }\n\n  /**\n   * Visits a structured query and translates it into a functional filter.\n   * @param query The structured query to translate.\n   * @returns An object containing a `filter` property, which is a function that takes a `Document` as an argument and returns a boolean based on the structured query.\n   */\n  visitStructuredQuery(\n    query: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"] {\n    if (!query.filter) {\n      return {};\n    }\n    const filterFunction = query.filter?.accept(this);\n    if (typeof filterFunction !== \"function\") {\n      throw new Error(\"Structured query filter is not a function\");\n    }\n    return { filter: filterFunction as FunctionFilter };\n  }\n\n  /**\n   * Merges two filters into one, based on the specified merge type.\n   * @param defaultFilter The default filter function.\n   * @param generatedFilter The generated filter function.\n   * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'. Default is 'and'.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the merged filters, or `undefined` if both filters are empty.\n   */\n  mergeFilters(\n    defaultFilter: FunctionFilter,\n    generatedFilter: FunctionFilter,\n    mergeType = \"and\"\n  ): FunctionFilter | undefined {\n    if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) {\n      return undefined;\n    }\n    if (isFilterEmpty(defaultFilter) || mergeType === \"replace\") {\n      if (isFilterEmpty(generatedFilter)) {\n        return undefined;\n      }\n      return generatedFilter;\n    }\n    if (isFilterEmpty(generatedFilter)) {\n      if (mergeType === \"and\") {\n        return undefined;\n      }\n      return defaultFilter;\n    }\n\n    if (mergeType === \"and\") {\n      return (document: Document) =>\n        defaultFilter(document) && generatedFilter(document);\n    } else if (mergeType === \"or\") {\n      return (document: Document) =>\n        defaultFilter(document) || generatedFilter(document);\n    } else {\n      throw new Error(\"Unknown merge type\");\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AA4CA,IAAa,uBAAb,cAA0CA,aAAAA,eAAe;CASvD,mBAA+B,CAACC,WAAAA,UAAU,KAAKA,WAAAA,UAAU,GAAG;CAE5D,qBAAmC;EACjCC,WAAAA,YAAY;EACZA,WAAAA,YAAY;EACZA,WAAAA,YAAY;EACZA,WAAAA,YAAY;EACZA,WAAAA,YAAY;EACZA,WAAAA,YAAY;EACb;CAED,iBAAyB;AACvB,QAAM,IAAI,MAAM,kBAAkB;;;;;;;CAQpC,6BAA6B,WAAiC;AAC5D,UAAQ,WAAR;GACE,KAAK,SACH,QAAO;IACLA,WAAAA,YAAY;IACZA,WAAAA,YAAY;IACZA,WAAAA,YAAY;IACZA,WAAAA,YAAY;IACZA,WAAAA,YAAY;IACZA,WAAAA,YAAY;IACb;GAEH,KAAK,SACH,QAAO;IACLA,WAAAA,YAAY;IACZA,WAAAA,YAAY;IACZA,WAAAA,YAAY;IACZA,WAAAA,YAAY;IACZA,WAAAA,YAAY;IACZA,WAAAA,YAAY;IACb;GAEH,KAAK,UACH,QAAO,CAACA,WAAAA,YAAY,IAAIA,WAAAA,YAAY,GAAG;GAEzC,QACE,OAAM,IAAI,MAAM,0BAA0B,YAAY;;;;;;;;;CAW5D,sBACE,YACkD;AAClD,UAAQ,YAAR;GACE,KAAKA,WAAAA,YAAY,GACf,SAAQ,GAAoB,MAAoB,MAAM;GAExD,KAAKA,WAAAA,YAAY,GACf,SAAQ,GAAoB,MAAoB,MAAM;GAExD,KAAKA,WAAAA,YAAY,GACf,SAAQ,GAAoB,MAAoB,IAAI;GAEtD,KAAKA,WAAAA,YAAY,IACf,SAAQ,GAAoB,MAAoB,KAAK;GAEvD,KAAKA,WAAAA,YAAY,GACf,SAAQ,GAAoB,MAAoB,IAAI;GAEtD,KAAKA,WAAAA,YAAY,IACf,SAAQ,GAAoB,MAAoB,KAAK;GAEvD,QACE,OAAM,IAAI,MAAM,qBAAqB;;;;;;;;;CAW3C,oBAAoB,UAAyD;AAC3E,UAAQ,UAAR;GACE,KAAKD,WAAAA,UAAU,IACb,SAAQ,GAAG,MAAM,KAAK;GAExB,KAAKA,WAAAA,UAAU,GACb,SAAQ,GAAG,MAAM,KAAK;GAExB,QACE,OAAM,IAAI,MAAM,mBAAmB;;;;;;;;;CAWzC,eAAe,WAAoD;EACjE,MAAM,EAAE,UAAU,SAAS;AAC3B,MAAI,KAAK,iBAAiB,SAAS,SAAS,EAAE;GAC5C,MAAM,mBAAmB,KAAK,oBAAoB,SAAS;AAC3D,WAAQ,aAAuB;AAC7B,QAAI,CAAC,KACH,QAAO;AAGT,WAAO,KAAK,QAAQ,KAAK,QAAQ;KAC/B,MAAM,SAAS,IAAI,OAAO,KAAK;AAC/B,SAAI,OAAO,WAAW,WACpB,QAAO,iBAAiB,KAAK,OAAO,SAAS,CAAC;SAE9C,OAAM,IAAI,MAAM,2BAA2B;OAE5C,KAAK;;QAGV,OAAM,IAAI,MAAM,uBAAuB;;;;;;;;CAU3C,gBACE,YAC+B;EAC/B,MAAM,EAAE,YAAY,WAAW,UAAU;EACzC,MAAM,gBAAgB,CAACC,WAAAA,YAAY,GAAG;AACtC,MAAI,KAAK,mBAAmB,SAAS,WAAW,EAAE;AAChD,OACE,CAAC,KAAK,6BAA6B,OAAO,MAAM,CAAC,SAAS,WAAW,CAErE,OAAM,IAAI,MACR,IAAI,WAAW,2CAA2C,OAAO,QAClE;GAEH,MAAM,qBAAqB,KAAK,sBAAsB,WAAW;AACjE,WAAQ,aAAuB;IAC7B,MAAM,gBAAgB,SAAS,SAAS;AACxC,QAAI,kBAAkB,KAAA,GAAW;AAC/B,SAAI,cAAc,SAAS,WAAW,CACpC,QAAO;AAET,YAAO;;AAET,WAAO,mBAAmB,eAAeC,cAAAA,UAAU,MAAM,CAAC;;QAG5D,OAAM,IAAI,MAAM,yBAAyB;;;;;;;CAS7C,qBACE,OACoC;AACpC,MAAI,CAAC,MAAM,OACT,QAAO,EAAE;EAEX,MAAM,iBAAiB,MAAM,QAAQ,OAAO,KAAK;AACjD,MAAI,OAAO,mBAAmB,WAC5B,OAAM,IAAI,MAAM,4CAA4C;AAE9D,SAAO,EAAE,QAAQ,gBAAkC;;;;;;;;;CAUrD,aACE,eACA,iBACA,YAAY,OACgB;AAC5B,MAAIC,cAAAA,cAAc,cAAc,IAAIA,cAAAA,cAAc,gBAAgB,CAChE;AAEF,MAAIA,cAAAA,cAAc,cAAc,IAAI,cAAc,WAAW;AAC3D,OAAIA,cAAAA,cAAc,gBAAgB,CAChC;AAEF,UAAO;;AAET,MAAIA,cAAAA,cAAc,gBAAgB,EAAE;AAClC,OAAI,cAAc,MAChB;AAEF,UAAO;;AAGT,MAAI,cAAc,MAChB,SAAQ,aACN,cAAc,SAAS,IAAI,gBAAgB,SAAS;WAC7C,cAAc,KACvB,SAAQ,aACN,cAAc,SAAS,IAAI,gBAAgB,SAAS;MAEtD,OAAM,IAAI,MAAM,qBAAqB"}

package/dist/structured_query/functional.d.cts

@@ -3,7 +3,6 @@ import { Comparator, Comparison, Operation, Operator, StructuredQuery } from "./
 import { BaseTranslator } from "./base.cjs";
 
 //#region src/structured_query/functional.d.ts
-
 /**
  * A type alias for an object that maps comparison operators to string or
  * number values. This is used in the comparison functions to determine

package/dist/structured_query/functional.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"functional.d.cts","names":["Document","Comparator","Comparison","Operation","Operator","StructuredQuery","BaseTranslator","ValueType","FunctionFilter","FunctionalTranslator","C"],"sources":["../../src/structured_query/functional.d.ts"],"sourcesContent":["import { Document } from \"../documents/document.js\";\nimport { Comparator, Comparison, Operation, Operator, StructuredQuery } from \"./ir.js\";\nimport { BaseTranslator } from \"./base.js\";\n/**\n * A type alias for an object that maps comparison operators to string or\n * number values. This is used in the comparison functions to determine\n * the result of a comparison operation.\n */\ntype ValueType = {\n    eq: string | number | boolean;\n    ne: string | number | boolean;\n    lt: string | number;\n    lte: string | number;\n    gt: string | number;\n    gte: string | number;\n};\n/**\n * A type alias for a function that takes a `Document` as an argument and\n * returns a boolean. This function is used as a filter for documents.\n */\nexport type FunctionFilter = (document: Document) => boolean;\n/**\n * A class that extends `BaseTranslator` to translate structured queries\n * into functional filters.\n * @example\n * ```typescript\n * const functionalTranslator = new FunctionalTranslator();\n * const relevantDocuments = await functionalTranslator.getRelevantDocuments(\n *   \"Which movies are rated higher than 8.5?\",\n * );\n * ```\n */\nexport declare class FunctionalTranslator extends BaseTranslator {\n    VisitOperationOutput: FunctionFilter;\n    VisitComparisonOutput: FunctionFilter;\n    VisitStructuredQueryOutput: {\n        filter: FunctionFilter;\n    } | {\n        [k: string]: never;\n    };\n    allowedOperators: Operator[];\n    allowedComparators: Comparator[];\n    formatFunction(): string;\n    /**\n     * Returns the allowed comparators for a given data type.\n     * @param input The input value to get the allowed comparators for.\n     * @returns An array of allowed comparators for the input data type.\n     */\n    getAllowedComparatorsForType(inputType: string): Comparator[];\n    /**\n     * Returns a function that performs a comparison based on the provided\n     * comparator.\n     * @param comparator The comparator to base the comparison function on.\n     * @returns A function that takes two arguments and returns a boolean based on the comparison.\n     */\n    getComparatorFunction<C extends Comparator>(comparator: Comparator): (a: string | number, b: ValueType[C]) => boolean;\n    /**\n     * Returns a function that performs an operation based on the provided\n     * operator.\n     * @param operator The operator to base the operation function on.\n     * @returns A function that takes two boolean arguments and returns a boolean based on the operation.\n     */\n    getOperatorFunction(operator: Operator): (a: boolean, b: boolean) => boolean;\n    /**\n     * Visits the operation part of a structured query and translates it into\n     * a functional filter.\n     * @param operation The operation part of a structured query.\n     * @returns A function that takes a `Document` as an argument and returns a boolean based on the operation.\n     */\n    visitOperation(operation: Operation): this[\"VisitOperationOutput\"];\n    /**\n     * Visits the comparison part of a structured query and translates it into\n     * a functional filter.\n     * @param comparison The comparison part of a structured query.\n     * @returns A function that takes a `Document` as an argument and returns a boolean based on the comparison.\n     */\n    visitComparison(comparison: Comparison<string | number | boolean>): this[\"VisitComparisonOutput\"];\n    /**\n     * Visits a structured query and translates it into a functional filter.\n     * @param query The structured query to translate.\n     * @returns An object containing a `filter` property, which is a function that takes a `Document` as an argument and returns a boolean based on the structured query.\n     */\n    visitStructuredQuery(query: StructuredQuery): this[\"VisitStructuredQueryOutput\"];\n    /**\n     * Merges two filters into one, based on the specified merge type.\n     * @param defaultFilter The default filter function.\n     * @param generatedFilter The generated filter function.\n     * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'. Default is 'and'.\n     * @returns A function that takes a `Document` as an argument and returns a boolean based on the merged filters, or `undefined` if both filters are empty.\n     */\n    mergeFilters(defaultFilter: FunctionFilter, generatedFilter: FunctionFilter, mergeType?: string): FunctionFilter | undefined;\n}\nexport {};\n//# sourceMappingURL=functional.d.ts.map"],"mappings":";;;;;;;;AAE2C;AAkB3C;AAYA;KAxBKO,SAAAA,GAyBqBC;EACCA,EAAAA,EAAAA,MAAAA,GAAAA,MAAAA,GAAAA,OAAAA;EAEXA,EAAAA,EAAAA,MAAAA,GAAAA,MAAAA,GAAAA,OAAAA;EAIMJ,EAAAA,EAAAA,MAAAA,GAAAA,MAAAA;EACEH,GAAAA,EAAAA,MAAAA,GAAAA,MAAAA;EAO6BA,EAAAA,EAAAA,MAAAA,GAAAA,MAAAA;EAOjBA,GAAAA,EAAAA,MAAAA,GAAAA,MAAAA;CAAwBA;;;;;AAqB5BC,KAxDpBM,cAAAA,GAwDoBN,CAAAA,QAAAA,EAxDQF,QAwDRE,EAAAA,GAAAA,OAAAA;;;;;;AA5CgC;;;;;;cAA3CO,oBAAAA,SAA6BH,cAAAA;wBACxBE;yBACCA;;YAEXA;;;;oBAIMJ;sBACEH;;;;;;;mDAO6BA;;;;;;;kCAOjBA,wBAAwBA,qCAAqCM,UAAUG;;;;;;;gCAOzEN;;;;;;;4BAOJD;;;;;;;8BAOED;;;;;;8BAMAG;;;;;;;;8BAQAG,iCAAiCA,qCAAqCA"}
+{"version":3,"file":"functional.d.cts","names":[],"sources":["../../src/structured_query/functional.ts"],"mappings":";;;;;;;AAU2C;;;KAQtC,SAAA;EACH,EAAA;EACA,EAAA;EACA,EAAA;EACA,GAAA;EACA,EAAA;EACA,GAAA;AAAA;;AAOF;;;KAAY,cAAA,IAAkB,QAAA,EAAU,QAAA;;AAaxC;;;;;;;;;;cAAa,oBAAA,SAA6B,cAAA;EAChC,oBAAA,EAAsB,cAAA;EAEtB,qBAAA,EAAuB,cAAA;EAEvB,0BAAA;IACF,MAAA,EAAQ,cAAA;EAAA;IAAA,CACP,CAAA;EAAA;EAEP,gBAAA,EAAkB,QAAA;EAElB,kBAAA,EAAoB,UAAA;EASpB,cAAA,CAAA;EApBsD;;;;;EA6BtD,4BAAA,CAA6B,SAAA,WAAoB,UAAA;EA1BlB;;;;;;EA+D/B,qBAAA,WAAgC,UAAA,CAAA,CAC9B,UAAA,EAAY,UAAA,IACV,CAAA,mBAAoB,CAAA,EAAG,SAAA,CAAU,CAAA;EAzDrC;;;;;;EAyFA,mBAAA,CAAoB,QAAA,EAAU,QAAA,IAAY,CAAA,WAAY,CAAA;EAlChC;;;;;;EAsDtB,cAAA,CAAe,SAAA,EAAW,SAAA;EApDF;;;;;;EAiFxB,eAAA,CACE,UAAA,EAAY,UAAA;EA9BY;;;;;EA+D1B,oBAAA,CACE,KAAA,EAAO,eAAA;EAAA;;;;;;;EAmBT,YAAA,CACE,aAAA,EAAe,cAAA,EACf,eAAA,EAAiB,cAAA,EACjB,SAAA,YACC,cAAA;AAAA"}

package/dist/structured_query/functional.d.ts

@@ -3,7 +3,6 @@ import { Comparator, Comparison, Operation, Operator, StructuredQuery } from "./
 import { BaseTranslator } from "./base.js";
 
 //#region src/structured_query/functional.d.ts
-
 /**
  * A type alias for an object that maps comparison operators to string or
  * number values. This is used in the comparison functions to determine

package/dist/structured_query/functional.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"functional.d.ts","names":["Document","Comparator","Comparison","Operation","Operator","StructuredQuery","BaseTranslator","ValueType","FunctionFilter","FunctionalTranslator","C"],"sources":["../../src/structured_query/functional.d.ts"],"sourcesContent":["import { Document } from \"../documents/document.js\";\nimport { Comparator, Comparison, Operation, Operator, StructuredQuery } from \"./ir.js\";\nimport { BaseTranslator } from \"./base.js\";\n/**\n * A type alias for an object that maps comparison operators to string or\n * number values. This is used in the comparison functions to determine\n * the result of a comparison operation.\n */\ntype ValueType = {\n    eq: string | number | boolean;\n    ne: string | number | boolean;\n    lt: string | number;\n    lte: string | number;\n    gt: string | number;\n    gte: string | number;\n};\n/**\n * A type alias for a function that takes a `Document` as an argument and\n * returns a boolean. This function is used as a filter for documents.\n */\nexport type FunctionFilter = (document: Document) => boolean;\n/**\n * A class that extends `BaseTranslator` to translate structured queries\n * into functional filters.\n * @example\n * ```typescript\n * const functionalTranslator = new FunctionalTranslator();\n * const relevantDocuments = await functionalTranslator.getRelevantDocuments(\n *   \"Which movies are rated higher than 8.5?\",\n * );\n * ```\n */\nexport declare class FunctionalTranslator extends BaseTranslator {\n    VisitOperationOutput: FunctionFilter;\n    VisitComparisonOutput: FunctionFilter;\n    VisitStructuredQueryOutput: {\n        filter: FunctionFilter;\n    } | {\n        [k: string]: never;\n    };\n    allowedOperators: Operator[];\n    allowedComparators: Comparator[];\n    formatFunction(): string;\n    /**\n     * Returns the allowed comparators for a given data type.\n     * @param input The input value to get the allowed comparators for.\n     * @returns An array of allowed comparators for the input data type.\n     */\n    getAllowedComparatorsForType(inputType: string): Comparator[];\n    /**\n     * Returns a function that performs a comparison based on the provided\n     * comparator.\n     * @param comparator The comparator to base the comparison function on.\n     * @returns A function that takes two arguments and returns a boolean based on the comparison.\n     */\n    getComparatorFunction<C extends Comparator>(comparator: Comparator): (a: string | number, b: ValueType[C]) => boolean;\n    /**\n     * Returns a function that performs an operation based on the provided\n     * operator.\n     * @param operator The operator to base the operation function on.\n     * @returns A function that takes two boolean arguments and returns a boolean based on the operation.\n     */\n    getOperatorFunction(operator: Operator): (a: boolean, b: boolean) => boolean;\n    /**\n     * Visits the operation part of a structured query and translates it into\n     * a functional filter.\n     * @param operation The operation part of a structured query.\n     * @returns A function that takes a `Document` as an argument and returns a boolean based on the operation.\n     */\n    visitOperation(operation: Operation): this[\"VisitOperationOutput\"];\n    /**\n     * Visits the comparison part of a structured query and translates it into\n     * a functional filter.\n     * @param comparison The comparison part of a structured query.\n     * @returns A function that takes a `Document` as an argument and returns a boolean based on the comparison.\n     */\n    visitComparison(comparison: Comparison<string | number | boolean>): this[\"VisitComparisonOutput\"];\n    /**\n     * Visits a structured query and translates it into a functional filter.\n     * @param query The structured query to translate.\n     * @returns An object containing a `filter` property, which is a function that takes a `Document` as an argument and returns a boolean based on the structured query.\n     */\n    visitStructuredQuery(query: StructuredQuery): this[\"VisitStructuredQueryOutput\"];\n    /**\n     * Merges two filters into one, based on the specified merge type.\n     * @param defaultFilter The default filter function.\n     * @param generatedFilter The generated filter function.\n     * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'. Default is 'and'.\n     * @returns A function that takes a `Document` as an argument and returns a boolean based on the merged filters, or `undefined` if both filters are empty.\n     */\n    mergeFilters(defaultFilter: FunctionFilter, generatedFilter: FunctionFilter, mergeType?: string): FunctionFilter | undefined;\n}\nexport {};\n//# sourceMappingURL=functional.d.ts.map"],"mappings":";;;;;;;;AAE2C;AAkB3C;AAYA;KAxBKO,SAAAA,GAyBqBC;EACCA,EAAAA,EAAAA,MAAAA,GAAAA,MAAAA,GAAAA,OAAAA;EAEXA,EAAAA,EAAAA,MAAAA,GAAAA,MAAAA,GAAAA,OAAAA;EAIMJ,EAAAA,EAAAA,MAAAA,GAAAA,MAAAA;EACEH,GAAAA,EAAAA,MAAAA,GAAAA,MAAAA;EAO6BA,EAAAA,EAAAA,MAAAA,GAAAA,MAAAA;EAOjBA,GAAAA,EAAAA,MAAAA,GAAAA,MAAAA;CAAwBA;;;;;AAqB5BC,KAxDpBM,cAAAA,GAwDoBN,CAAAA,QAAAA,EAxDQF,QAwDRE,EAAAA,GAAAA,OAAAA;;;;;;AA5CgC;;;;;;cAA3CO,oBAAAA,SAA6BH,cAAAA;wBACxBE;yBACCA;;YAEXA;;;;oBAIMJ;sBACEH;;;;;;;mDAO6BA;;;;;;;kCAOjBA,wBAAwBA,qCAAqCM,UAAUG;;;;;;;gCAOzEN;;;;;;;4BAOJD;;;;;;;8BAOED;;;;;;8BAMAG;;;;;;;;8BAQAG,iCAAiCA,qCAAqCA"}
+{"version":3,"file":"functional.d.ts","names":[],"sources":["../../src/structured_query/functional.ts"],"mappings":";;;;;;;AAU2C;;;KAQtC,SAAA;EACH,EAAA;EACA,EAAA;EACA,EAAA;EACA,GAAA;EACA,EAAA;EACA,GAAA;AAAA;;AAOF;;;KAAY,cAAA,IAAkB,QAAA,EAAU,QAAA;;AAaxC;;;;;;;;;;cAAa,oBAAA,SAA6B,cAAA;EAChC,oBAAA,EAAsB,cAAA;EAEtB,qBAAA,EAAuB,cAAA;EAEvB,0BAAA;IACF,MAAA,EAAQ,cAAA;EAAA;IAAA,CACP,CAAA;EAAA;EAEP,gBAAA,EAAkB,QAAA;EAElB,kBAAA,EAAoB,UAAA;EASpB,cAAA,CAAA;EApBsD;;;;;EA6BtD,4BAAA,CAA6B,SAAA,WAAoB,UAAA;EA1BlB;;;;;;EA+D/B,qBAAA,WAAgC,UAAA,CAAA,CAC9B,UAAA,EAAY,UAAA,IACV,CAAA,mBAAoB,CAAA,EAAG,SAAA,CAAU,CAAA;EAzDrC;;;;;;EAyFA,mBAAA,CAAoB,QAAA,EAAU,QAAA,IAAY,CAAA,WAAY,CAAA;EAlChC;;;;;;EAsDtB,cAAA,CAAe,SAAA,EAAW,SAAA;EApDF;;;;;;EAiFxB,eAAA,CACE,UAAA,EAAY,UAAA;EA9BY;;;;;EA+D1B,oBAAA,CACE,KAAA,EAAO,eAAA;EAAA;;;;;;;EAmBT,YAAA,CACE,aAAA,EAAe,cAAA,EACf,eAAA,EAAiB,cAAA,EACjB,SAAA,YACC,cAAA;AAAA"}

package/dist/structured_query/functional.js

@@ -1,7 +1,6 @@
 import { Comparators, Operators } from "./ir.js";
 import { castValue, isFilterEmpty } from "./utils.js";
 import { BaseTranslator } from "./base.js";
-
 //#region src/structured_query/functional.ts
 /**
 * A class that extends `BaseTranslator` to translate structured queries
@@ -145,13 +144,13 @@ var FunctionalTranslator = class extends BaseTranslator {
 	* @returns A function that takes a `Document` as an argument and returns a boolean based on the merged filters, or `undefined` if both filters are empty.
 	*/
 	mergeFilters(defaultFilter, generatedFilter, mergeType = "and") {
-		if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) return void 0;
+		if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) return;
 		if (isFilterEmpty(defaultFilter) || mergeType === "replace") {
-			if (isFilterEmpty(generatedFilter)) return void 0;
+			if (isFilterEmpty(generatedFilter)) return;
 			return generatedFilter;
 		}
 		if (isFilterEmpty(generatedFilter)) {
-			if (mergeType === "and") return void 0;
+			if (mergeType === "and") return;
 			return defaultFilter;
 		}
 		if (mergeType === "and") return (document) => defaultFilter(document) && generatedFilter(document);
@@ -159,7 +158,7 @@ var FunctionalTranslator = class extends BaseTranslator {
 		else throw new Error("Unknown merge type");
 	}
 };
-
 //#endregion
 export { FunctionalTranslator };
+
 //# sourceMappingURL=functional.js.map

package/dist/structured_query/functional.js.map

@@ -1 +1 @@
-{"version":3,"file":"functional.js","names":["inputType: string","comparator: Comparator","a: string | number","b: ValueType[C]","operator: Operator","operation: Operation","document: Document","comparison: Comparison<string | number | boolean>","query: StructuredQuery","defaultFilter: FunctionFilter","generatedFilter: FunctionFilter"],"sources":["../../src/structured_query/functional.ts"],"sourcesContent":["import { Document } from \"../documents/document.js\";\nimport {\n  Comparator,\n  Comparators,\n  Comparison,\n  Operation,\n  Operator,\n  Operators,\n  StructuredQuery,\n} from \"./ir.js\";\nimport { BaseTranslator } from \"./base.js\";\nimport { castValue, isFilterEmpty } from \"./utils.js\";\n\n/**\n * A type alias for an object that maps comparison operators to string or\n * number values. This is used in the comparison functions to determine\n * the result of a comparison operation.\n */\ntype ValueType = {\n  eq: string | number | boolean;\n  ne: string | number | boolean;\n  lt: string | number;\n  lte: string | number;\n  gt: string | number;\n  gte: string | number;\n};\n\n/**\n * A type alias for a function that takes a `Document` as an argument and\n * returns a boolean. This function is used as a filter for documents.\n */\nexport type FunctionFilter = (document: Document) => boolean;\n\n/**\n * A class that extends `BaseTranslator` to translate structured queries\n * into functional filters.\n * @example\n * ```typescript\n * const functionalTranslator = new FunctionalTranslator();\n * const relevantDocuments = await functionalTranslator.getRelevantDocuments(\n *   \"Which movies are rated higher than 8.5?\",\n * );\n * ```\n */\nexport class FunctionalTranslator extends BaseTranslator {\n  declare VisitOperationOutput: FunctionFilter;\n\n  declare VisitComparisonOutput: FunctionFilter;\n\n  declare VisitStructuredQueryOutput:\n    | { filter: FunctionFilter }\n    | { [k: string]: never };\n\n  allowedOperators: Operator[] = [Operators.and, Operators.or];\n\n  allowedComparators: Comparator[] = [\n    Comparators.eq,\n    Comparators.ne,\n    Comparators.gt,\n    Comparators.gte,\n    Comparators.lt,\n    Comparators.lte,\n  ];\n\n  formatFunction(): string {\n    throw new Error(\"Not implemented\");\n  }\n\n  /**\n   * Returns the allowed comparators for a given data type.\n   * @param input The input value to get the allowed comparators for.\n   * @returns An array of allowed comparators for the input data type.\n   */\n  getAllowedComparatorsForType(inputType: string): Comparator[] {\n    switch (inputType) {\n      case \"string\": {\n        return [\n          Comparators.eq,\n          Comparators.ne,\n          Comparators.gt,\n          Comparators.gte,\n          Comparators.lt,\n          Comparators.lte,\n        ];\n      }\n      case \"number\": {\n        return [\n          Comparators.eq,\n          Comparators.ne,\n          Comparators.gt,\n          Comparators.gte,\n          Comparators.lt,\n          Comparators.lte,\n        ];\n      }\n      case \"boolean\": {\n        return [Comparators.eq, Comparators.ne];\n      }\n      default: {\n        throw new Error(`Unsupported data type: ${inputType}`);\n      }\n    }\n  }\n\n  /**\n   * Returns a function that performs a comparison based on the provided\n   * comparator.\n   * @param comparator The comparator to base the comparison function on.\n   * @returns A function that takes two arguments and returns a boolean based on the comparison.\n   */\n  getComparatorFunction<C extends Comparator>(\n    comparator: Comparator\n  ): (a: string | number, b: ValueType[C]) => boolean {\n    switch (comparator) {\n      case Comparators.eq: {\n        return (a: string | number, b: ValueType[C]) => a === b;\n      }\n      case Comparators.ne: {\n        return (a: string | number, b: ValueType[C]) => a !== b;\n      }\n      case Comparators.gt: {\n        return (a: string | number, b: ValueType[C]) => a > b;\n      }\n      case Comparators.gte: {\n        return (a: string | number, b: ValueType[C]) => a >= b;\n      }\n      case Comparators.lt: {\n        return (a: string | number, b: ValueType[C]) => a < b;\n      }\n      case Comparators.lte: {\n        return (a: string | number, b: ValueType[C]) => a <= b;\n      }\n      default: {\n        throw new Error(\"Unknown comparator\");\n      }\n    }\n  }\n\n  /**\n   * Returns a function that performs an operation based on the provided\n   * operator.\n   * @param operator The operator to base the operation function on.\n   * @returns A function that takes two boolean arguments and returns a boolean based on the operation.\n   */\n  getOperatorFunction(operator: Operator): (a: boolean, b: boolean) => boolean {\n    switch (operator) {\n      case Operators.and: {\n        return (a, b) => a && b;\n      }\n      case Operators.or: {\n        return (a, b) => a || b;\n      }\n      default: {\n        throw new Error(\"Unknown operator\");\n      }\n    }\n  }\n\n  /**\n   * Visits the operation part of a structured query and translates it into\n   * a functional filter.\n   * @param operation The operation part of a structured query.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the operation.\n   */\n  visitOperation(operation: Operation): this[\"VisitOperationOutput\"] {\n    const { operator, args } = operation;\n    if (this.allowedOperators.includes(operator)) {\n      const operatorFunction = this.getOperatorFunction(operator);\n      return (document: Document) => {\n        if (!args) {\n          return true;\n        }\n\n        return args.reduce((acc, arg) => {\n          const result = arg.accept(this);\n          if (typeof result === \"function\") {\n            return operatorFunction(acc, result(document));\n          } else {\n            throw new Error(\"Filter is not a function\");\n          }\n        }, true);\n      };\n    } else {\n      throw new Error(\"Operator not allowed\");\n    }\n  }\n\n  /**\n   * Visits the comparison part of a structured query and translates it into\n   * a functional filter.\n   * @param comparison The comparison part of a structured query.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the comparison.\n   */\n  visitComparison(\n    comparison: Comparison<string | number | boolean>\n  ): this[\"VisitComparisonOutput\"] {\n    const { comparator, attribute, value } = comparison;\n    const undefinedTrue = [Comparators.ne];\n    if (this.allowedComparators.includes(comparator)) {\n      if (\n        !this.getAllowedComparatorsForType(typeof value).includes(comparator)\n      ) {\n        throw new Error(\n          `'${comparator}' comparator not allowed to be used with ${typeof value}`\n        );\n      }\n      const comparatorFunction = this.getComparatorFunction(comparator);\n      return (document: Document) => {\n        const documentValue = document.metadata[attribute];\n        if (documentValue === undefined) {\n          if (undefinedTrue.includes(comparator)) {\n            return true;\n          }\n          return false;\n        }\n        return comparatorFunction(documentValue, castValue(value));\n      };\n    } else {\n      throw new Error(\"Comparator not allowed\");\n    }\n  }\n\n  /**\n   * Visits a structured query and translates it into a functional filter.\n   * @param query The structured query to translate.\n   * @returns An object containing a `filter` property, which is a function that takes a `Document` as an argument and returns a boolean based on the structured query.\n   */\n  visitStructuredQuery(\n    query: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"] {\n    if (!query.filter) {\n      return {};\n    }\n    const filterFunction = query.filter?.accept(this);\n    if (typeof filterFunction !== \"function\") {\n      throw new Error(\"Structured query filter is not a function\");\n    }\n    return { filter: filterFunction as FunctionFilter };\n  }\n\n  /**\n   * Merges two filters into one, based on the specified merge type.\n   * @param defaultFilter The default filter function.\n   * @param generatedFilter The generated filter function.\n   * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'. Default is 'and'.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the merged filters, or `undefined` if both filters are empty.\n   */\n  mergeFilters(\n    defaultFilter: FunctionFilter,\n    generatedFilter: FunctionFilter,\n    mergeType = \"and\"\n  ): FunctionFilter | undefined {\n    if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) {\n      return undefined;\n    }\n    if (isFilterEmpty(defaultFilter) || mergeType === \"replace\") {\n      if (isFilterEmpty(generatedFilter)) {\n        return undefined;\n      }\n      return generatedFilter;\n    }\n    if (isFilterEmpty(generatedFilter)) {\n      if (mergeType === \"and\") {\n        return undefined;\n      }\n      return defaultFilter;\n    }\n\n    if (mergeType === \"and\") {\n      return (document: Document) =>\n        defaultFilter(document) && generatedFilter(document);\n    } else if (mergeType === \"or\") {\n      return (document: Document) =>\n        defaultFilter(document) || generatedFilter(document);\n    } else {\n      throw new Error(\"Unknown merge type\");\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"functional.js","names":[],"sources":["../../src/structured_query/functional.ts"],"sourcesContent":["import { Document } from \"../documents/document.js\";\nimport {\n  Comparator,\n  Comparators,\n  Comparison,\n  Operation,\n  Operator,\n  Operators,\n  StructuredQuery,\n} from \"./ir.js\";\nimport { BaseTranslator } from \"./base.js\";\nimport { castValue, isFilterEmpty } from \"./utils.js\";\n\n/**\n * A type alias for an object that maps comparison operators to string or\n * number values. This is used in the comparison functions to determine\n * the result of a comparison operation.\n */\ntype ValueType = {\n  eq: string | number | boolean;\n  ne: string | number | boolean;\n  lt: string | number;\n  lte: string | number;\n  gt: string | number;\n  gte: string | number;\n};\n\n/**\n * A type alias for a function that takes a `Document` as an argument and\n * returns a boolean. This function is used as a filter for documents.\n */\nexport type FunctionFilter = (document: Document) => boolean;\n\n/**\n * A class that extends `BaseTranslator` to translate structured queries\n * into functional filters.\n * @example\n * ```typescript\n * const functionalTranslator = new FunctionalTranslator();\n * const relevantDocuments = await functionalTranslator.getRelevantDocuments(\n *   \"Which movies are rated higher than 8.5?\",\n * );\n * ```\n */\nexport class FunctionalTranslator extends BaseTranslator {\n  declare VisitOperationOutput: FunctionFilter;\n\n  declare VisitComparisonOutput: FunctionFilter;\n\n  declare VisitStructuredQueryOutput:\n    | { filter: FunctionFilter }\n    | { [k: string]: never };\n\n  allowedOperators: Operator[] = [Operators.and, Operators.or];\n\n  allowedComparators: Comparator[] = [\n    Comparators.eq,\n    Comparators.ne,\n    Comparators.gt,\n    Comparators.gte,\n    Comparators.lt,\n    Comparators.lte,\n  ];\n\n  formatFunction(): string {\n    throw new Error(\"Not implemented\");\n  }\n\n  /**\n   * Returns the allowed comparators for a given data type.\n   * @param input The input value to get the allowed comparators for.\n   * @returns An array of allowed comparators for the input data type.\n   */\n  getAllowedComparatorsForType(inputType: string): Comparator[] {\n    switch (inputType) {\n      case \"string\": {\n        return [\n          Comparators.eq,\n          Comparators.ne,\n          Comparators.gt,\n          Comparators.gte,\n          Comparators.lt,\n          Comparators.lte,\n        ];\n      }\n      case \"number\": {\n        return [\n          Comparators.eq,\n          Comparators.ne,\n          Comparators.gt,\n          Comparators.gte,\n          Comparators.lt,\n          Comparators.lte,\n        ];\n      }\n      case \"boolean\": {\n        return [Comparators.eq, Comparators.ne];\n      }\n      default: {\n        throw new Error(`Unsupported data type: ${inputType}`);\n      }\n    }\n  }\n\n  /**\n   * Returns a function that performs a comparison based on the provided\n   * comparator.\n   * @param comparator The comparator to base the comparison function on.\n   * @returns A function that takes two arguments and returns a boolean based on the comparison.\n   */\n  getComparatorFunction<C extends Comparator>(\n    comparator: Comparator\n  ): (a: string | number, b: ValueType[C]) => boolean {\n    switch (comparator) {\n      case Comparators.eq: {\n        return (a: string | number, b: ValueType[C]) => a === b;\n      }\n      case Comparators.ne: {\n        return (a: string | number, b: ValueType[C]) => a !== b;\n      }\n      case Comparators.gt: {\n        return (a: string | number, b: ValueType[C]) => a > b;\n      }\n      case Comparators.gte: {\n        return (a: string | number, b: ValueType[C]) => a >= b;\n      }\n      case Comparators.lt: {\n        return (a: string | number, b: ValueType[C]) => a < b;\n      }\n      case Comparators.lte: {\n        return (a: string | number, b: ValueType[C]) => a <= b;\n      }\n      default: {\n        throw new Error(\"Unknown comparator\");\n      }\n    }\n  }\n\n  /**\n   * Returns a function that performs an operation based on the provided\n   * operator.\n   * @param operator The operator to base the operation function on.\n   * @returns A function that takes two boolean arguments and returns a boolean based on the operation.\n   */\n  getOperatorFunction(operator: Operator): (a: boolean, b: boolean) => boolean {\n    switch (operator) {\n      case Operators.and: {\n        return (a, b) => a && b;\n      }\n      case Operators.or: {\n        return (a, b) => a || b;\n      }\n      default: {\n        throw new Error(\"Unknown operator\");\n      }\n    }\n  }\n\n  /**\n   * Visits the operation part of a structured query and translates it into\n   * a functional filter.\n   * @param operation The operation part of a structured query.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the operation.\n   */\n  visitOperation(operation: Operation): this[\"VisitOperationOutput\"] {\n    const { operator, args } = operation;\n    if (this.allowedOperators.includes(operator)) {\n      const operatorFunction = this.getOperatorFunction(operator);\n      return (document: Document) => {\n        if (!args) {\n          return true;\n        }\n\n        return args.reduce((acc, arg) => {\n          const result = arg.accept(this);\n          if (typeof result === \"function\") {\n            return operatorFunction(acc, result(document));\n          } else {\n            throw new Error(\"Filter is not a function\");\n          }\n        }, true);\n      };\n    } else {\n      throw new Error(\"Operator not allowed\");\n    }\n  }\n\n  /**\n   * Visits the comparison part of a structured query and translates it into\n   * a functional filter.\n   * @param comparison The comparison part of a structured query.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the comparison.\n   */\n  visitComparison(\n    comparison: Comparison<string | number | boolean>\n  ): this[\"VisitComparisonOutput\"] {\n    const { comparator, attribute, value } = comparison;\n    const undefinedTrue = [Comparators.ne];\n    if (this.allowedComparators.includes(comparator)) {\n      if (\n        !this.getAllowedComparatorsForType(typeof value).includes(comparator)\n      ) {\n        throw new Error(\n          `'${comparator}' comparator not allowed to be used with ${typeof value}`\n        );\n      }\n      const comparatorFunction = this.getComparatorFunction(comparator);\n      return (document: Document) => {\n        const documentValue = document.metadata[attribute];\n        if (documentValue === undefined) {\n          if (undefinedTrue.includes(comparator)) {\n            return true;\n          }\n          return false;\n        }\n        return comparatorFunction(documentValue, castValue(value));\n      };\n    } else {\n      throw new Error(\"Comparator not allowed\");\n    }\n  }\n\n  /**\n   * Visits a structured query and translates it into a functional filter.\n   * @param query The structured query to translate.\n   * @returns An object containing a `filter` property, which is a function that takes a `Document` as an argument and returns a boolean based on the structured query.\n   */\n  visitStructuredQuery(\n    query: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"] {\n    if (!query.filter) {\n      return {};\n    }\n    const filterFunction = query.filter?.accept(this);\n    if (typeof filterFunction !== \"function\") {\n      throw new Error(\"Structured query filter is not a function\");\n    }\n    return { filter: filterFunction as FunctionFilter };\n  }\n\n  /**\n   * Merges two filters into one, based on the specified merge type.\n   * @param defaultFilter The default filter function.\n   * @param generatedFilter The generated filter function.\n   * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'. Default is 'and'.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the merged filters, or `undefined` if both filters are empty.\n   */\n  mergeFilters(\n    defaultFilter: FunctionFilter,\n    generatedFilter: FunctionFilter,\n    mergeType = \"and\"\n  ): FunctionFilter | undefined {\n    if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) {\n      return undefined;\n    }\n    if (isFilterEmpty(defaultFilter) || mergeType === \"replace\") {\n      if (isFilterEmpty(generatedFilter)) {\n        return undefined;\n      }\n      return generatedFilter;\n    }\n    if (isFilterEmpty(generatedFilter)) {\n      if (mergeType === \"and\") {\n        return undefined;\n      }\n      return defaultFilter;\n    }\n\n    if (mergeType === \"and\") {\n      return (document: Document) =>\n        defaultFilter(document) && generatedFilter(document);\n    } else if (mergeType === \"or\") {\n      return (document: Document) =>\n        defaultFilter(document) || generatedFilter(document);\n    } else {\n      throw new Error(\"Unknown merge type\");\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/structured_query/index.cjs

@@ -1,12 +1,11 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
-const require_ir = require('./ir.cjs');
-const require_utils = require('./utils.cjs');
-const require_base = require('./base.cjs');
-const require_functional = require('./functional.cjs');
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_ir = require("./ir.cjs");
+const require_utils = require("./utils.cjs");
+const require_base = require("./base.cjs");
+const require_functional = require("./functional.cjs");
 //#region src/structured_query/index.ts
-var structured_query_exports = {};
-require_rolldown_runtime.__export(structured_query_exports, {
+var structured_query_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	BaseTranslator: () => require_base.BaseTranslator,
 	BasicTranslator: () => require_base.BasicTranslator,
 	Comparators: () => require_ir.Comparators,
@@ -26,7 +25,6 @@ require_rolldown_runtime.__export(structured_query_exports, {
 	isObject: () => require_utils.isObject,
 	isString: () => require_utils.isString
 });
-
 //#endregion
 exports.BaseTranslator = require_base.BaseTranslator;
 exports.BasicTranslator = require_base.BasicTranslator;
@@ -46,10 +44,11 @@ exports.isFloat = require_utils.isFloat;
 exports.isInt = require_utils.isInt;
 exports.isObject = require_utils.isObject;
 exports.isString = require_utils.isString;
-Object.defineProperty(exports, 'structured_query_exports', {
-  enumerable: true,
-  get: function () {
-    return structured_query_exports;
-  }
+Object.defineProperty(exports, "structured_query_exports", {
+	enumerable: true,
+	get: function() {
+		return structured_query_exports;
+	}
 });
+
 //# sourceMappingURL=index.cjs.map

package/dist/structured_query/index.js

@@ -1,12 +1,10 @@
-import { __export } from "../_virtual/rolldown_runtime.js";
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
 import { Comparators, Comparison, Expression, FilterDirective, Operation, Operators, StructuredQuery, Visitor } from "./ir.js";
 import { castValue, isBoolean, isFilterEmpty, isFloat, isInt, isObject, isString } from "./utils.js";
 import { BaseTranslator, BasicTranslator } from "./base.js";
 import { FunctionalTranslator } from "./functional.js";
-
 //#region src/structured_query/index.ts
-var structured_query_exports = {};
-__export(structured_query_exports, {
+var structured_query_exports = /* @__PURE__ */ __exportAll({
 	BaseTranslator: () => BaseTranslator,
 	BasicTranslator: () => BasicTranslator,
 	Comparators: () => Comparators,
@@ -26,7 +24,7 @@ __export(structured_query_exports, {
 	isObject: () => isObject,
 	isString: () => isString
 });
-
 //#endregion
 export { BaseTranslator, BasicTranslator, Comparators, Comparison, Expression, FilterDirective, FunctionalTranslator, Operation, Operators, StructuredQuery, Visitor, castValue, isBoolean, isFilterEmpty, isFloat, isInt, isObject, isString, structured_query_exports };
+
 //# sourceMappingURL=index.js.map

package/dist/structured_query/ir.cjs

@@ -1,4 +1,3 @@
-
 //#region src/structured_query/ir.ts
 const Operators = {
 	and: "and",
@@ -72,7 +71,6 @@ var StructuredQuery = class extends Expression {
 		this.filter = filter;
 	}
 };
-
 //#endregion
 exports.Comparators = Comparators;
 exports.Comparison = Comparison;
@@ -82,4 +80,5 @@ exports.Operation = Operation;
 exports.Operators = Operators;
 exports.StructuredQuery = StructuredQuery;
 exports.Visitor = Visitor;
+
 //# sourceMappingURL=ir.cjs.map

package/dist/structured_query/ir.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"ir.cjs","names":["Operators: { [key: string]: Operator }","Comparators: { [key: string]: Comparator }","visitor: Visitor","comparator: Comparator","attribute: string","value: ValueTypes","operator: Operator","args?: FilterDirective[]","query: string","filter?: FilterDirective"],"sources":["../../src/structured_query/ir.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\n\n/**\n * Represents logical AND operator.\n */\nexport type AND = \"and\";\n/**\n * Represents logical OR operator.\n */\nexport type OR = \"or\";\n/**\n * Represents logical NOT operator.\n */\nexport type NOT = \"not\";\n\n/**\n * Represents a logical operator which can be AND, OR, or NOT.\n */\nexport type Operator = AND | OR | NOT;\n\n/**\n * Represents equality comparison operator.\n */\nexport type EQ = \"eq\";\n/**\n * Represents inequality comparison operator.\n */\nexport type NE = \"ne\";\n/**\n * Represents less than comparison operator.\n */\nexport type LT = \"lt\";\n/**\n * Represents greater than comparison operator.\n */\nexport type GT = \"gt\";\n/**\n * Represents less than or equal to comparison operator.\n */\nexport type LTE = \"lte\";\n/**\n * Represents greater than or equal to comparison operator.\n */\nexport type GTE = \"gte\";\n\n/**\n * Represents a comparison operator which can be EQ, NE, LT, GT, LTE, or\n * GTE.\n */\nexport type Comparator = EQ | NE | LT | GT | LTE | GTE;\n\nexport const Operators: { [key: string]: Operator } = {\n  and: \"and\",\n  or: \"or\",\n  not: \"not\",\n};\n\nexport const Comparators: { [key: string]: Comparator } = {\n  eq: \"eq\",\n  ne: \"ne\",\n  lt: \"lt\",\n  gt: \"gt\",\n  lte: \"lte\",\n  gte: \"gte\",\n};\n\n/**\n * Represents the result of visiting an operation or comparison\n * expression.\n */\nexport type VisitorResult = VisitorOperationResult | VisitorComparisonResult;\n\n/**\n * Represents the result of visiting an operation expression.\n */\nexport type VisitorOperationResult = {\n  [operator: string]: VisitorResult[];\n};\n\n/**\n * Represents the result of visiting a comparison expression.\n */\nexport type VisitorComparisonResult = {\n  [attr: string]: {\n    [comparator: string]: string | number | boolean;\n  };\n};\n\n/**\n * Represents the result of visiting a structured query expression.\n */\nexport type VisitorStructuredQueryResult = {\n  filter?: VisitorComparisonResult | VisitorOperationResult;\n};\n\n/**\n * Abstract class for visiting expressions. Subclasses must implement\n * visitOperation, visitComparison, and visitStructuredQuery methods.\n */\nexport abstract class Visitor<T extends VectorStore = VectorStore> {\n  declare VisitOperationOutput: object;\n\n  declare VisitComparisonOutput: object;\n\n  declare VisitStructuredQueryOutput: { filter?: T[\"FilterType\"] };\n\n  abstract allowedOperators: Operator[];\n\n  abstract allowedComparators: Comparator[];\n\n  abstract visitOperation(operation: Operation): this[\"VisitOperationOutput\"];\n\n  abstract visitComparison(\n    comparison: Comparison\n  ): this[\"VisitComparisonOutput\"];\n\n  abstract visitStructuredQuery(\n    structuredQuery: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"];\n}\n\n/**\n * Abstract class representing an expression. Subclasses must implement\n * the exprName property and the accept method.\n */\nexport abstract class Expression {\n  abstract exprName: \"Operation\" | \"Comparison\" | \"StructuredQuery\";\n\n  accept(visitor: Visitor) {\n    if (this.exprName === \"Operation\") {\n      return visitor.visitOperation(this as unknown as Operation);\n    } else if (this.exprName === \"Comparison\") {\n      return visitor.visitComparison(this as unknown as Comparison);\n    } else if (this.exprName === \"StructuredQuery\") {\n      return visitor.visitStructuredQuery(this as unknown as StructuredQuery);\n    } else {\n      throw new Error(\"Unknown Expression type\");\n    }\n  }\n}\n\n/**\n * Abstract class representing a filter directive. It extends the\n * Expression class.\n */\nexport abstract class FilterDirective extends Expression {}\n\n/**\n * Class representing a comparison filter directive. It extends the\n * FilterDirective class.\n */\nexport class Comparison<ValueTypes = string | number> extends FilterDirective {\n  exprName = \"Comparison\" as const;\n\n  constructor(\n    public comparator: Comparator,\n    public attribute: string,\n    public value: ValueTypes\n  ) {\n    super();\n  }\n}\n\n/**\n * Class representing an operation filter directive. It extends the\n * FilterDirective class.\n */\nexport class Operation extends FilterDirective {\n  exprName = \"Operation\" as const;\n\n  constructor(public operator: Operator, public args?: FilterDirective[]) {\n    super();\n  }\n}\n\n/**\n * Class representing a structured query expression. It extends the\n * Expression class.\n */\nexport class StructuredQuery extends Expression {\n  exprName = \"StructuredQuery\" as const;\n\n  constructor(public query: string, public filter?: FilterDirective) {\n    super();\n  }\n}\n"],"mappings":";;AAmDA,MAAaA,YAAyC;CACpD,KAAK;CACL,IAAI;CACJ,KAAK;AACN;AAED,MAAaC,cAA6C;CACxD,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,KAAK;CACL,KAAK;AACN;;;;;AAmCD,IAAsB,UAAtB,MAAmE,CAoBlE;;;;;AAMD,IAAsB,aAAtB,MAAiC;CAG/B,OAAOC,SAAkB;AACvB,MAAI,KAAK,aAAa,YACpB,QAAO,QAAQ,eAAe,KAA6B;WAClD,KAAK,aAAa,aAC3B,QAAO,QAAQ,gBAAgB,KAA8B;WACpD,KAAK,aAAa,kBAC3B,QAAO,QAAQ,qBAAqB,KAAmC;MAEvE,OAAM,IAAI,MAAM;CAEnB;AACF;;;;;AAMD,IAAsB,kBAAtB,cAA8C,WAAW,CAAE;;;;;AAM3D,IAAa,aAAb,cAA8D,gBAAgB;CAC5E,WAAW;CAEX,YACSC,YACAC,WACAC,OACP;EACA,OAAO;EAJA;EACA;EACA;CAGR;AACF;;;;;AAMD,IAAa,YAAb,cAA+B,gBAAgB;CAC7C,WAAW;CAEX,YAAmBC,UAA2BC,MAA0B;EACtE,OAAO;EADU;EAA2B;CAE7C;AACF;;;;;AAMD,IAAa,kBAAb,cAAqC,WAAW;CAC9C,WAAW;CAEX,YAAmBC,OAAsBC,QAA0B;EACjE,OAAO;EADU;EAAsB;CAExC;AACF"}
+{"version":3,"file":"ir.cjs","names":[],"sources":["../../src/structured_query/ir.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\n\n/**\n * Represents logical AND operator.\n */\nexport type AND = \"and\";\n/**\n * Represents logical OR operator.\n */\nexport type OR = \"or\";\n/**\n * Represents logical NOT operator.\n */\nexport type NOT = \"not\";\n\n/**\n * Represents a logical operator which can be AND, OR, or NOT.\n */\nexport type Operator = AND | OR | NOT;\n\n/**\n * Represents equality comparison operator.\n */\nexport type EQ = \"eq\";\n/**\n * Represents inequality comparison operator.\n */\nexport type NE = \"ne\";\n/**\n * Represents less than comparison operator.\n */\nexport type LT = \"lt\";\n/**\n * Represents greater than comparison operator.\n */\nexport type GT = \"gt\";\n/**\n * Represents less than or equal to comparison operator.\n */\nexport type LTE = \"lte\";\n/**\n * Represents greater than or equal to comparison operator.\n */\nexport type GTE = \"gte\";\n\n/**\n * Represents a comparison operator which can be EQ, NE, LT, GT, LTE, or\n * GTE.\n */\nexport type Comparator = EQ | NE | LT | GT | LTE | GTE;\n\nexport const Operators: { [key: string]: Operator } = {\n  and: \"and\",\n  or: \"or\",\n  not: \"not\",\n};\n\nexport const Comparators: { [key: string]: Comparator } = {\n  eq: \"eq\",\n  ne: \"ne\",\n  lt: \"lt\",\n  gt: \"gt\",\n  lte: \"lte\",\n  gte: \"gte\",\n};\n\n/**\n * Represents the result of visiting an operation or comparison\n * expression.\n */\nexport type VisitorResult = VisitorOperationResult | VisitorComparisonResult;\n\n/**\n * Represents the result of visiting an operation expression.\n */\nexport type VisitorOperationResult = {\n  [operator: string]: VisitorResult[];\n};\n\n/**\n * Represents the result of visiting a comparison expression.\n */\nexport type VisitorComparisonResult = {\n  [attr: string]: {\n    [comparator: string]: string | number | boolean;\n  };\n};\n\n/**\n * Represents the result of visiting a structured query expression.\n */\nexport type VisitorStructuredQueryResult = {\n  filter?: VisitorComparisonResult | VisitorOperationResult;\n};\n\n/**\n * Abstract class for visiting expressions. Subclasses must implement\n * visitOperation, visitComparison, and visitStructuredQuery methods.\n */\nexport abstract class Visitor<T extends VectorStore = VectorStore> {\n  declare VisitOperationOutput: object;\n\n  declare VisitComparisonOutput: object;\n\n  declare VisitStructuredQueryOutput: { filter?: T[\"FilterType\"] };\n\n  abstract allowedOperators: Operator[];\n\n  abstract allowedComparators: Comparator[];\n\n  abstract visitOperation(operation: Operation): this[\"VisitOperationOutput\"];\n\n  abstract visitComparison(\n    comparison: Comparison\n  ): this[\"VisitComparisonOutput\"];\n\n  abstract visitStructuredQuery(\n    structuredQuery: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"];\n}\n\n/**\n * Abstract class representing an expression. Subclasses must implement\n * the exprName property and the accept method.\n */\nexport abstract class Expression {\n  abstract exprName: \"Operation\" | \"Comparison\" | \"StructuredQuery\";\n\n  accept(visitor: Visitor) {\n    if (this.exprName === \"Operation\") {\n      return visitor.visitOperation(this as unknown as Operation);\n    } else if (this.exprName === \"Comparison\") {\n      return visitor.visitComparison(this as unknown as Comparison);\n    } else if (this.exprName === \"StructuredQuery\") {\n      return visitor.visitStructuredQuery(this as unknown as StructuredQuery);\n    } else {\n      throw new Error(\"Unknown Expression type\");\n    }\n  }\n}\n\n/**\n * Abstract class representing a filter directive. It extends the\n * Expression class.\n */\nexport abstract class FilterDirective extends Expression {}\n\n/**\n * Class representing a comparison filter directive. It extends the\n * FilterDirective class.\n */\nexport class Comparison<ValueTypes = string | number> extends FilterDirective {\n  exprName = \"Comparison\" as const;\n\n  constructor(\n    public comparator: Comparator,\n    public attribute: string,\n    public value: ValueTypes\n  ) {\n    super();\n  }\n}\n\n/**\n * Class representing an operation filter directive. It extends the\n * FilterDirective class.\n */\nexport class Operation extends FilterDirective {\n  exprName = \"Operation\" as const;\n\n  constructor(\n    public operator: Operator,\n    public args?: FilterDirective[]\n  ) {\n    super();\n  }\n}\n\n/**\n * Class representing a structured query expression. It extends the\n * Expression class.\n */\nexport class StructuredQuery extends Expression {\n  exprName = \"StructuredQuery\" as const;\n\n  constructor(\n    public query: string,\n    public filter?: FilterDirective\n  ) {\n    super();\n  }\n}\n"],"mappings":";AAmDA,MAAa,YAAyC;CACpD,KAAK;CACL,IAAI;CACJ,KAAK;CACN;AAED,MAAa,cAA6C;CACxD,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,KAAK;CACL,KAAK;CACN;;;;;AAmCD,IAAsB,UAAtB,MAAmE;;;;;AA0BnE,IAAsB,aAAtB,MAAiC;CAG/B,OAAO,SAAkB;AACvB,MAAI,KAAK,aAAa,YACpB,QAAO,QAAQ,eAAe,KAA6B;WAClD,KAAK,aAAa,aAC3B,QAAO,QAAQ,gBAAgB,KAA8B;WACpD,KAAK,aAAa,kBAC3B,QAAO,QAAQ,qBAAqB,KAAmC;MAEvE,OAAM,IAAI,MAAM,0BAA0B;;;;;;;AAShD,IAAsB,kBAAtB,cAA8C,WAAW;;;;;AAMzD,IAAa,aAAb,cAA8D,gBAAgB;CAC5E,WAAW;CAEX,YACE,YACA,WACA,OACA;AACA,SAAO;AAJA,OAAA,aAAA;AACA,OAAA,YAAA;AACA,OAAA,QAAA;;;;;;;AAUX,IAAa,YAAb,cAA+B,gBAAgB;CAC7C,WAAW;CAEX,YACE,UACA,MACA;AACA,SAAO;AAHA,OAAA,WAAA;AACA,OAAA,OAAA;;;;;;;AAUX,IAAa,kBAAb,cAAqC,WAAW;CAC9C,WAAW;CAEX,YACE,OACA,QACA;AACA,SAAO;AAHA,OAAA,QAAA;AACA,OAAA,SAAA"}

package/dist/structured_query/ir.d.cts

@@ -1,7 +1,6 @@
 import { VectorStore } from "../vectorstores.cjs";
 
 //#region src/structured_query/ir.d.ts
-
 /**
  * Represents logical AND operator.
  */

package/dist/structured_query/ir.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"ir.d.cts","names":["VectorStore","AND","OR","NOT","Operator","EQ","NE","LT","GT","LTE","GTE","Comparator","Operators","Comparators","VisitorResult","VisitorOperationResult","VisitorComparisonResult","VisitorStructuredQueryResult","Visitor","T","Operation","Comparison","StructuredQuery","Expression","FilterDirective","ValueTypes"],"sources":["../../src/structured_query/ir.d.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\n/**\n * Represents logical AND operator.\n */\nexport type AND = \"and\";\n/**\n * Represents logical OR operator.\n */\nexport type OR = \"or\";\n/**\n * Represents logical NOT operator.\n */\nexport type NOT = \"not\";\n/**\n * Represents a logical operator which can be AND, OR, or NOT.\n */\nexport type Operator = AND | OR | NOT;\n/**\n * Represents equality comparison operator.\n */\nexport type EQ = \"eq\";\n/**\n * Represents inequality comparison operator.\n */\nexport type NE = \"ne\";\n/**\n * Represents less than comparison operator.\n */\nexport type LT = \"lt\";\n/**\n * Represents greater than comparison operator.\n */\nexport type GT = \"gt\";\n/**\n * Represents less than or equal to comparison operator.\n */\nexport type LTE = \"lte\";\n/**\n * Represents greater than or equal to comparison operator.\n */\nexport type GTE = \"gte\";\n/**\n * Represents a comparison operator which can be EQ, NE, LT, GT, LTE, or\n * GTE.\n */\nexport type Comparator = EQ | NE | LT | GT | LTE | GTE;\nexport declare const Operators: {\n    [key: string]: Operator;\n};\nexport declare const Comparators: {\n    [key: string]: Comparator;\n};\n/**\n * Represents the result of visiting an operation or comparison\n * expression.\n */\nexport type VisitorResult = VisitorOperationResult | VisitorComparisonResult;\n/**\n * Represents the result of visiting an operation expression.\n */\nexport type VisitorOperationResult = {\n    [operator: string]: VisitorResult[];\n};\n/**\n * Represents the result of visiting a comparison expression.\n */\nexport type VisitorComparisonResult = {\n    [attr: string]: {\n        [comparator: string]: string | number | boolean;\n    };\n};\n/**\n * Represents the result of visiting a structured query expression.\n */\nexport type VisitorStructuredQueryResult = {\n    filter?: VisitorComparisonResult | VisitorOperationResult;\n};\n/**\n * Abstract class for visiting expressions. Subclasses must implement\n * visitOperation, visitComparison, and visitStructuredQuery methods.\n */\nexport declare abstract class Visitor<T extends VectorStore = VectorStore> {\n    VisitOperationOutput: object;\n    VisitComparisonOutput: object;\n    VisitStructuredQueryOutput: {\n        filter?: T[\"FilterType\"];\n    };\n    abstract allowedOperators: Operator[];\n    abstract allowedComparators: Comparator[];\n    abstract visitOperation(operation: Operation): this[\"VisitOperationOutput\"];\n    abstract visitComparison(comparison: Comparison): this[\"VisitComparisonOutput\"];\n    abstract visitStructuredQuery(structuredQuery: StructuredQuery): this[\"VisitStructuredQueryOutput\"];\n}\n/**\n * Abstract class representing an expression. Subclasses must implement\n * the exprName property and the accept method.\n */\nexport declare abstract class Expression {\n    abstract exprName: \"Operation\" | \"Comparison\" | \"StructuredQuery\";\n    accept(visitor: Visitor): object;\n}\n/**\n * Abstract class representing a filter directive. It extends the\n * Expression class.\n */\nexport declare abstract class FilterDirective extends Expression {\n}\n/**\n * Class representing a comparison filter directive. It extends the\n * FilterDirective class.\n */\nexport declare class Comparison<ValueTypes = string | number> extends FilterDirective {\n    comparator: Comparator;\n    attribute: string;\n    value: ValueTypes;\n    exprName: \"Comparison\";\n    constructor(comparator: Comparator, attribute: string, value: ValueTypes);\n}\n/**\n * Class representing an operation filter directive. It extends the\n * FilterDirective class.\n */\nexport declare class Operation extends FilterDirective {\n    operator: Operator;\n    args?: FilterDirective[] | undefined;\n    exprName: \"Operation\";\n    constructor(operator: Operator, args?: FilterDirective[] | undefined);\n}\n/**\n * Class representing a structured query expression. It extends the\n * Expression class.\n */\nexport declare class StructuredQuery extends Expression {\n    query: string;\n    filter?: FilterDirective | undefined;\n    exprName: \"StructuredQuery\";\n    constructor(query: string, filter?: FilterDirective | undefined);\n}\n//# sourceMappingURL=ir.d.ts.map"],"mappings":";;;;;;AAIA;AAIYE,KAJAD,GAAAA,GAIE,KAAA;AAId;AAIA;;AAA6BC,KARjBA,EAAAA,GAQiBA,IAAAA;;AAAQ;AAIrC;AAIYI,KAZAH,GAAAA,GAYE,KAAA;AAId;AAIA;AAIA;AAIYO,KAxBAN,QAAAA,GAAWH,GAwBR,GAxBcC,EAwBd,GAxBmBC,GAwBnB;AAKf;;;AAAmCI,KAzBvBF,EAAAA,GAyBuBE,IAAAA;;;;AAAmB,KArB1CD,EAAAA,GAqB0C,IAAA;AACtD;AAGA;AAOA;AAIYS,KAhCAR,EAAAA,GAgCAQ,IAAAA;AAMZ;AAQA;AAOA;AAAgDf,KAjDpCQ,EAAAA,GAiDoCR,IAAAA;;;;AAOfW,KApDrBF,GAAAA,GAoDqBE,KAAAA;;;;AAGiC,KAnDtDD,GAAAA,GAmDsD,KAAA;AAMlE;AAQA;AAMA;;AAGWe,KArECd,UAAAA,GAAaN,EAqEdoB,GArEmBnB,EAqEnBmB,GArEwBlB,EAqExBkB,GArE6BjB,EAqE7BiB,GArEkChB,GAqElCgB,GArEwCf,GAqExCe;AAEiBd,cAtEPC,SAsEOD,EAAAA;EAAsCc,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EArE/CrB,QAqE+CqB;CALID;AAAe,cA9DhEX,WA8DgE,EAAA;EAWhEO,CAAAA,GAAAA,EAAAA,MAAS,CAAA,EAxEXT,UAwEW;CAChBP;;;;;AADwC,KAlE1CU,aAAAA,GAAgBC,sBAkE0B,GAlEDC,uBAkEC;AAUtD;;;AAA6CO,KAxEjCR,sBAAAA,GAwEiCQ;EAAU,CAAA,QAAA,EAAA,MAAA,CAAA,EAvE/BT,aAuE+B,EAAA;;;;;KAlE3CE,uBAAAA;;;;;;;;KAQAC,4BAAAA;WACCD,0BAA0BD;;;;;;uBAMTG,kBAAkBlB,cAAcA;;;;aAI7CmB;;6BAEcf;+BACEO;qCACMS;uCACEC;iDACUC;;;;;;uBAMrBC,UAAAA;;kBAEVL;;;;;;uBAMUM,eAAAA,SAAwBD,UAAU;;;;;cAM3CF,iDAAiDG,eAAAA;cACtDb;;SAELc;;0BAEiBd,sCAAsCc;;;;;;cAM7CL,SAAAA,SAAkBI,eAAAA;YACzBpB;SACHoB;;wBAEepB,iBAAiBoB;;;;;;cAMtBF,eAAAA,SAAwBC,UAAAA;;WAEhCC;;sCAE2BA"}
+{"version":3,"file":"ir.d.cts","names":[],"sources":["../../src/structured_query/ir.ts"],"mappings":";;;;;AAKA;KAAY,GAAA;;;;KAIA,EAAA;;;;KAIA,GAAA;AAAZ;;;AAAA,KAKY,QAAA,GAAW,GAAA,GAAM,EAAA,GAAK,GAAA;;AAAlC;;KAKY,EAAA;;;;KAIA,EAAA;;;;KAIA,EAAA;;;AARZ;KAYY,EAAA;;;;KAIA,GAAA;;;;KAIA,GAAA;AAZZ;;;;AAAA,KAkBY,UAAA,GAAa,EAAA,GAAK,EAAA,GAAK,EAAA,GAAK,EAAA,GAAK,GAAA,GAAM,GAAA;AAAA,cAEtC,SAAA;EAAA,CAAc,GAAA,WAAc,QAAA;AAAA;AAAA,cAM5B,WAAA;EAAA,CAAgB,GAAA,WAAc,UAAA;AAAA;;;;;KAa/B,aAAA,GAAgB,sBAAA,GAAyB,uBAAA;;;;KAKzC,sBAAA;EAAA,CACT,QAAA,WAAmB,aAAA;AAAA;;;;KAMV,uBAAA;EAAA,CACT,IAAA;IAAA,CACE,UAAA;EAAA;AAAA;;;;KAOO,4BAAA;EACV,MAAA,GAAS,uBAAA,GAA0B,sBAAA;AAAA;;;;AAzCrC;uBAgDsB,OAAA,WAAkB,WAAA,GAAc,WAAA;EAC5C,oBAAA;EAEA,qBAAA;EAEA,0BAAA;IAA8B,MAAA,GAAS,CAAA;EAAA;EAAA,SAEtC,gBAAA,EAAkB,QAAA;EAAA,SAElB,kBAAA,EAAoB,UAAA;EAAA,SAEpB,cAAA,CAAe,SAAA,EAAW,SAAA;EAAA,SAE1B,eAAA,CACP,UAAA,EAAY,UAAA;EAAA,SAGL,oBAAA,CACP,eAAA,EAAiB,eAAA;AAAA;;;AA1CrB;;uBAkDsB,UAAA;EAAA,SACX,QAAA;EAET,MAAA,CAAO,OAAA,EAAS,OAAA;AAAA;;;;;uBAiBI,eAAA,SAAwB,UAAA;;;;;cAMjC,UAAA,uCAAiD,eAAA;EAInD,UAAA,EAAY,UAAA;EACZ,SAAA;EACA,KAAA,EAAO,UAAA;EALhB,QAAA;EAEA,WAAA,CACS,UAAA,EAAY,UAAA,EACZ,SAAA,UACA,KAAA,EAAO,UAAA;AAAA;;;;;cAUL,SAAA,SAAkB,eAAA;EAIpB,QAAA,EAAU,QAAA;EACV,IAAA,GAAO,eAAA;EAJhB,QAAA;EAEA,WAAA,CACS,QAAA,EAAU,QAAA,EACV,IAAA,GAAO,eAAA;AAAA;;;;;cAUL,eAAA,SAAwB,UAAA;EAI1B,KAAA;EACA,MAAA,GAAS,eAAA;EAJlB,QAAA;EAEA,WAAA,CACS,KAAA,UACA,MAAA,GAAS,eAAA;AAAA"}

package/dist/structured_query/ir.d.ts

@@ -1,7 +1,6 @@
 import { VectorStore } from "../vectorstores.js";
 
 //#region src/structured_query/ir.d.ts
-
 /**
  * Represents logical AND operator.
  */

package/dist/structured_query/ir.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ir.d.ts","names":["VectorStore","AND","OR","NOT","Operator","EQ","NE","LT","GT","LTE","GTE","Comparator","Operators","Comparators","VisitorResult","VisitorOperationResult","VisitorComparisonResult","VisitorStructuredQueryResult","Visitor","T","Operation","Comparison","StructuredQuery","Expression","FilterDirective","ValueTypes"],"sources":["../../src/structured_query/ir.d.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\n/**\n * Represents logical AND operator.\n */\nexport type AND = \"and\";\n/**\n * Represents logical OR operator.\n */\nexport type OR = \"or\";\n/**\n * Represents logical NOT operator.\n */\nexport type NOT = \"not\";\n/**\n * Represents a logical operator which can be AND, OR, or NOT.\n */\nexport type Operator = AND | OR | NOT;\n/**\n * Represents equality comparison operator.\n */\nexport type EQ = \"eq\";\n/**\n * Represents inequality comparison operator.\n */\nexport type NE = \"ne\";\n/**\n * Represents less than comparison operator.\n */\nexport type LT = \"lt\";\n/**\n * Represents greater than comparison operator.\n */\nexport type GT = \"gt\";\n/**\n * Represents less than or equal to comparison operator.\n */\nexport type LTE = \"lte\";\n/**\n * Represents greater than or equal to comparison operator.\n */\nexport type GTE = \"gte\";\n/**\n * Represents a comparison operator which can be EQ, NE, LT, GT, LTE, or\n * GTE.\n */\nexport type Comparator = EQ | NE | LT | GT | LTE | GTE;\nexport declare const Operators: {\n    [key: string]: Operator;\n};\nexport declare const Comparators: {\n    [key: string]: Comparator;\n};\n/**\n * Represents the result of visiting an operation or comparison\n * expression.\n */\nexport type VisitorResult = VisitorOperationResult | VisitorComparisonResult;\n/**\n * Represents the result of visiting an operation expression.\n */\nexport type VisitorOperationResult = {\n    [operator: string]: VisitorResult[];\n};\n/**\n * Represents the result of visiting a comparison expression.\n */\nexport type VisitorComparisonResult = {\n    [attr: string]: {\n        [comparator: string]: string | number | boolean;\n    };\n};\n/**\n * Represents the result of visiting a structured query expression.\n */\nexport type VisitorStructuredQueryResult = {\n    filter?: VisitorComparisonResult | VisitorOperationResult;\n};\n/**\n * Abstract class for visiting expressions. Subclasses must implement\n * visitOperation, visitComparison, and visitStructuredQuery methods.\n */\nexport declare abstract class Visitor<T extends VectorStore = VectorStore> {\n    VisitOperationOutput: object;\n    VisitComparisonOutput: object;\n    VisitStructuredQueryOutput: {\n        filter?: T[\"FilterType\"];\n    };\n    abstract allowedOperators: Operator[];\n    abstract allowedComparators: Comparator[];\n    abstract visitOperation(operation: Operation): this[\"VisitOperationOutput\"];\n    abstract visitComparison(comparison: Comparison): this[\"VisitComparisonOutput\"];\n    abstract visitStructuredQuery(structuredQuery: StructuredQuery): this[\"VisitStructuredQueryOutput\"];\n}\n/**\n * Abstract class representing an expression. Subclasses must implement\n * the exprName property and the accept method.\n */\nexport declare abstract class Expression {\n    abstract exprName: \"Operation\" | \"Comparison\" | \"StructuredQuery\";\n    accept(visitor: Visitor): object;\n}\n/**\n * Abstract class representing a filter directive. It extends the\n * Expression class.\n */\nexport declare abstract class FilterDirective extends Expression {\n}\n/**\n * Class representing a comparison filter directive. It extends the\n * FilterDirective class.\n */\nexport declare class Comparison<ValueTypes = string | number> extends FilterDirective {\n    comparator: Comparator;\n    attribute: string;\n    value: ValueTypes;\n    exprName: \"Comparison\";\n    constructor(comparator: Comparator, attribute: string, value: ValueTypes);\n}\n/**\n * Class representing an operation filter directive. It extends the\n * FilterDirective class.\n */\nexport declare class Operation extends FilterDirective {\n    operator: Operator;\n    args?: FilterDirective[] | undefined;\n    exprName: \"Operation\";\n    constructor(operator: Operator, args?: FilterDirective[] | undefined);\n}\n/**\n * Class representing a structured query expression. It extends the\n * Expression class.\n */\nexport declare class StructuredQuery extends Expression {\n    query: string;\n    filter?: FilterDirective | undefined;\n    exprName: \"StructuredQuery\";\n    constructor(query: string, filter?: FilterDirective | undefined);\n}\n//# sourceMappingURL=ir.d.ts.map"],"mappings":";;;;;;AAIA;AAIYE,KAJAD,GAAAA,GAIE,KAAA;AAId;AAIA;;AAA6BC,KARjBA,EAAAA,GAQiBA,IAAAA;;AAAQ;AAIrC;AAIYI,KAZAH,GAAAA,GAYE,KAAA;AAId;AAIA;AAIA;AAIYO,KAxBAN,QAAAA,GAAWH,GAwBR,GAxBcC,EAwBd,GAxBmBC,GAwBnB;AAKf;;;AAAmCI,KAzBvBF,EAAAA,GAyBuBE,IAAAA;;;;AAAmB,KArB1CD,EAAAA,GAqB0C,IAAA;AACtD;AAGA;AAOA;AAIYS,KAhCAR,EAAAA,GAgCAQ,IAAAA;AAMZ;AAQA;AAOA;AAAgDf,KAjDpCQ,EAAAA,GAiDoCR,IAAAA;;;;AAOfW,KApDrBF,GAAAA,GAoDqBE,KAAAA;;;;AAGiC,KAnDtDD,GAAAA,GAmDsD,KAAA;AAMlE;AAQA;AAMA;;AAGWe,KArECd,UAAAA,GAAaN,EAqEdoB,GArEmBnB,EAqEnBmB,GArEwBlB,EAqExBkB,GArE6BjB,EAqE7BiB,GArEkChB,GAqElCgB,GArEwCf,GAqExCe;AAEiBd,cAtEPC,SAsEOD,EAAAA;EAAsCc,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EArE/CrB,QAqE+CqB;CALID;AAAe,cA9DhEX,WA8DgE,EAAA;EAWhEO,CAAAA,GAAAA,EAAAA,MAAS,CAAA,EAxEXT,UAwEW;CAChBP;;;;;AADwC,KAlE1CU,aAAAA,GAAgBC,sBAkE0B,GAlEDC,uBAkEC;AAUtD;;;AAA6CO,KAxEjCR,sBAAAA,GAwEiCQ;EAAU,CAAA,QAAA,EAAA,MAAA,CAAA,EAvE/BT,aAuE+B,EAAA;;;;;KAlE3CE,uBAAAA;;;;;;;;KAQAC,4BAAAA;WACCD,0BAA0BD;;;;;;uBAMTG,kBAAkBlB,cAAcA;;;;aAI7CmB;;6BAEcf;+BACEO;qCACMS;uCACEC;iDACUC;;;;;;uBAMrBC,UAAAA;;kBAEVL;;;;;;uBAMUM,eAAAA,SAAwBD,UAAU;;;;;cAM3CF,iDAAiDG,eAAAA;cACtDb;;SAELc;;0BAEiBd,sCAAsCc;;;;;;cAM7CL,SAAAA,SAAkBI,eAAAA;YACzBpB;SACHoB;;wBAEepB,iBAAiBoB;;;;;;cAMtBF,eAAAA,SAAwBC,UAAAA;;WAEhCC;;sCAE2BA"}
+{"version":3,"file":"ir.d.ts","names":[],"sources":["../../src/structured_query/ir.ts"],"mappings":";;;;;AAKA;KAAY,GAAA;;;;KAIA,EAAA;;;;KAIA,GAAA;AAAZ;;;AAAA,KAKY,QAAA,GAAW,GAAA,GAAM,EAAA,GAAK,GAAA;;AAAlC;;KAKY,EAAA;;;;KAIA,EAAA;;;;KAIA,EAAA;;;AARZ;KAYY,EAAA;;;;KAIA,GAAA;;;;KAIA,GAAA;AAZZ;;;;AAAA,KAkBY,UAAA,GAAa,EAAA,GAAK,EAAA,GAAK,EAAA,GAAK,EAAA,GAAK,GAAA,GAAM,GAAA;AAAA,cAEtC,SAAA;EAAA,CAAc,GAAA,WAAc,QAAA;AAAA;AAAA,cAM5B,WAAA;EAAA,CAAgB,GAAA,WAAc,UAAA;AAAA;;;;;KAa/B,aAAA,GAAgB,sBAAA,GAAyB,uBAAA;;;;KAKzC,sBAAA;EAAA,CACT,QAAA,WAAmB,aAAA;AAAA;;;;KAMV,uBAAA;EAAA,CACT,IAAA;IAAA,CACE,UAAA;EAAA;AAAA;;;;KAOO,4BAAA;EACV,MAAA,GAAS,uBAAA,GAA0B,sBAAA;AAAA;;;;AAzCrC;uBAgDsB,OAAA,WAAkB,WAAA,GAAc,WAAA;EAC5C,oBAAA;EAEA,qBAAA;EAEA,0BAAA;IAA8B,MAAA,GAAS,CAAA;EAAA;EAAA,SAEtC,gBAAA,EAAkB,QAAA;EAAA,SAElB,kBAAA,EAAoB,UAAA;EAAA,SAEpB,cAAA,CAAe,SAAA,EAAW,SAAA;EAAA,SAE1B,eAAA,CACP,UAAA,EAAY,UAAA;EAAA,SAGL,oBAAA,CACP,eAAA,EAAiB,eAAA;AAAA;;;AA1CrB;;uBAkDsB,UAAA;EAAA,SACX,QAAA;EAET,MAAA,CAAO,OAAA,EAAS,OAAA;AAAA;;;;;uBAiBI,eAAA,SAAwB,UAAA;;;;;cAMjC,UAAA,uCAAiD,eAAA;EAInD,UAAA,EAAY,UAAA;EACZ,SAAA;EACA,KAAA,EAAO,UAAA;EALhB,QAAA;EAEA,WAAA,CACS,UAAA,EAAY,UAAA,EACZ,SAAA,UACA,KAAA,EAAO,UAAA;AAAA;;;;;cAUL,SAAA,SAAkB,eAAA;EAIpB,QAAA,EAAU,QAAA;EACV,IAAA,GAAO,eAAA;EAJhB,QAAA;EAEA,WAAA,CACS,QAAA,EAAU,QAAA,EACV,IAAA,GAAO,eAAA;AAAA;;;;;cAUL,eAAA,SAAwB,UAAA;EAI1B,KAAA;EACA,MAAA,GAAS,eAAA;EAJlB,QAAA;EAEA,WAAA,CACS,KAAA,UACA,MAAA,GAAS,eAAA;AAAA"}

package/dist/structured_query/ir.js

@@ -71,7 +71,7 @@ var StructuredQuery = class extends Expression {
 		this.filter = filter;
 	}
 };
-
 //#endregion
 export { Comparators, Comparison, Expression, FilterDirective, Operation, Operators, StructuredQuery, Visitor };
+
 //# sourceMappingURL=ir.js.map

package/dist/structured_query/ir.js.map

@@ -1 +1 @@
-{"version":3,"file":"ir.js","names":["Operators: { [key: string]: Operator }","Comparators: { [key: string]: Comparator }","visitor: Visitor","comparator: Comparator","attribute: string","value: ValueTypes","operator: Operator","args?: FilterDirective[]","query: string","filter?: FilterDirective"],"sources":["../../src/structured_query/ir.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\n\n/**\n * Represents logical AND operator.\n */\nexport type AND = \"and\";\n/**\n * Represents logical OR operator.\n */\nexport type OR = \"or\";\n/**\n * Represents logical NOT operator.\n */\nexport type NOT = \"not\";\n\n/**\n * Represents a logical operator which can be AND, OR, or NOT.\n */\nexport type Operator = AND | OR | NOT;\n\n/**\n * Represents equality comparison operator.\n */\nexport type EQ = \"eq\";\n/**\n * Represents inequality comparison operator.\n */\nexport type NE = \"ne\";\n/**\n * Represents less than comparison operator.\n */\nexport type LT = \"lt\";\n/**\n * Represents greater than comparison operator.\n */\nexport type GT = \"gt\";\n/**\n * Represents less than or equal to comparison operator.\n */\nexport type LTE = \"lte\";\n/**\n * Represents greater than or equal to comparison operator.\n */\nexport type GTE = \"gte\";\n\n/**\n * Represents a comparison operator which can be EQ, NE, LT, GT, LTE, or\n * GTE.\n */\nexport type Comparator = EQ | NE | LT | GT | LTE | GTE;\n\nexport const Operators: { [key: string]: Operator } = {\n  and: \"and\",\n  or: \"or\",\n  not: \"not\",\n};\n\nexport const Comparators: { [key: string]: Comparator } = {\n  eq: \"eq\",\n  ne: \"ne\",\n  lt: \"lt\",\n  gt: \"gt\",\n  lte: \"lte\",\n  gte: \"gte\",\n};\n\n/**\n * Represents the result of visiting an operation or comparison\n * expression.\n */\nexport type VisitorResult = VisitorOperationResult | VisitorComparisonResult;\n\n/**\n * Represents the result of visiting an operation expression.\n */\nexport type VisitorOperationResult = {\n  [operator: string]: VisitorResult[];\n};\n\n/**\n * Represents the result of visiting a comparison expression.\n */\nexport type VisitorComparisonResult = {\n  [attr: string]: {\n    [comparator: string]: string | number | boolean;\n  };\n};\n\n/**\n * Represents the result of visiting a structured query expression.\n */\nexport type VisitorStructuredQueryResult = {\n  filter?: VisitorComparisonResult | VisitorOperationResult;\n};\n\n/**\n * Abstract class for visiting expressions. Subclasses must implement\n * visitOperation, visitComparison, and visitStructuredQuery methods.\n */\nexport abstract class Visitor<T extends VectorStore = VectorStore> {\n  declare VisitOperationOutput: object;\n\n  declare VisitComparisonOutput: object;\n\n  declare VisitStructuredQueryOutput: { filter?: T[\"FilterType\"] };\n\n  abstract allowedOperators: Operator[];\n\n  abstract allowedComparators: Comparator[];\n\n  abstract visitOperation(operation: Operation): this[\"VisitOperationOutput\"];\n\n  abstract visitComparison(\n    comparison: Comparison\n  ): this[\"VisitComparisonOutput\"];\n\n  abstract visitStructuredQuery(\n    structuredQuery: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"];\n}\n\n/**\n * Abstract class representing an expression. Subclasses must implement\n * the exprName property and the accept method.\n */\nexport abstract class Expression {\n  abstract exprName: \"Operation\" | \"Comparison\" | \"StructuredQuery\";\n\n  accept(visitor: Visitor) {\n    if (this.exprName === \"Operation\") {\n      return visitor.visitOperation(this as unknown as Operation);\n    } else if (this.exprName === \"Comparison\") {\n      return visitor.visitComparison(this as unknown as Comparison);\n    } else if (this.exprName === \"StructuredQuery\") {\n      return visitor.visitStructuredQuery(this as unknown as StructuredQuery);\n    } else {\n      throw new Error(\"Unknown Expression type\");\n    }\n  }\n}\n\n/**\n * Abstract class representing a filter directive. It extends the\n * Expression class.\n */\nexport abstract class FilterDirective extends Expression {}\n\n/**\n * Class representing a comparison filter directive. It extends the\n * FilterDirective class.\n */\nexport class Comparison<ValueTypes = string | number> extends FilterDirective {\n  exprName = \"Comparison\" as const;\n\n  constructor(\n    public comparator: Comparator,\n    public attribute: string,\n    public value: ValueTypes\n  ) {\n    super();\n  }\n}\n\n/**\n * Class representing an operation filter directive. It extends the\n * FilterDirective class.\n */\nexport class Operation extends FilterDirective {\n  exprName = \"Operation\" as const;\n\n  constructor(public operator: Operator, public args?: FilterDirective[]) {\n    super();\n  }\n}\n\n/**\n * Class representing a structured query expression. It extends the\n * Expression class.\n */\nexport class StructuredQuery extends Expression {\n  exprName = \"StructuredQuery\" as const;\n\n  constructor(public query: string, public filter?: FilterDirective) {\n    super();\n  }\n}\n"],"mappings":";AAmDA,MAAaA,YAAyC;CACpD,KAAK;CACL,IAAI;CACJ,KAAK;AACN;AAED,MAAaC,cAA6C;CACxD,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,KAAK;CACL,KAAK;AACN;;;;;AAmCD,IAAsB,UAAtB,MAAmE,CAoBlE;;;;;AAMD,IAAsB,aAAtB,MAAiC;CAG/B,OAAOC,SAAkB;AACvB,MAAI,KAAK,aAAa,YACpB,QAAO,QAAQ,eAAe,KAA6B;WAClD,KAAK,aAAa,aAC3B,QAAO,QAAQ,gBAAgB,KAA8B;WACpD,KAAK,aAAa,kBAC3B,QAAO,QAAQ,qBAAqB,KAAmC;MAEvE,OAAM,IAAI,MAAM;CAEnB;AACF;;;;;AAMD,IAAsB,kBAAtB,cAA8C,WAAW,CAAE;;;;;AAM3D,IAAa,aAAb,cAA8D,gBAAgB;CAC5E,WAAW;CAEX,YACSC,YACAC,WACAC,OACP;EACA,OAAO;EAJA;EACA;EACA;CAGR;AACF;;;;;AAMD,IAAa,YAAb,cAA+B,gBAAgB;CAC7C,WAAW;CAEX,YAAmBC,UAA2BC,MAA0B;EACtE,OAAO;EADU;EAA2B;CAE7C;AACF;;;;;AAMD,IAAa,kBAAb,cAAqC,WAAW;CAC9C,WAAW;CAEX,YAAmBC,OAAsBC,QAA0B;EACjE,OAAO;EADU;EAAsB;CAExC;AACF"}
+{"version":3,"file":"ir.js","names":[],"sources":["../../src/structured_query/ir.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\n\n/**\n * Represents logical AND operator.\n */\nexport type AND = \"and\";\n/**\n * Represents logical OR operator.\n */\nexport type OR = \"or\";\n/**\n * Represents logical NOT operator.\n */\nexport type NOT = \"not\";\n\n/**\n * Represents a logical operator which can be AND, OR, or NOT.\n */\nexport type Operator = AND | OR | NOT;\n\n/**\n * Represents equality comparison operator.\n */\nexport type EQ = \"eq\";\n/**\n * Represents inequality comparison operator.\n */\nexport type NE = \"ne\";\n/**\n * Represents less than comparison operator.\n */\nexport type LT = \"lt\";\n/**\n * Represents greater than comparison operator.\n */\nexport type GT = \"gt\";\n/**\n * Represents less than or equal to comparison operator.\n */\nexport type LTE = \"lte\";\n/**\n * Represents greater than or equal to comparison operator.\n */\nexport type GTE = \"gte\";\n\n/**\n * Represents a comparison operator which can be EQ, NE, LT, GT, LTE, or\n * GTE.\n */\nexport type Comparator = EQ | NE | LT | GT | LTE | GTE;\n\nexport const Operators: { [key: string]: Operator } = {\n  and: \"and\",\n  or: \"or\",\n  not: \"not\",\n};\n\nexport const Comparators: { [key: string]: Comparator } = {\n  eq: \"eq\",\n  ne: \"ne\",\n  lt: \"lt\",\n  gt: \"gt\",\n  lte: \"lte\",\n  gte: \"gte\",\n};\n\n/**\n * Represents the result of visiting an operation or comparison\n * expression.\n */\nexport type VisitorResult = VisitorOperationResult | VisitorComparisonResult;\n\n/**\n * Represents the result of visiting an operation expression.\n */\nexport type VisitorOperationResult = {\n  [operator: string]: VisitorResult[];\n};\n\n/**\n * Represents the result of visiting a comparison expression.\n */\nexport type VisitorComparisonResult = {\n  [attr: string]: {\n    [comparator: string]: string | number | boolean;\n  };\n};\n\n/**\n * Represents the result of visiting a structured query expression.\n */\nexport type VisitorStructuredQueryResult = {\n  filter?: VisitorComparisonResult | VisitorOperationResult;\n};\n\n/**\n * Abstract class for visiting expressions. Subclasses must implement\n * visitOperation, visitComparison, and visitStructuredQuery methods.\n */\nexport abstract class Visitor<T extends VectorStore = VectorStore> {\n  declare VisitOperationOutput: object;\n\n  declare VisitComparisonOutput: object;\n\n  declare VisitStructuredQueryOutput: { filter?: T[\"FilterType\"] };\n\n  abstract allowedOperators: Operator[];\n\n  abstract allowedComparators: Comparator[];\n\n  abstract visitOperation(operation: Operation): this[\"VisitOperationOutput\"];\n\n  abstract visitComparison(\n    comparison: Comparison\n  ): this[\"VisitComparisonOutput\"];\n\n  abstract visitStructuredQuery(\n    structuredQuery: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"];\n}\n\n/**\n * Abstract class representing an expression. Subclasses must implement\n * the exprName property and the accept method.\n */\nexport abstract class Expression {\n  abstract exprName: \"Operation\" | \"Comparison\" | \"StructuredQuery\";\n\n  accept(visitor: Visitor) {\n    if (this.exprName === \"Operation\") {\n      return visitor.visitOperation(this as unknown as Operation);\n    } else if (this.exprName === \"Comparison\") {\n      return visitor.visitComparison(this as unknown as Comparison);\n    } else if (this.exprName === \"StructuredQuery\") {\n      return visitor.visitStructuredQuery(this as unknown as StructuredQuery);\n    } else {\n      throw new Error(\"Unknown Expression type\");\n    }\n  }\n}\n\n/**\n * Abstract class representing a filter directive. It extends the\n * Expression class.\n */\nexport abstract class FilterDirective extends Expression {}\n\n/**\n * Class representing a comparison filter directive. It extends the\n * FilterDirective class.\n */\nexport class Comparison<ValueTypes = string | number> extends FilterDirective {\n  exprName = \"Comparison\" as const;\n\n  constructor(\n    public comparator: Comparator,\n    public attribute: string,\n    public value: ValueTypes\n  ) {\n    super();\n  }\n}\n\n/**\n * Class representing an operation filter directive. It extends the\n * FilterDirective class.\n */\nexport class Operation extends FilterDirective {\n  exprName = \"Operation\" as const;\n\n  constructor(\n    public operator: Operator,\n    public args?: FilterDirective[]\n  ) {\n    super();\n  }\n}\n\n/**\n * Class representing a structured query expression. It extends the\n * Expression class.\n */\nexport class StructuredQuery extends Expression {\n  exprName = \"StructuredQuery\" as const;\n\n  constructor(\n    public query: string,\n    public filter?: FilterDirective\n  ) {\n    super();\n  }\n}\n"],"mappings":";AAmDA,MAAa,YAAyC;CACpD,KAAK;CACL,IAAI;CACJ,KAAK;CACN;AAED,MAAa,cAA6C;CACxD,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,KAAK;CACL,KAAK;CACN;;;;;AAmCD,IAAsB,UAAtB,MAAmE;;;;;AA0BnE,IAAsB,aAAtB,MAAiC;CAG/B,OAAO,SAAkB;AACvB,MAAI,KAAK,aAAa,YACpB,QAAO,QAAQ,eAAe,KAA6B;WAClD,KAAK,aAAa,aAC3B,QAAO,QAAQ,gBAAgB,KAA8B;WACpD,KAAK,aAAa,kBAC3B,QAAO,QAAQ,qBAAqB,KAAmC;MAEvE,OAAM,IAAI,MAAM,0BAA0B;;;;;;;AAShD,IAAsB,kBAAtB,cAA8C,WAAW;;;;;AAMzD,IAAa,aAAb,cAA8D,gBAAgB;CAC5E,WAAW;CAEX,YACE,YACA,WACA,OACA;AACA,SAAO;AAJA,OAAA,aAAA;AACA,OAAA,YAAA;AACA,OAAA,QAAA;;;;;;;AAUX,IAAa,YAAb,cAA+B,gBAAgB;CAC7C,WAAW;CAEX,YACE,UACA,MACA;AACA,SAAO;AAHA,OAAA,WAAA;AACA,OAAA,OAAA;;;;;;;AAUX,IAAa,kBAAb,cAAqC,WAAW;CAC9C,WAAW;CAEX,YACE,OACA,QACA;AACA,SAAO;AAHA,OAAA,QAAA;AACA,OAAA,SAAA"}

package/dist/structured_query/utils.cjs

@@ -1,4 +1,3 @@
-
 //#region src/structured_query/utils.ts
 /**
 * Checks if the provided argument is an object and not an array.
@@ -66,7 +65,6 @@ function castValue(input) {
 	else throw new Error("Unsupported value type");
 	return value;
 }
-
 //#endregion
 exports.castValue = castValue;
 exports.isBoolean = isBoolean;
@@ -75,4 +73,5 @@ exports.isFloat = isFloat;
 exports.isInt = isInt;
 exports.isObject = isObject;
 exports.isString = isString;
+
 //# sourceMappingURL=utils.cjs.map

package/dist/structured_query/utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.cjs","names":["obj: any","filter: ((q: any) => any) | object | string | undefined","value: unknown","input: unknown"],"sources":["../../src/structured_query/utils.ts"],"sourcesContent":["/**\n * Checks if the provided argument is an object and not an array.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isObject(obj: any): obj is object {\n  return obj && typeof obj === \"object\" && !Array.isArray(obj);\n}\n\n/**\n * Checks if a provided filter is empty. The filter can be a function, an\n * object, a string, or undefined.\n */\nexport function isFilterEmpty(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  filter: ((q: any) => any) | object | string | undefined\n): filter is undefined {\n  if (!filter) return true;\n  // for Milvus\n  if (typeof filter === \"string\" && filter.length > 0) {\n    return false;\n  }\n  if (typeof filter === \"function\") {\n    return false;\n  }\n  return isObject(filter) && Object.keys(filter).length === 0;\n}\n\n/**\n * Checks if the provided value is an integer.\n */\nexport function isInt(value: unknown): boolean {\n  if (typeof value === \"number\") {\n    return value % 1 === 0;\n  } else if (typeof value === \"string\") {\n    const numberValue = parseInt(value, 10);\n    return (\n      !Number.isNaN(numberValue) &&\n      numberValue % 1 === 0 &&\n      numberValue.toString() === value\n    );\n  }\n\n  return false;\n}\n\n/**\n * Checks if the provided value is a floating-point number.\n */\nexport function isFloat(value: unknown): boolean {\n  if (typeof value === \"number\") {\n    return value % 1 !== 0;\n  } else if (typeof value === \"string\") {\n    const numberValue = parseFloat(value);\n    return (\n      !Number.isNaN(numberValue) &&\n      numberValue % 1 !== 0 &&\n      numberValue.toString() === value\n    );\n  }\n\n  return false;\n}\n\n/**\n * Checks if the provided value is a string that cannot be parsed into a\n * number.\n */\nexport function isString(value: unknown): boolean {\n  return (\n    typeof value === \"string\" &&\n    (Number.isNaN(parseFloat(value)) || parseFloat(value).toString() !== value)\n  );\n}\n\n/**\n * Checks if the provided value is a boolean.\n */\nexport function isBoolean(value: unknown): boolean {\n  return typeof value === \"boolean\";\n}\n\n/**\n * Casts a value that might be string or number to actual string or number.\n * Since LLM might return back an integer/float as a string, we need to cast\n * it back to a number, as many vector databases can't handle number as string\n * values as a comparator.\n */\nexport function castValue(input: unknown): string | number | boolean {\n  let value;\n  if (isString(input)) {\n    value = input as string;\n  } else if (isInt(input)) {\n    value = parseInt(input as string, 10);\n  } else if (isFloat(input)) {\n    value = parseFloat(input as string);\n  } else if (isBoolean(input)) {\n    value = Boolean(input);\n  } else {\n    throw new Error(\"Unsupported value type\");\n  }\n\n  return value;\n}\n"],"mappings":";;;;;AAIA,SAAgB,SAASA,KAAyB;AAChD,QAAO,OAAO,OAAO,QAAQ,YAAY,CAAC,MAAM,QAAQ,IAAI;AAC7D;;;;;AAMD,SAAgB,cAEdC,QACqB;AACrB,KAAI,CAAC,OAAQ,QAAO;AAEpB,KAAI,OAAO,WAAW,YAAY,OAAO,SAAS,EAChD,QAAO;AAET,KAAI,OAAO,WAAW,WACpB,QAAO;AAET,QAAO,SAAS,OAAO,IAAI,OAAO,KAAK,OAAO,CAAC,WAAW;AAC3D;;;;AAKD,SAAgB,MAAMC,OAAyB;AAC7C,KAAI,OAAO,UAAU,SACnB,QAAO,QAAQ,MAAM;UACZ,OAAO,UAAU,UAAU;EACpC,MAAM,cAAc,SAAS,OAAO,GAAG;AACvC,SACE,CAAC,OAAO,MAAM,YAAY,IAC1B,cAAc,MAAM,KACpB,YAAY,UAAU,KAAK;CAE9B;AAED,QAAO;AACR;;;;AAKD,SAAgB,QAAQA,OAAyB;AAC/C,KAAI,OAAO,UAAU,SACnB,QAAO,QAAQ,MAAM;UACZ,OAAO,UAAU,UAAU;EACpC,MAAM,cAAc,WAAW,MAAM;AACrC,SACE,CAAC,OAAO,MAAM,YAAY,IAC1B,cAAc,MAAM,KACpB,YAAY,UAAU,KAAK;CAE9B;AAED,QAAO;AACR;;;;;AAMD,SAAgB,SAASA,OAAyB;AAChD,QACE,OAAO,UAAU,aAChB,OAAO,MAAM,WAAW,MAAM,CAAC,IAAI,WAAW,MAAM,CAAC,UAAU,KAAK;AAExE;;;;AAKD,SAAgB,UAAUA,OAAyB;AACjD,QAAO,OAAO,UAAU;AACzB;;;;;;;AAQD,SAAgB,UAAUC,OAA2C;CACnE,IAAI;AACJ,KAAI,SAAS,MAAM,EACjB,QAAQ;UACC,MAAM,MAAM,EACrB,QAAQ,SAAS,OAAiB,GAAG;UAC5B,QAAQ,MAAM,EACvB,QAAQ,WAAW,MAAgB;UAC1B,UAAU,MAAM,EACzB,QAAQ,QAAQ,MAAM;KAEtB,OAAM,IAAI,MAAM;AAGlB,QAAO;AACR"}
+{"version":3,"file":"utils.cjs","names":[],"sources":["../../src/structured_query/utils.ts"],"sourcesContent":["/**\n * Checks if the provided argument is an object and not an array.\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isObject(obj: any): obj is object {\n  return obj && typeof obj === \"object\" && !Array.isArray(obj);\n}\n\n/**\n * Checks if a provided filter is empty. The filter can be a function, an\n * object, a string, or undefined.\n */\nexport function isFilterEmpty(\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  filter: ((q: any) => any) | object | string | undefined\n): filter is undefined {\n  if (!filter) return true;\n  // for Milvus\n  if (typeof filter === \"string\" && filter.length > 0) {\n    return false;\n  }\n  if (typeof filter === \"function\") {\n    return false;\n  }\n  return isObject(filter) && Object.keys(filter).length === 0;\n}\n\n/**\n * Checks if the provided value is an integer.\n */\nexport function isInt(value: unknown): boolean {\n  if (typeof value === \"number\") {\n    return value % 1 === 0;\n  } else if (typeof value === \"string\") {\n    const numberValue = parseInt(value, 10);\n    return (\n      !Number.isNaN(numberValue) &&\n      numberValue % 1 === 0 &&\n      numberValue.toString() === value\n    );\n  }\n\n  return false;\n}\n\n/**\n * Checks if the provided value is a floating-point number.\n */\nexport function isFloat(value: unknown): boolean {\n  if (typeof value === \"number\") {\n    return value % 1 !== 0;\n  } else if (typeof value === \"string\") {\n    const numberValue = parseFloat(value);\n    return (\n      !Number.isNaN(numberValue) &&\n      numberValue % 1 !== 0 &&\n      numberValue.toString() === value\n    );\n  }\n\n  return false;\n}\n\n/**\n * Checks if the provided value is a string that cannot be parsed into a\n * number.\n */\nexport function isString(value: unknown): boolean {\n  return (\n    typeof value === \"string\" &&\n    (Number.isNaN(parseFloat(value)) || parseFloat(value).toString() !== value)\n  );\n}\n\n/**\n * Checks if the provided value is a boolean.\n */\nexport function isBoolean(value: unknown): boolean {\n  return typeof value === \"boolean\";\n}\n\n/**\n * Casts a value that might be string or number to actual string or number.\n * Since LLM might return back an integer/float as a string, we need to cast\n * it back to a number, as many vector databases can't handle number as string\n * values as a comparator.\n */\nexport function castValue(input: unknown): string | number | boolean {\n  let value;\n  if (isString(input)) {\n    value = input as string;\n  } else if (isInt(input)) {\n    value = parseInt(input as string, 10);\n  } else if (isFloat(input)) {\n    value = parseFloat(input as string);\n  } else if (isBoolean(input)) {\n    value = Boolean(input);\n  } else {\n    throw new Error(\"Unsupported value type\");\n  }\n\n  return value;\n}\n"],"mappings":";;;;AAIA,SAAgB,SAAS,KAAyB;AAChD,QAAO,OAAO,OAAO,QAAQ,YAAY,CAAC,MAAM,QAAQ,IAAI;;;;;;AAO9D,SAAgB,cAEd,QACqB;AACrB,KAAI,CAAC,OAAQ,QAAO;AAEpB,KAAI,OAAO,WAAW,YAAY,OAAO,SAAS,EAChD,QAAO;AAET,KAAI,OAAO,WAAW,WACpB,QAAO;AAET,QAAO,SAAS,OAAO,IAAI,OAAO,KAAK,OAAO,CAAC,WAAW;;;;;AAM5D,SAAgB,MAAM,OAAyB;AAC7C,KAAI,OAAO,UAAU,SACnB,QAAO,QAAQ,MAAM;UACZ,OAAO,UAAU,UAAU;EACpC,MAAM,cAAc,SAAS,OAAO,GAAG;AACvC,SACE,CAAC,OAAO,MAAM,YAAY,IAC1B,cAAc,MAAM,KACpB,YAAY,UAAU,KAAK;;AAI/B,QAAO;;;;;AAMT,SAAgB,QAAQ,OAAyB;AAC/C,KAAI,OAAO,UAAU,SACnB,QAAO,QAAQ,MAAM;UACZ,OAAO,UAAU,UAAU;EACpC,MAAM,cAAc,WAAW,MAAM;AACrC,SACE,CAAC,OAAO,MAAM,YAAY,IAC1B,cAAc,MAAM,KACpB,YAAY,UAAU,KAAK;;AAI/B,QAAO;;;;;;AAOT,SAAgB,SAAS,OAAyB;AAChD,QACE,OAAO,UAAU,aAChB,OAAO,MAAM,WAAW,MAAM,CAAC,IAAI,WAAW,MAAM,CAAC,UAAU,KAAK;;;;;AAOzE,SAAgB,UAAU,OAAyB;AACjD,QAAO,OAAO,UAAU;;;;;;;;AAS1B,SAAgB,UAAU,OAA2C;CACnE,IAAI;AACJ,KAAI,SAAS,MAAM,CACjB,SAAQ;UACC,MAAM,MAAM,CACrB,SAAQ,SAAS,OAAiB,GAAG;UAC5B,QAAQ,MAAM,CACvB,SAAQ,WAAW,MAAgB;UAC1B,UAAU,MAAM,CACzB,SAAQ,QAAQ,MAAM;KAEtB,OAAM,IAAI,MAAM,yBAAyB;AAG3C,QAAO"}

package/dist/structured_query/utils.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.cts","names":["isObject","isFilterEmpty","isInt","isFloat","isString","isBoolean","castValue"],"sources":["../../src/structured_query/utils.d.ts"],"sourcesContent":["/**\n * Checks if the provided argument is an object and not an array.\n */\nexport declare function isObject(obj: any): obj is object;\n/**\n * Checks if a provided filter is empty. The filter can be a function, an\n * object, a string, or undefined.\n */\nexport declare function isFilterEmpty(filter: ((q: any) => any) | object | string | undefined): filter is undefined;\n/**\n * Checks if the provided value is an integer.\n */\nexport declare function isInt(value: unknown): boolean;\n/**\n * Checks if the provided value is a floating-point number.\n */\nexport declare function isFloat(value: unknown): boolean;\n/**\n * Checks if the provided value is a string that cannot be parsed into a\n * number.\n */\nexport declare function isString(value: unknown): boolean;\n/**\n * Checks if the provided value is a boolean.\n */\nexport declare function isBoolean(value: unknown): boolean;\n/**\n * Casts a value that might be string or number to actual string or number.\n * Since LLM might return back an integer/float as a string, we need to cast\n * it back to a number, as many vector databases can't handle number as string\n * values as a comparator.\n */\nexport declare function castValue(input: unknown): string | number | boolean;\n//# sourceMappingURL=utils.d.ts.map"],"mappings":";;AAGA;AAKA;AAIwBE,iBATAF,QAAAA,CASK,GAAA,EAAA,GAAA,CAAA,EAAA,GAAA,IAAA,MAAA;AAI7B;AAKA;AAIA;AAOA;iBAxBwBC,aAAAA;;;;iBAIAC,KAAAA;;;;iBAIAC,OAAAA;;;;;iBAKAC,QAAAA;;;;iBAIAC,SAAAA;;;;;;;iBAOAC,SAAAA"}
+{"version":3,"file":"utils.d.cts","names":[],"sources":["../../src/structured_query/utils.ts"],"mappings":";;AAIA;;iBAAgB,QAAA,CAAS,GAAA,QAAW,GAAA;;;AAQpC;;iBAAgB,aAAA,CAEd,MAAA,IAAU,CAAA,+CACT,MAAA;;;;iBAea,KAAA,CAAM,KAAA;;;AAAtB;iBAkBgB,OAAA,CAAQ,KAAA;;;;AAAxB;iBAmBgB,QAAA,CAAS,KAAA;;;;iBAUT,SAAA,CAAU,KAAA;;;;;AAA1B;;iBAUgB,SAAA,CAAU,KAAA"}

package/dist/structured_query/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","names":["isObject","isFilterEmpty","isInt","isFloat","isString","isBoolean","castValue"],"sources":["../../src/structured_query/utils.d.ts"],"sourcesContent":["/**\n * Checks if the provided argument is an object and not an array.\n */\nexport declare function isObject(obj: any): obj is object;\n/**\n * Checks if a provided filter is empty. The filter can be a function, an\n * object, a string, or undefined.\n */\nexport declare function isFilterEmpty(filter: ((q: any) => any) | object | string | undefined): filter is undefined;\n/**\n * Checks if the provided value is an integer.\n */\nexport declare function isInt(value: unknown): boolean;\n/**\n * Checks if the provided value is a floating-point number.\n */\nexport declare function isFloat(value: unknown): boolean;\n/**\n * Checks if the provided value is a string that cannot be parsed into a\n * number.\n */\nexport declare function isString(value: unknown): boolean;\n/**\n * Checks if the provided value is a boolean.\n */\nexport declare function isBoolean(value: unknown): boolean;\n/**\n * Casts a value that might be string or number to actual string or number.\n * Since LLM might return back an integer/float as a string, we need to cast\n * it back to a number, as many vector databases can't handle number as string\n * values as a comparator.\n */\nexport declare function castValue(input: unknown): string | number | boolean;\n//# sourceMappingURL=utils.d.ts.map"],"mappings":";;AAGA;AAKA;AAIwBE,iBATAF,QAAAA,CASK,GAAA,EAAA,GAAA,CAAA,EAAA,GAAA,IAAA,MAAA;AAI7B;AAKA;AAIA;AAOA;iBAxBwBC,aAAAA;;;;iBAIAC,KAAAA;;;;iBAIAC,OAAAA;;;;;iBAKAC,QAAAA;;;;iBAIAC,SAAAA;;;;;;;iBAOAC,SAAAA"}
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/structured_query/utils.ts"],"mappings":";;AAIA;;iBAAgB,QAAA,CAAS,GAAA,QAAW,GAAA;;;AAQpC;;iBAAgB,aAAA,CAEd,MAAA,IAAU,CAAA,+CACT,MAAA;;;;iBAea,KAAA,CAAM,KAAA;;;AAAtB;iBAkBgB,OAAA,CAAQ,KAAA;;;;AAAxB;iBAmBgB,QAAA,CAAS,KAAA;;;;iBAUT,SAAA,CAAU,KAAA;;;;;AAA1B;;iBAUgB,SAAA,CAAU,KAAA"}

package/dist/structured_query/utils.js

@@ -65,7 +65,7 @@ function castValue(input) {
 	else throw new Error("Unsupported value type");
 	return value;
 }
-
 //#endregion
 export { castValue, isBoolean, isFilterEmpty, isFloat, isInt, isObject, isString };
+
 //# sourceMappingURL=utils.js.map

package/dist/structured_query/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","names":["obj: any","filter: ((q: any) => any) | object | string | undefined","value: unknown","input: unknown"],"sources":["../../src/structured_query/utils.ts"],"sourcesContent":["/**\n * Checks if the provided argument is an object and not an array.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isObject(obj: any): obj is object {\n  return obj && typeof obj === \"object\" && !Array.isArray(obj);\n}\n\n/**\n * Checks if a provided filter is empty. The filter can be a function, an\n * object, a string, or undefined.\n */\nexport function isFilterEmpty(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  filter: ((q: any) => any) | object | string | undefined\n): filter is undefined {\n  if (!filter) return true;\n  // for Milvus\n  if (typeof filter === \"string\" && filter.length > 0) {\n    return false;\n  }\n  if (typeof filter === \"function\") {\n    return false;\n  }\n  return isObject(filter) && Object.keys(filter).length === 0;\n}\n\n/**\n * Checks if the provided value is an integer.\n */\nexport function isInt(value: unknown): boolean {\n  if (typeof value === \"number\") {\n    return value % 1 === 0;\n  } else if (typeof value === \"string\") {\n    const numberValue = parseInt(value, 10);\n    return (\n      !Number.isNaN(numberValue) &&\n      numberValue % 1 === 0 &&\n      numberValue.toString() === value\n    );\n  }\n\n  return false;\n}\n\n/**\n * Checks if the provided value is a floating-point number.\n */\nexport function isFloat(value: unknown): boolean {\n  if (typeof value === \"number\") {\n    return value % 1 !== 0;\n  } else if (typeof value === \"string\") {\n    const numberValue = parseFloat(value);\n    return (\n      !Number.isNaN(numberValue) &&\n      numberValue % 1 !== 0 &&\n      numberValue.toString() === value\n    );\n  }\n\n  return false;\n}\n\n/**\n * Checks if the provided value is a string that cannot be parsed into a\n * number.\n */\nexport function isString(value: unknown): boolean {\n  return (\n    typeof value === \"string\" &&\n    (Number.isNaN(parseFloat(value)) || parseFloat(value).toString() !== value)\n  );\n}\n\n/**\n * Checks if the provided value is a boolean.\n */\nexport function isBoolean(value: unknown): boolean {\n  return typeof value === \"boolean\";\n}\n\n/**\n * Casts a value that might be string or number to actual string or number.\n * Since LLM might return back an integer/float as a string, we need to cast\n * it back to a number, as many vector databases can't handle number as string\n * values as a comparator.\n */\nexport function castValue(input: unknown): string | number | boolean {\n  let value;\n  if (isString(input)) {\n    value = input as string;\n  } else if (isInt(input)) {\n    value = parseInt(input as string, 10);\n  } else if (isFloat(input)) {\n    value = parseFloat(input as string);\n  } else if (isBoolean(input)) {\n    value = Boolean(input);\n  } else {\n    throw new Error(\"Unsupported value type\");\n  }\n\n  return value;\n}\n"],"mappings":";;;;AAIA,SAAgB,SAASA,KAAyB;AAChD,QAAO,OAAO,OAAO,QAAQ,YAAY,CAAC,MAAM,QAAQ,IAAI;AAC7D;;;;;AAMD,SAAgB,cAEdC,QACqB;AACrB,KAAI,CAAC,OAAQ,QAAO;AAEpB,KAAI,OAAO,WAAW,YAAY,OAAO,SAAS,EAChD,QAAO;AAET,KAAI,OAAO,WAAW,WACpB,QAAO;AAET,QAAO,SAAS,OAAO,IAAI,OAAO,KAAK,OAAO,CAAC,WAAW;AAC3D;;;;AAKD,SAAgB,MAAMC,OAAyB;AAC7C,KAAI,OAAO,UAAU,SACnB,QAAO,QAAQ,MAAM;UACZ,OAAO,UAAU,UAAU;EACpC,MAAM,cAAc,SAAS,OAAO,GAAG;AACvC,SACE,CAAC,OAAO,MAAM,YAAY,IAC1B,cAAc,MAAM,KACpB,YAAY,UAAU,KAAK;CAE9B;AAED,QAAO;AACR;;;;AAKD,SAAgB,QAAQA,OAAyB;AAC/C,KAAI,OAAO,UAAU,SACnB,QAAO,QAAQ,MAAM;UACZ,OAAO,UAAU,UAAU;EACpC,MAAM,cAAc,WAAW,MAAM;AACrC,SACE,CAAC,OAAO,MAAM,YAAY,IAC1B,cAAc,MAAM,KACpB,YAAY,UAAU,KAAK;CAE9B;AAED,QAAO;AACR;;;;;AAMD,SAAgB,SAASA,OAAyB;AAChD,QACE,OAAO,UAAU,aAChB,OAAO,MAAM,WAAW,MAAM,CAAC,IAAI,WAAW,MAAM,CAAC,UAAU,KAAK;AAExE;;;;AAKD,SAAgB,UAAUA,OAAyB;AACjD,QAAO,OAAO,UAAU;AACzB;;;;;;;AAQD,SAAgB,UAAUC,OAA2C;CACnE,IAAI;AACJ,KAAI,SAAS,MAAM,EACjB,QAAQ;UACC,MAAM,MAAM,EACrB,QAAQ,SAAS,OAAiB,GAAG;UAC5B,QAAQ,MAAM,EACvB,QAAQ,WAAW,MAAgB;UAC1B,UAAU,MAAM,EACzB,QAAQ,QAAQ,MAAM;KAEtB,OAAM,IAAI,MAAM;AAGlB,QAAO;AACR"}
+{"version":3,"file":"utils.js","names":[],"sources":["../../src/structured_query/utils.ts"],"sourcesContent":["/**\n * Checks if the provided argument is an object and not an array.\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isObject(obj: any): obj is object {\n  return obj && typeof obj === \"object\" && !Array.isArray(obj);\n}\n\n/**\n * Checks if a provided filter is empty. The filter can be a function, an\n * object, a string, or undefined.\n */\nexport function isFilterEmpty(\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  filter: ((q: any) => any) | object | string | undefined\n): filter is undefined {\n  if (!filter) return true;\n  // for Milvus\n  if (typeof filter === \"string\" && filter.length > 0) {\n    return false;\n  }\n  if (typeof filter === \"function\") {\n    return false;\n  }\n  return isObject(filter) && Object.keys(filter).length === 0;\n}\n\n/**\n * Checks if the provided value is an integer.\n */\nexport function isInt(value: unknown): boolean {\n  if (typeof value === \"number\") {\n    return value % 1 === 0;\n  } else if (typeof value === \"string\") {\n    const numberValue = parseInt(value, 10);\n    return (\n      !Number.isNaN(numberValue) &&\n      numberValue % 1 === 0 &&\n      numberValue.toString() === value\n    );\n  }\n\n  return false;\n}\n\n/**\n * Checks if the provided value is a floating-point number.\n */\nexport function isFloat(value: unknown): boolean {\n  if (typeof value === \"number\") {\n    return value % 1 !== 0;\n  } else if (typeof value === \"string\") {\n    const numberValue = parseFloat(value);\n    return (\n      !Number.isNaN(numberValue) &&\n      numberValue % 1 !== 0 &&\n      numberValue.toString() === value\n    );\n  }\n\n  return false;\n}\n\n/**\n * Checks if the provided value is a string that cannot be parsed into a\n * number.\n */\nexport function isString(value: unknown): boolean {\n  return (\n    typeof value === \"string\" &&\n    (Number.isNaN(parseFloat(value)) || parseFloat(value).toString() !== value)\n  );\n}\n\n/**\n * Checks if the provided value is a boolean.\n */\nexport function isBoolean(value: unknown): boolean {\n  return typeof value === \"boolean\";\n}\n\n/**\n * Casts a value that might be string or number to actual string or number.\n * Since LLM might return back an integer/float as a string, we need to cast\n * it back to a number, as many vector databases can't handle number as string\n * values as a comparator.\n */\nexport function castValue(input: unknown): string | number | boolean {\n  let value;\n  if (isString(input)) {\n    value = input as string;\n  } else if (isInt(input)) {\n    value = parseInt(input as string, 10);\n  } else if (isFloat(input)) {\n    value = parseFloat(input as string);\n  } else if (isBoolean(input)) {\n    value = Boolean(input);\n  } else {\n    throw new Error(\"Unsupported value type\");\n  }\n\n  return value;\n}\n"],"mappings":";;;;AAIA,SAAgB,SAAS,KAAyB;AAChD,QAAO,OAAO,OAAO,QAAQ,YAAY,CAAC,MAAM,QAAQ,IAAI;;;;;;AAO9D,SAAgB,cAEd,QACqB;AACrB,KAAI,CAAC,OAAQ,QAAO;AAEpB,KAAI,OAAO,WAAW,YAAY,OAAO,SAAS,EAChD,QAAO;AAET,KAAI,OAAO,WAAW,WACpB,QAAO;AAET,QAAO,SAAS,OAAO,IAAI,OAAO,KAAK,OAAO,CAAC,WAAW;;;;;AAM5D,SAAgB,MAAM,OAAyB;AAC7C,KAAI,OAAO,UAAU,SACnB,QAAO,QAAQ,MAAM;UACZ,OAAO,UAAU,UAAU;EACpC,MAAM,cAAc,SAAS,OAAO,GAAG;AACvC,SACE,CAAC,OAAO,MAAM,YAAY,IAC1B,cAAc,MAAM,KACpB,YAAY,UAAU,KAAK;;AAI/B,QAAO;;;;;AAMT,SAAgB,QAAQ,OAAyB;AAC/C,KAAI,OAAO,UAAU,SACnB,QAAO,QAAQ,MAAM;UACZ,OAAO,UAAU,UAAU;EACpC,MAAM,cAAc,WAAW,MAAM;AACrC,SACE,CAAC,OAAO,MAAM,YAAY,IAC1B,cAAc,MAAM,KACpB,YAAY,UAAU,KAAK;;AAI/B,QAAO;;;;;;AAOT,SAAgB,SAAS,OAAyB;AAChD,QACE,OAAO,UAAU,aAChB,OAAO,MAAM,WAAW,MAAM,CAAC,IAAI,WAAW,MAAM,CAAC,UAAU,KAAK;;;;;AAOzE,SAAgB,UAAU,OAAyB;AACjD,QAAO,OAAO,UAAU;;;;;;;;AAS1B,SAAgB,UAAU,OAA2C;CACnE,IAAI;AACJ,KAAI,SAAS,MAAM,CACjB,SAAQ;UACC,MAAM,MAAM,CACrB,SAAQ,SAAS,OAAiB,GAAG;UAC5B,QAAQ,MAAM,CACvB,SAAQ,WAAW,MAAgB;UAC1B,UAAU,MAAM,CACzB,SAAQ,QAAQ,MAAM;KAEtB,OAAM,IAAI,MAAM,yBAAyB;AAG3C,QAAO"}