night-query-parser 0.0.1

package/README.md

@@ -0,0 +1 @@
+# night-query-parser

package/build/ast/field.d.ts

@@ -0,0 +1,4 @@
+import { SyntaxToken } from './tokenizer';
+import { FieldSelectorNode } from './types';
+export { parseFieldSelector };
+declare function parseFieldSelector(tokens: SyntaxToken[]): FieldSelectorNode;

package/build/ast/field.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFieldSelector = parseFieldSelector;
+const error_1 = require("../error");
+const tokenizer_1 = require("./tokenizer");
+const types_1 = require("./types");
+// Parse field selector from a collection of tokens.
+// Field selector token pattern is (Reference) + (Operator) + (Value)
+function parseFieldSelector(tokens) {
+    const operatorStartIdx = tokens.findIndex((t) => tokenIsFieldOperator(t));
+    if (operatorStartIdx == -1) {
+        throw new Error('Unable to parse field selector, expected field operator');
+    }
+    // Parse field selector reference
+    const fieldReferenceTokens = tokens.splice(0, operatorStartIdx);
+    const fieldSelectorReference = parseFieldSelectorReference(fieldReferenceTokens);
+    // Parse field selector operator
+    const fieldOperatorTokens = [];
+    while (true) {
+        const fieldOperator = tokens.shift();
+        if (!fieldOperator) {
+            throw new error_1.InvalidOrUnexpectedTokens('Unable to parse field selector, invalid operator', tokens);
+        }
+        if (!tokenIsFieldOperator(fieldOperator)) {
+            tokens.unshift(fieldOperator);
+            break;
+        }
+        fieldOperatorTokens.push(fieldOperator);
+    }
+    const fieldSelectorOperator = parseFieldSelectorOperator(fieldOperatorTokens);
+    // Parse field selector value
+    const fieldSelectorValue = parseFieldSelectorValue(tokens);
+    return {
+        type: 'FieldSelector',
+        reference: fieldSelectorReference,
+        operator: fieldSelectorOperator,
+        value: fieldSelectorValue,
+    };
+}
+function tokenIsFieldOperator(token) {
+    return [
+        tokenizer_1.SyntaxTokenTypes.Equal,
+        tokenizer_1.SyntaxTokenTypes.Not,
+        tokenizer_1.SyntaxTokenTypes.GreaterThan,
+        tokenizer_1.SyntaxTokenTypes.LessThan,
+        tokenizer_1.SyntaxTokenTypes.ILike,
+        tokenizer_1.SyntaxTokenTypes.Regex,
+    ].includes(token.type);
+}
+function parseFieldSelectorReference(tokens) {
+    // Single reference
+    if (tokens.length == 1 && tokens[0].type == tokenizer_1.SyntaxTokenTypes.Reference) {
+        return { type: 'FieldReference', paths: tokens };
+    }
+    // Joined references
+    const joinedReferencesTokenTypes = [
+        tokenizer_1.SyntaxTokenTypes.Reference,
+        tokenizer_1.SyntaxTokenTypes.ReferenceJoin,
+    ];
+    if (tokens.length > 1 &&
+        tokens.every((t) => joinedReferencesTokenTypes.includes(t.type))) {
+        // Ensure references are joined properly
+        const joinsIdx = tokens.map((_, idx) => idx);
+        if (joinsIdx.every((idx) => idx % 2 == 1)) {
+            throw new error_1.InvalidOrUnexpectedTokens('Invalid field reference, invalid reference joins', tokens);
+        }
+        const references = tokens.filter((t) => t.type == tokenizer_1.SyntaxTokenTypes.Reference);
+        return { type: 'FieldReference', paths: references };
+    }
+    throw new error_1.InvalidOrUnexpectedTokens('Unexpected tokens while parsing field selector reference', tokens);
+}
+function parseFieldSelectorOperator(tokens) {
+    if (tokens.length === 1) {
+        const operator = tokens[0];
+        switch (operator.type) {
+            case tokenizer_1.SyntaxTokenTypes.GreaterThan:
+                return types_1.FieldOperatorNode.GreaterThan;
+            case tokenizer_1.SyntaxTokenTypes.LessThan:
+                return types_1.FieldOperatorNode.LessThan;
+            case tokenizer_1.SyntaxTokenTypes.Equal:
+                return types_1.FieldOperatorNode.Equal;
+            case tokenizer_1.SyntaxTokenTypes.Not:
+                return types_1.FieldOperatorNode.NotEqual;
+            case tokenizer_1.SyntaxTokenTypes.ILike:
+                return types_1.FieldOperatorNode.ILike;
+            case tokenizer_1.SyntaxTokenTypes.Regex:
+                return types_1.FieldOperatorNode.Regex;
+        }
+    }
+    if (tokens.length === 2) {
+        const hasGreaterThan = tokens.some((o) => o.type === tokenizer_1.SyntaxTokenTypes.GreaterThan);
+        const hasLessThan = tokens.some((o) => o.type === tokenizer_1.SyntaxTokenTypes.LessThan);
+        const hasEqual = tokens.some((o) => o.type === tokenizer_1.SyntaxTokenTypes.Equal);
+        const hasNotEqual = tokens.some((o) => o.type === tokenizer_1.SyntaxTokenTypes.Not);
+        const hasRegex = tokens.some((o) => o.type === tokenizer_1.SyntaxTokenTypes.Regex);
+        if (hasGreaterThan && hasEqual)
+            return types_1.FieldOperatorNode.GreaterThanOrEqual;
+        if (hasLessThan && hasEqual)
+            return types_1.FieldOperatorNode.LessThanOrEqual;
+        if (hasRegex && hasEqual)
+            return types_1.FieldOperatorNode.Regex;
+        if (hasNotEqual && hasEqual)
+            return types_1.FieldOperatorNode.NotEqual;
+        if (hasEqual &&
+            !hasGreaterThan &&
+            !hasLessThan &&
+            !hasRegex &&
+            !hasNotEqual) {
+            return types_1.FieldOperatorNode.Equal;
+        }
+    }
+    throw new error_1.InvalidOrUnexpectedTokens('Unexpected token pattern while parsing field selector operator', tokens);
+}
+function parseFieldSelectorValue(tokens) {
+    // Single literal value or reference
+    if (tokens.length == 1) {
+        const token = tokens[0];
+        if ([
+            tokenizer_1.SyntaxTokenTypes.QuotedText,
+            tokenizer_1.SyntaxTokenTypes.Number,
+            tokenizer_1.SyntaxTokenTypes.True,
+            tokenizer_1.SyntaxTokenTypes.False,
+        ].includes(token.type)) {
+            return { type: 'FieldSelectorValueLiteral', token };
+        }
+        else if (token.type == tokenizer_1.SyntaxTokenTypes.Reference) {
+            return { type: 'FieldReference', paths: [token] };
+        }
+    }
+    // Joined references
+    const joinedReferencesTokenTypes = [
+        tokenizer_1.SyntaxTokenTypes.Reference,
+        tokenizer_1.SyntaxTokenTypes.ReferenceJoin,
+    ];
+    if (tokens.length > 1 &&
+        tokens.every((t) => joinedReferencesTokenTypes.includes(t.type))) {
+        // Ensure references are joined properly
+        const joinsIdx = tokens.map((_, idx) => idx);
+        if (joinsIdx.every((idx) => idx % 2 == 1)) {
+            throw new Error('Invalid field reference, invalid reference joins');
+        }
+        const references = tokens.filter((t) => t.type == tokenizer_1.SyntaxTokenTypes.Reference);
+        return { type: 'FieldReference', paths: references };
+    }
+    // Subgroups
+    if ([
+        tokenizer_1.SyntaxTokenTypes.OpenArrayGroup,
+        tokenizer_1.SyntaxTokenTypes.OpenSubQuery,
+    ].includes(tokens[0].type)) {
+        // todo
+        throw new Error('Not implemented');
+    }
+    throw new error_1.InvalidOrUnexpectedTokens('Unexpected tokens while parsing field selector value', tokens);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/ast/group.d.ts

@@ -0,0 +1,4 @@
+import { SyntaxToken } from './tokenizer';
+import { FieldGroupNode } from './types';
+export { parseFieldGroup };
+declare function parseFieldGroup(tokens: SyntaxToken[]): FieldGroupNode;

package/build/ast/group.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFieldGroup = parseFieldGroup;
+const error_1 = require("../error");
+const field_1 = require("./field");
+const tokenizer_1 = require("./tokenizer");
+const types_1 = require("./types");
+function parseFieldGroup(tokens) {
+    // If tokens start and end with group token,
+    // remove the group tokens
+    const firstOpenGroupToken = tokens.findIndex((t) => t.type == tokenizer_1.SyntaxTokenTypes.OpenGroup);
+    const lastOpenGroupToken = tokens.findIndex((t) => t.type == tokenizer_1.SyntaxTokenTypes.CloseGroup);
+    if (firstOpenGroupToken == 0 && lastOpenGroupToken == tokens.length - 1) {
+        tokens.shift();
+        tokens.pop();
+    }
+    // Extract position of all operators in base depth
+    const operators = new Map();
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (tokenIsPrimaryGroupOperator(token)) {
+            const groupOperator = parsePrimaryGroupOperator(token);
+            operators.set(groupOperator, [
+                ...(operators.get(groupOperator) ?? []),
+                i,
+            ]);
+            // If next token is a open group token,
+            // skip tokens until matching close group token
+            const startingGroupToken = tokens[i + 1];
+            if (startingGroupToken?.type == tokenizer_1.SyntaxTokenTypes.OpenGroup) {
+                const groupTokenEndIdx = (0, tokenizer_1.findClosingGroupTokenIdx)(tokens, i + 2, startingGroupToken.type);
+                i = groupTokenEndIdx;
+            }
+        }
+    }
+    // If there are no operators,
+    // parse tokens as a single field selector with AND operator.
+    // This should only every run at base depth.
+    if (operators.size == 0) {
+        const fieldSelector = (0, field_1.parseFieldSelector)(tokens);
+        return {
+            type: 'FieldGroup',
+            operator: types_1.FieldGroupOperatorNode.And,
+            children: [fieldSelector],
+        };
+    }
+    // Decide what operate for current group based on precedence rules
+    const operatorOrder = [
+        types_1.FieldGroupOperatorNode.Or,
+        types_1.FieldGroupOperatorNode.And,
+    ];
+    let groupOperator;
+    for (const op of operatorOrder) {
+        if (operators.has(op)) {
+            groupOperator = op;
+            break;
+        }
+    }
+    const fieldGroup = {
+        type: 'FieldGroup',
+        operator: groupOperator,
+        children: [],
+    };
+    // Split tokens between operator
+    const operatorTokenPositions = operators.get(fieldGroup.operator);
+    const splitOperatorTokens = operatorTokenPositions.flatMap((position, idx) => {
+        const split = [];
+        if (idx == 0) {
+            split.push(tokens.slice(0, position));
+        }
+        if (idx == operatorTokenPositions.length - 1) {
+            split.push(tokens.slice(position + 1));
+        }
+        if (idx != 0 && idx != operatorTokenPositions.length - 1) {
+            split.push(tokens.slice(operatorTokenPositions[idx - 1] + 1, position));
+        }
+        return split;
+    });
+    const emptyOperatorTokensIdx = splitOperatorTokens.findIndex((t) => t.length == 0);
+    if (emptyOperatorTokensIdx != -1) {
+        const operatorToken = tokens[operatorTokenPositions[emptyOperatorTokensIdx]];
+        throw new error_1.InvalidOrUnexpectedTokens('Group operator must be followed by a valid expression', [operatorToken]);
+    }
+    for (const tokens of splitOperatorTokens) {
+        // If tokens start and end with group token,
+        // remove the group tokens
+        const firstOpenGroupToken = tokens.findIndex((t) => t.type == tokenizer_1.SyntaxTokenTypes.OpenGroup);
+        const lastOpenGroupToken = tokens.findIndex((t) => t.type == tokenizer_1.SyntaxTokenTypes.CloseGroup);
+        if (firstOpenGroupToken == 0 &&
+            lastOpenGroupToken == tokens.length - 1) {
+            tokens.shift();
+            tokens.pop();
+        }
+        // If token starts with NOT group operator,
+        // parse remaining tokens as a group, then add NOT group on top
+        if (tokens[0].type == tokenizer_1.SyntaxTokenTypes.Not) {
+            tokens.splice(0, 1);
+            const group = parseFieldGroup(tokens);
+            const notGroup = {
+                type: 'FieldGroup',
+                operator: types_1.FieldGroupOperatorNode.Not,
+                children: [group],
+            };
+            fieldGroup.children.push(notGroup);
+            continue;
+        }
+        // If tokens contains primary group operator,
+        // assume this is another depth and recursively build that group
+        const tokensGroupOperator = tokens.find((t) => tokenIsPrimaryGroupOperator(t));
+        if (tokensGroupOperator != null) {
+            const group = parseFieldGroup(tokens);
+            fieldGroup.children.push(group);
+            continue;
+        }
+        // If none of the previous conditions match,
+        // assume this is a single field selector and parse it
+        const fieldSelector = (0, field_1.parseFieldSelector)(tokens);
+        fieldGroup.children.push(fieldSelector);
+    }
+    return fieldGroup;
+}
+function tokenIsPrimaryGroupOperator(token) {
+    return [tokenizer_1.SyntaxTokenTypes.And, tokenizer_1.SyntaxTokenTypes.Or].includes(token.type);
+}
+function parsePrimaryGroupOperator(token) {
+    const type = token.type;
+    if (type == tokenizer_1.SyntaxTokenTypes.And) {
+        return types_1.FieldGroupOperatorNode.And;
+    }
+    else if (type == tokenizer_1.SyntaxTokenTypes.Or) {
+        return types_1.FieldGroupOperatorNode.Or;
+    }
+    throw new error_1.InvalidOrUnexpectedTokens('Unexpected token, unable to parse group operator', [token]);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/ast/query.d.ts

@@ -0,0 +1,2 @@
+import { QueryNode } from './types';
+export declare function parseQuery(query: string): QueryNode;

package/build/ast/query.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseQuery = parseQuery;
+const group_1 = require("./group");
+const tokenizer_1 = require("./tokenizer");
+const types_1 = require("./types");
+function parseQuery(query) {
+    const tokens = (0, tokenizer_1.tokenize)(query);
+    if (tokens.length == 0) {
+        return {
+            type: 'Query',
+            groups: {
+                type: 'FieldGroup',
+                operator: types_1.FieldGroupOperatorNode.And,
+                children: [],
+            },
+        };
+    }
+    const fieldGroups = (0, group_1.parseFieldGroup)(tokens);
+    return {
+        type: 'Query',
+        groups: fieldGroups,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXN0L3F1ZXJ5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBSUEsZ0NBa0JDO0FBdEJELG1DQUEwQztBQUMxQywyQ0FBdUM7QUFDdkMsbUNBQTREO0FBRTVELFNBQWdCLFVBQVUsQ0FBQyxLQUFhO0lBQ3BDLE1BQU0sTUFBTSxHQUFHLElBQUEsb0JBQVEsRUFBQyxLQUFLLENBQUMsQ0FBQztJQUMvQixJQUFJLE1BQU0sQ0FBQyxNQUFNLElBQUksQ0FBQyxFQUFFLENBQUM7UUFDckIsT0FBTztZQUNILElBQUksRUFBRSxPQUFPO1lBQ2IsTUFBTSxFQUFFO2dCQUNKLElBQUksRUFBRSxZQUFZO2dCQUNsQixRQUFRLEVBQUUsOEJBQXNCLENBQUMsR0FBRztnQkFDcEMsUUFBUSxFQUFFLEVBQUU7YUFDZjtTQUNKLENBQUM7SUFDTixDQUFDO0lBRUQsTUFBTSxXQUFXLEdBQUcsSUFBQSx1QkFBZSxFQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQzVDLE9BQU87UUFDSCxJQUFJLEVBQUUsT0FBTztRQUNiLE1BQU0sRUFBRSxXQUFXO0tBQ3RCLENBQUM7QUFDTixDQUFDIn0=

package/build/ast/tokenizer.d.ts

@@ -0,0 +1,36 @@
+export declare enum SyntaxTokenTypes {
+    Reference = 0,
+    Number = 1,
+    Quote = 2,
+    QuotedText = 3,
+    ReferenceJoin = 4,
+    OpenGroup = 5,
+    CloseGroup = 6,
+    OpenArrayGroup = 7,
+    CloseArrayGroup = 8,
+    OpenSubQuery = 9,
+    CloseSubQuery = 10,
+    And = 11,
+    Or = 12,
+    Not = 13,
+    Equal = 14,
+    GreaterThan = 15,
+    LessThan = 16,
+    ILike = 17,
+    Regex = 18,
+    True = 19,
+    False = 20,
+    Whitespace = 21,
+    InvalidToken = 22
+}
+export interface SyntaxToken {
+    type: SyntaxTokenTypes;
+    value?: string;
+    position: number | [number, number];
+}
+export declare function tokenize(input: string, keepWhitespace?: boolean): SyntaxToken[];
+export declare function findClosingGroupTokenIdx(tokens: SyntaxToken[], startIdx: number, startingGroupToken: SyntaxTokenTypes): number;
+export declare function isGroupToken(tokenType: SyntaxTokenTypes): boolean;
+export declare function isStartingGroupToken(tokenType: SyntaxTokenTypes): boolean;
+export declare function isEndingGroupToken(tokenType: SyntaxTokenTypes): boolean;
+export declare function endingGroupToken(startingGroupTokenType: SyntaxTokenTypes): SyntaxTokenTypes;

package/build/ast/tokenizer.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyntaxTokenTypes = void 0;
+exports.tokenize = tokenize;
+exports.findClosingGroupTokenIdx = findClosingGroupTokenIdx;
+exports.isGroupToken = isGroupToken;
+exports.isStartingGroupToken = isStartingGroupToken;
+exports.isEndingGroupToken = isEndingGroupToken;
+exports.endingGroupToken = endingGroupToken;
+const error_1 = require("../error");
+var SyntaxTokenTypes;
+(function (SyntaxTokenTypes) {
+    SyntaxTokenTypes[SyntaxTokenTypes["Reference"] = 0] = "Reference";
+    SyntaxTokenTypes[SyntaxTokenTypes["Number"] = 1] = "Number";
+    SyntaxTokenTypes[SyntaxTokenTypes["Quote"] = 2] = "Quote";
+    SyntaxTokenTypes[SyntaxTokenTypes["QuotedText"] = 3] = "QuotedText";
+    SyntaxTokenTypes[SyntaxTokenTypes["ReferenceJoin"] = 4] = "ReferenceJoin";
+    SyntaxTokenTypes[SyntaxTokenTypes["OpenGroup"] = 5] = "OpenGroup";
+    SyntaxTokenTypes[SyntaxTokenTypes["CloseGroup"] = 6] = "CloseGroup";
+    SyntaxTokenTypes[SyntaxTokenTypes["OpenArrayGroup"] = 7] = "OpenArrayGroup";
+    SyntaxTokenTypes[SyntaxTokenTypes["CloseArrayGroup"] = 8] = "CloseArrayGroup";
+    SyntaxTokenTypes[SyntaxTokenTypes["OpenSubQuery"] = 9] = "OpenSubQuery";
+    SyntaxTokenTypes[SyntaxTokenTypes["CloseSubQuery"] = 10] = "CloseSubQuery";
+    SyntaxTokenTypes[SyntaxTokenTypes["And"] = 11] = "And";
+    SyntaxTokenTypes[SyntaxTokenTypes["Or"] = 12] = "Or";
+    SyntaxTokenTypes[SyntaxTokenTypes["Not"] = 13] = "Not";
+    SyntaxTokenTypes[SyntaxTokenTypes["Equal"] = 14] = "Equal";
+    SyntaxTokenTypes[SyntaxTokenTypes["GreaterThan"] = 15] = "GreaterThan";
+    SyntaxTokenTypes[SyntaxTokenTypes["LessThan"] = 16] = "LessThan";
+    SyntaxTokenTypes[SyntaxTokenTypes["ILike"] = 17] = "ILike";
+    SyntaxTokenTypes[SyntaxTokenTypes["Regex"] = 18] = "Regex";
+    SyntaxTokenTypes[SyntaxTokenTypes["True"] = 19] = "True";
+    SyntaxTokenTypes[SyntaxTokenTypes["False"] = 20] = "False";
+    SyntaxTokenTypes[SyntaxTokenTypes["Whitespace"] = 21] = "Whitespace";
+    SyntaxTokenTypes[SyntaxTokenTypes["InvalidToken"] = 22] = "InvalidToken";
+})(SyntaxTokenTypes || (exports.SyntaxTokenTypes = SyntaxTokenTypes = {}));
+const Tokens = {
+    '"': SyntaxTokenTypes.Quote,
+    "'": SyntaxTokenTypes.Quote,
+    '`': SyntaxTokenTypes.Quote,
+    '.': SyntaxTokenTypes.ReferenceJoin,
+    '(': SyntaxTokenTypes.OpenGroup,
+    ')': SyntaxTokenTypes.CloseGroup,
+    '[': SyntaxTokenTypes.OpenArrayGroup,
+    ']': SyntaxTokenTypes.CloseArrayGroup,
+    '{': SyntaxTokenTypes.OpenSubQuery,
+    '}': SyntaxTokenTypes.CloseSubQuery,
+    and: SyntaxTokenTypes.And,
+    '&': SyntaxTokenTypes.And,
+    ',': SyntaxTokenTypes.And,
+    or: SyntaxTokenTypes.Or,
+    '|': SyntaxTokenTypes.Or,
+    not: SyntaxTokenTypes.Not,
+    '!': SyntaxTokenTypes.Not,
+    '=': SyntaxTokenTypes.Equal,
+    ':': SyntaxTokenTypes.Equal,
+    '>': SyntaxTokenTypes.GreaterThan,
+    '<': SyntaxTokenTypes.LessThan,
+    ilike: SyntaxTokenTypes.ILike,
+    '~': SyntaxTokenTypes.Regex,
+    true: SyntaxTokenTypes.True,
+    false: SyntaxTokenTypes.False,
+    ' ': SyntaxTokenTypes.Whitespace,
+};
+// Normalize an input string by trimming extra spaces.
+function normalize(input) {
+    return input.replace(/\s+/g, ' ').trim();
+}
+// Checks if input is a valid reference value.
+// A reference value is a non-empty string containing either
+// alphabetic characters and underscores OR only numeric characters
+// (but not both).
+function validReferenceValue(input) {
+    if (input.length === 0)
+        return false;
+    return /^[a-zA-Z_]+$/.test(input) || /^[0-9]+$/.test(input);
+}
+function tokenize(input, keepWhitespace = false) {
+    input = normalize(input);
+    const syntaxTokens = [];
+    const tokens = input.split('');
+    for (let i = 0; i < tokens.length; i++) {
+        const previousSyntaxToken = syntaxTokens[syntaxTokens.length - 1];
+        const previousEndPosition = previousSyntaxToken
+            ? Array.isArray(previousSyntaxToken.position)
+                ? previousSyntaxToken.position[1]
+                : previousSyntaxToken.position
+            : null;
+        const startPosition = previousEndPosition != null ? previousEndPosition + 1 : 0;
+        const tokenValue = tokens[i];
+        const token = {
+            type: Tokens[tokenValue.toLowerCase()],
+            value: tokenValue,
+            position: startPosition,
+        };
+        // Parse full quoted text as a single token
+        if (token.type == SyntaxTokenTypes.Quote) {
+            const nextTokens = tokens.slice(i + 1);
+            const endQuoteTokenIncludedIdx = nextTokens.findIndex((t) => t == token.value);
+            if (endQuoteTokenIncludedIdx == -1) {
+                // TODO: throw error
+                throw new Error('Quote must have a closing token');
+            }
+            const quoteTokens = [
+                tokenValue,
+                ...tokens.splice(i + 1, endQuoteTokenIncludedIdx + 1),
+            ];
+            const quoteToken = quoteTokens.join('');
+            const quoteTokenUnquoted = quoteToken.slice(1, -1);
+            token.type = SyntaxTokenTypes.QuotedText;
+            token.value = quoteTokenUnquoted;
+            token.position = [
+                startPosition,
+                startPosition + endQuoteTokenIncludedIdx + 1,
+            ];
+        }
+        // Attempt to parse multi-character tokens and references
+        if (token.type == null) {
+            const nextTokens = tokens.slice(i + 1);
+            let endWordExcludedIdx = nextTokens.findIndex((t) => {
+                return !t.match(/\w/g);
+            });
+            if (endWordExcludedIdx == -1) {
+                endWordExcludedIdx = nextTokens.length;
+            }
+            const word = tokens.slice(i, i + endWordExcludedIdx + 1).join('');
+            const wordTokenType = Tokens[word.toLowerCase()];
+            if (wordTokenType != null) {
+                tokens.splice(i + 1, endWordExcludedIdx);
+                token.type = wordTokenType;
+                token.value = word;
+                token.position = [
+                    startPosition,
+                    startPosition + endWordExcludedIdx,
+                ];
+            }
+            else if (!isNaN(parseFloat(word)) &&
+                parseFloat(word).toString() == word) {
+                tokens.splice(i + 1, endWordExcludedIdx);
+                token.type = SyntaxTokenTypes.Number;
+                token.value = word;
+                token.position = [
+                    startPosition,
+                    startPosition + endWordExcludedIdx,
+                ];
+            }
+            else if (validReferenceValue(word)) {
+                tokens.splice(i + 1, endWordExcludedIdx);
+                token.type = SyntaxTokenTypes.Reference;
+                token.value = word;
+                token.position = [
+                    startPosition,
+                    startPosition + endWordExcludedIdx,
+                ];
+            }
+        }
+        if (token.type == null) {
+            throw new error_1.InvalidOrUnexpectedTokens('Unknown token', [token]);
+        }
+        if (Array.isArray(token.position) &&
+            token.position[0] == token.position[1]) {
+            token.position = token.position[0];
+        }
+        syntaxTokens.push(token);
+    }
+    if (!keepWhitespace) {
+        const syntaxTokensWithoutWhitespace = syntaxTokens.filter((t) => t.type != SyntaxTokenTypes.Whitespace);
+        return syntaxTokensWithoutWhitespace;
+    }
+    else {
+        return syntaxTokens;
+    }
+}
+function findClosingGroupTokenIdx(tokens, startIdx, startingGroupToken) {
+    const endingTokenType = endingGroupToken(startingGroupToken);
+    for (let i = startIdx; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (isStartingGroupToken(token.type)) {
+            const endPosition = findClosingGroupTokenIdx(tokens, i + 1, token.type);
+            i = endPosition + 1;
+            continue;
+        }
+        if (isEndingGroupToken(token.type)) {
+            if (token.type == endingTokenType) {
+                return i;
+            }
+            throw new error_1.InvalidOrUnexpectedTokens('Unexpected token, no group starting token', [token]);
+        }
+    }
+    throw new error_1.InvalidOrUnexpectedTokens('Invalid tokens, expected group to end', tokens.slice(startIdx));
+}
+function isGroupToken(tokenType) {
+    return isStartingGroupToken(tokenType) || isEndingGroupToken(tokenType);
+}
+function isStartingGroupToken(tokenType) {
+    return [
+        SyntaxTokenTypes.OpenGroup,
+        SyntaxTokenTypes.OpenArrayGroup,
+        SyntaxTokenTypes.OpenSubQuery,
+    ].includes(tokenType);
+}
+function isEndingGroupToken(tokenType) {
+    return [
+        SyntaxTokenTypes.CloseGroup,
+        SyntaxTokenTypes.CloseArrayGroup,
+        SyntaxTokenTypes.CloseSubQuery,
+    ].includes(tokenType);
+}
+function endingGroupToken(startingGroupTokenType) {
+    switch (startingGroupTokenType) {
+        case SyntaxTokenTypes.OpenGroup:
+            return SyntaxTokenTypes.CloseGroup;
+        case SyntaxTokenTypes.OpenArrayGroup:
+            return SyntaxTokenTypes.CloseArrayGroup;
+        case SyntaxTokenTypes.OpenSubQuery:
+            return SyntaxTokenTypes.CloseSubQuery;
+    }
+    throw new error_1.InvalidOrUnexpectedTokens(`Unknown starting group token ${startingGroupTokenType}`, []);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tokenizer.js","sourceRoot":"","sources":["../../src/ast/tokenizer.ts"],"names":[],"mappings":"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"}

package/build/ast/types.d.ts

@@ -0,0 +1,49 @@
+import { SyntaxToken } from './tokenizer';
+export interface QueryNode {
+    type: 'Query';
+    groups: FieldGroupNode;
+}
+export declare enum FieldGroupOperatorNode {
+    And = 0,
+    Or = 1,
+    Not = 2
+}
+export interface FieldGroupNode {
+    type: 'FieldGroup';
+    operator: FieldGroupOperatorNode;
+    children: (FieldSelectorNode | FieldGroupNode)[];
+}
+export interface FieldSelectorNode {
+    type: 'FieldSelector';
+    reference: FieldReferenceNode;
+    operator: FieldOperatorNode;
+    value: FieldSelectorValueNode;
+}
+export interface FieldReferenceNode {
+    type: 'FieldReference';
+    paths: SyntaxToken[];
+}
+export declare enum FieldOperatorNode {
+    Equal = 0,
+    NotEqual = 1,
+    GreaterThan = 2,
+    GreaterThanOrEqual = 3,
+    LessThan = 4,
+    LessThanOrEqual = 5,
+    ILike = 6,
+    Regex = 7,
+    Exists = 8
+}
+export type FieldSelectorValueNode = FieldSelectorValueLiteralNode | FieldSelectorValueExistsNode | FieldReferenceNode | SubFieldSelectorsNode | QueryNode;
+export interface FieldSelectorValueLiteralNode {
+    type: 'FieldSelectorValueLiteral';
+    token: SyntaxToken;
+}
+export interface FieldSelectorValueExistsNode {
+    type: 'FieldSelectorValueExists';
+    token: SyntaxToken;
+}
+export interface SubFieldSelectorsNode {
+    type: 'SubFieldSelectors';
+    children: FieldSelectorNode[];
+}

package/build/ast/types.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldOperatorNode = exports.FieldGroupOperatorNode = void 0;
+var FieldGroupOperatorNode;
+(function (FieldGroupOperatorNode) {
+    FieldGroupOperatorNode[FieldGroupOperatorNode["And"] = 0] = "And";
+    FieldGroupOperatorNode[FieldGroupOperatorNode["Or"] = 1] = "Or";
+    FieldGroupOperatorNode[FieldGroupOperatorNode["Not"] = 2] = "Not";
+})(FieldGroupOperatorNode || (exports.FieldGroupOperatorNode = FieldGroupOperatorNode = {}));
+var FieldOperatorNode;
+(function (FieldOperatorNode) {
+    FieldOperatorNode[FieldOperatorNode["Equal"] = 0] = "Equal";
+    FieldOperatorNode[FieldOperatorNode["NotEqual"] = 1] = "NotEqual";
+    FieldOperatorNode[FieldOperatorNode["GreaterThan"] = 2] = "GreaterThan";
+    FieldOperatorNode[FieldOperatorNode["GreaterThanOrEqual"] = 3] = "GreaterThanOrEqual";
+    FieldOperatorNode[FieldOperatorNode["LessThan"] = 4] = "LessThan";
+    FieldOperatorNode[FieldOperatorNode["LessThanOrEqual"] = 5] = "LessThanOrEqual";
+    FieldOperatorNode[FieldOperatorNode["ILike"] = 6] = "ILike";
+    FieldOperatorNode[FieldOperatorNode["Regex"] = 7] = "Regex";
+    FieldOperatorNode[FieldOperatorNode["Exists"] = 8] = "Exists";
+})(FieldOperatorNode || (exports.FieldOperatorNode = FieldOperatorNode = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXN0L3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQU9BLElBQVksc0JBSVg7QUFKRCxXQUFZLHNCQUFzQjtJQUM5QixpRUFBRyxDQUFBO0lBQ0gsK0RBQUUsQ0FBQTtJQUNGLGlFQUFHLENBQUE7QUFDUCxDQUFDLEVBSlcsc0JBQXNCLHNDQUF0QixzQkFBc0IsUUFJakM7QUFvQkQsSUFBWSxpQkFVWDtBQVZELFdBQVksaUJBQWlCO0lBQ3pCLDJEQUFLLENBQUE7SUFDTCxpRUFBUSxDQUFBO0lBQ1IsdUVBQVcsQ0FBQTtJQUNYLHFGQUFrQixDQUFBO0lBQ2xCLGlFQUFRLENBQUE7SUFDUiwrRUFBZSxDQUFBO0lBQ2YsMkRBQUssQ0FBQTtJQUNMLDJEQUFLLENBQUE7SUFDTCw2REFBTSxDQUFBO0FBQ1YsQ0FBQyxFQVZXLGlCQUFpQixpQ0FBakIsaUJBQWlCLFFBVTVCIn0=

package/build/compiler/field.d.ts

@@ -0,0 +1,3 @@
+import { QueryField } from 'night-rest-api/generated';
+import { FieldSelectorNode } from '../ast/types';
+export declare function compileFieldSelector(astFieldSelector: FieldSelectorNode, fieldId?: number): QueryField;

package/build/compiler/field.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileFieldSelector = compileFieldSelector;
+const tokenizer_1 = require("../ast/tokenizer");
+const types_1 = require("../ast/types");
+function compileFieldSelector(astFieldSelector, fieldId = 0) {
+    // Extract query module id and field path from AST field selector reference
+    const reference = astFieldSelector.reference;
+    const referencePaths = reference.paths.map((p) => p.value);
+    const moduleId = referencePaths.shift();
+    const fieldPath = referencePaths;
+    // Construct selector based on AST field selector operator and value
+    const fieldSelectorOperator = astFieldSelector.operator;
+    const fieldSelectorValue = astFieldSelector.value;
+    let selector = null;
+    if (fieldSelectorValue.type == 'FieldSelectorValueLiteral') {
+        const valueToken = fieldSelectorValue.token;
+        const value = valueToken.value;
+        switch (valueToken.type) {
+            case tokenizer_1.SyntaxTokenTypes.QuotedText:
+                selector = {
+                    text: {
+                        eq: fieldSelectorOperator == types_1.FieldOperatorNode.Equal
+                            ? value
+                            : undefined,
+                        ilike: fieldSelectorOperator == types_1.FieldOperatorNode.ILike
+                            ? value
+                            : undefined,
+                        regex: fieldSelectorOperator == types_1.FieldOperatorNode.Regex
+                            ? value
+                            : undefined,
+                    },
+                };
+                break;
+            case tokenizer_1.SyntaxTokenTypes.False:
+            case tokenizer_1.SyntaxTokenTypes.True:
+                selector = {
+                    bool: {
+                        eq: valueToken.type == tokenizer_1.SyntaxTokenTypes.True,
+                    },
+                };
+                break;
+            case tokenizer_1.SyntaxTokenTypes.Number: {
+                const valueNumber = parseFloat(value);
+                selector = {
+                    number: {
+                        eq: fieldSelectorOperator == types_1.FieldOperatorNode.Equal
+                            ? valueNumber
+                            : undefined,
+                        gt: fieldSelectorOperator ==
+                            types_1.FieldOperatorNode.GreaterThan
+                            ? valueNumber
+                            : fieldSelectorOperator ==
+                                types_1.FieldOperatorNode.GreaterThanOrEqual
+                                ? valueNumber - 1
+                                : null,
+                        lt: fieldSelectorOperator == types_1.FieldOperatorNode.LessThan
+                            ? valueNumber
+                            : fieldSelectorOperator ==
+                                types_1.FieldOperatorNode.LessThanOrEqual
+                                ? valueNumber + 1
+                                : undefined,
+                    },
+                };
+            }
+        }
+    }
+    if (!selector) {
+        throw new Error('Unable to parse AST, unknown selector');
+    }
+    return {
+        id: fieldId,
+        path: fieldPath,
+        module_id: moduleId,
+        selector: selector,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/compiler/group.d.ts

@@ -0,0 +1,3 @@
+import { QueryField, QueryGroup } from 'night-rest-api/generated';
+import { FieldGroupNode } from '../ast/types';
+export declare function compileFieldGroup(fieldGroup: FieldGroupNode, fieldIdStart?: number): [QueryGroup, QueryField[]];

package/build/compiler/group.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileFieldGroup = compileFieldGroup;
+const generated_1 = require("night-rest-api/generated");
+const types_1 = require("../ast/types");
+const field_1 = require("./field");
+function compileFieldGroup(fieldGroup, fieldIdStart = 0) {
+    const fields = [];
+    const children = [];
+    // Match operator
+    let operator;
+    switch (fieldGroup.operator) {
+        case types_1.FieldGroupOperatorNode.And:
+            operator = generated_1.QueryFieldGroupOperator.AND;
+            break;
+        case types_1.FieldGroupOperatorNode.Not:
+            operator = generated_1.QueryFieldGroupOperator.NOT;
+            break;
+        case types_1.FieldGroupOperatorNode.Or:
+            operator = generated_1.QueryFieldGroupOperator.OR;
+            break;
+    }
+    // Compile children
+    for (const child of fieldGroup.children) {
+        if (child.type == 'FieldSelector') {
+            const field = (0, field_1.compileFieldSelector)(child, fields.length + fieldIdStart);
+            fields.push(field);
+            children.push(field.id);
+        }
+        else if (child.type == 'FieldGroup') {
+            const [combiledFieldGroup, newFields] = compileFieldGroup(child, fields.length + fieldIdStart);
+            children.push(combiledFieldGroup);
+            fields.push(...newFields);
+        }
+    }
+    return [[operator, children], fields];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3JvdXAuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29tcGlsZXIvZ3JvdXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFXQSw4Q0F5Q0M7QUFwREQsd0RBS2tDO0FBRWxDLHdDQUFzRTtBQUV0RSxtQ0FBK0M7QUFFL0MsU0FBZ0IsaUJBQWlCLENBQzdCLFVBQTBCLEVBQzFCLFlBQVksR0FBRyxDQUFDO0lBRWhCLE1BQU0sTUFBTSxHQUFpQixFQUFFLENBQUM7SUFDaEMsTUFBTSxRQUFRLEdBQXNCLEVBQUUsQ0FBQztJQUV2QyxpQkFBaUI7SUFDakIsSUFBSSxRQUFpQyxDQUFDO0lBQ3RDLFFBQVEsVUFBVSxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQzFCLEtBQUssOEJBQXNCLENBQUMsR0FBRztZQUMzQixRQUFRLEdBQUcsbUNBQXVCLENBQUMsR0FBRyxDQUFDO1lBQ3ZDLE1BQU07UUFDVixLQUFLLDhCQUFzQixDQUFDLEdBQUc7WUFDM0IsUUFBUSxHQUFHLG1DQUF1QixDQUFDLEdBQUcsQ0FBQztZQUN2QyxNQUFNO1FBQ1YsS0FBSyw4QkFBc0IsQ0FBQyxFQUFFO1lBQzFCLFFBQVEsR0FBRyxtQ0FBdUIsQ0FBQyxFQUFFLENBQUM7WUFDdEMsTUFBTTtJQUNkLENBQUM7SUFFRCxtQkFBbUI7SUFDbkIsS0FBSyxNQUFNLEtBQUssSUFBSSxVQUFVLENBQUMsUUFBUSxFQUFFLENBQUM7UUFDdEMsSUFBSSxLQUFLLENBQUMsSUFBSSxJQUFJLGVBQWUsRUFBRSxDQUFDO1lBQ2hDLE1BQU0sS0FBSyxHQUFHLElBQUEsNEJBQW9CLEVBQzlCLEtBQUssRUFDTCxNQUFNLENBQUMsTUFBTSxHQUFHLFlBQVksQ0FDL0IsQ0FBQztZQUNGLE1BQU0sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7WUFDbkIsUUFBUSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDNUIsQ0FBQzthQUFNLElBQUksS0FBSyxDQUFDLElBQUksSUFBSSxZQUFZLEVBQUUsQ0FBQztZQUNwQyxNQUFNLENBQUMsa0JBQWtCLEVBQUUsU0FBUyxDQUFDLEdBQUcsaUJBQWlCLENBQ3JELEtBQUssRUFDTCxNQUFNLENBQUMsTUFBTSxHQUFHLFlBQVksQ0FDL0IsQ0FBQztZQUNGLFFBQVEsQ0FBQyxJQUFJLENBQUMsa0JBQWtCLENBQUMsQ0FBQztZQUNsQyxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsU0FBUyxDQUFDLENBQUM7UUFDOUIsQ0FBQztJQUNMLENBQUM7SUFFRCxPQUFPLENBQUMsQ0FBQyxRQUFRLEVBQUUsUUFBUSxDQUFDLEVBQUUsTUFBTSxDQUFDLENBQUM7QUFDMUMsQ0FBQyJ9

package/build/compiler/query.d.ts

@@ -0,0 +1,3 @@
+import { Query } from 'night-rest-api/generated';
+import { QueryNode } from '../ast/types';
+export declare function compileQuery(query: QueryNode): Query;

package/build/compiler/query.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileQuery = compileQuery;
+const group_1 = require("./group");
+function compileQuery(query) {
+    const [compiledGroups, fields] = (0, group_1.compileFieldGroup)(query.groups);
+    return { fields, grouping: compiledGroups };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29tcGlsZXIvcXVlcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFNQSxvQ0FHQztBQUxELG1DQUE0QztBQUU1QyxTQUFnQixZQUFZLENBQUMsS0FBZ0I7SUFDekMsTUFBTSxDQUFDLGNBQWMsRUFBRSxNQUFNLENBQUMsR0FBRyxJQUFBLHlCQUFpQixFQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUNqRSxPQUFPLEVBQUUsTUFBTSxFQUFFLFFBQVEsRUFBRSxjQUFjLEVBQUUsQ0FBQztBQUNoRCxDQUFDIn0=

package/build/error.d.ts

@@ -0,0 +1,6 @@
+import { SyntaxToken } from './ast/tokenizer';
+export declare class InvalidOrUnexpectedTokens extends Error {
+    tokens: SyntaxToken[];
+    constructor(message: string, tokens: SyntaxToken[]);
+    range(): [number, number];
+}

package/build/error.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidOrUnexpectedTokens = void 0;
+class InvalidOrUnexpectedTokens extends Error {
+    tokens;
+    constructor(message, tokens) {
+        super(message);
+        this.tokens = tokens;
+    }
+    range() {
+        const endIndex = this.tokens.length - 1;
+        const startRange = Array.isArray(this.tokens[0].position)
+            ? this.tokens[0].position[0]
+            : this.tokens[0].position;
+        const endRange = Array.isArray(this.tokens[endIndex].position)
+            ? this.tokens[endIndex].position[1]
+            : this.tokens[endIndex].position;
+        return [startRange, endRange + 1];
+    }
+}
+exports.InvalidOrUnexpectedTokens = InvalidOrUnexpectedTokens;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvZXJyb3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBRUEsTUFBYSx5QkFBMEIsU0FBUSxLQUFLO0lBQ3pDLE1BQU0sQ0FBZ0I7SUFFN0IsWUFBWSxPQUFlLEVBQUUsTUFBcUI7UUFDOUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ2YsSUFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUM7SUFDekIsQ0FBQztJQUVNLEtBQUs7UUFDUixNQUFNLFFBQVEsR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUM7UUFDeEMsTUFBTSxVQUFVLEdBQUcsS0FBSyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQztZQUNyRCxDQUFDLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDO1lBQzVCLENBQUMsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQztRQUM5QixNQUFNLFFBQVEsR0FBRyxLQUFLLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLENBQUMsUUFBUSxDQUFDO1lBQzFELENBQUMsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUM7WUFDbkMsQ0FBQyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLENBQUMsUUFBUSxDQUFDO1FBQ3JDLE9BQU8sQ0FBQyxVQUFVLEVBQUUsUUFBUSxHQUFHLENBQUMsQ0FBQyxDQUFDO0lBQ3RDLENBQUM7Q0FDSjtBQWxCRCw4REFrQkMifQ==

package/build/lib.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGliLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2xpYi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "night-query-parser",
+  "version": "0.0.1",
+  "exports": {
+    "./*": "./build/*.js"
+  },
+  "files": [
+    "build/",
+    "package.json",
+    "README.md"
+  ],
+  "dependencies": {
+    "night-rest-api": "0.0.1"
+  },
+  "devDependencies": {
+    "@jest/globals": "^30.3.0",
+    "@types/lodash": "^4.17.24",
+    "jest": "^30.3.0",
+    "ts-jest": "^29.4.9",
+    "typescript": "^6.0.2"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "prepublish": "pnpm build"
+  }
+}