@claudiu-ceia/combine 0.2.4

package/esm/src/combinators.js

@@ -0,0 +1,531 @@
+import { assert } from "./internal_assert.js";
+import { failure, isFatal, success, } from "./Parser.js";
+import { map } from "./utility.js";
+/**
+ * Apply a variadic list of parsers sequentially. The return type maintains
+ * the order of the parsers such that you get a typed result back.
+ *
+ * // p is a Parser<[number, string, number, string]>
+ * const p = seq(number(), str("-"), number(), str("-"), number());
+ */
+export const seq = (...parsers) => {
+    return (ctx) => {
+        if (parsers.length === 0) {
+            return failure(ctx, `A sequential parser needs to receive at least one parser.`);
+        }
+        const values = [];
+        let nextCtx = ctx;
+        for (const parser of parsers) {
+            const res = parser(nextCtx);
+            if (!res.success) {
+                return res;
+            }
+            values.push(res.value);
+            nextCtx = res.ctx;
+        }
+        return success(nextCtx, values);
+    };
+};
+/**
+ * Try both parsers in sequence, return the first one that's succesful.
+ * Fatal errors from either parser will be propagated immediately.
+ */
+export const either = (a, b) => {
+    return (ctx) => {
+        return any(a, b)(ctx);
+    };
+};
+/**
+ * Try all parsers in order, return the first one that is succesful.
+ * If none match, return the failure result of the parser that
+ * consumed most of the input.
+ *
+ * Fatal errors are propagated immediately without trying remaining parsers.
+ */
+export const any = (...parsers) => {
+    return (ctx) => {
+        let furthestRes;
+        for (const parser of parsers) {
+            const res = parser(ctx);
+            if (res.success) {
+                return res;
+            }
+            // Fatal errors propagate immediately - no backtracking
+            if (isFatal(res)) {
+                return res;
+            }
+            if (!furthestRes || furthestRes.ctx.index < res.ctx.index) {
+                furthestRes = res;
+            }
+        }
+        assert(furthestRes);
+        return furthestRes;
+    };
+};
+/**
+ * Try all parsers in order. If more than one match is found,
+ * it's a failure. If only one matches, return it's result.
+ * If none matches, return the failure result of the parser
+ * that consumed the most input.
+ *
+ * Fatal errors are propagated immediately.
+ */
+export const oneOf = (...parsers) => {
+    return (ctx) => {
+        let match;
+        let furthestRes;
+        for (const parser of parsers) {
+            const res = parser(ctx);
+            // Fatal errors propagate immediately
+            if (!res.success && isFatal(res)) {
+                return res;
+            }
+            if (res.success) {
+                if (match) {
+                    if (match.success) {
+                        return failure(ctx, `expected single parser to match, already matched "${JSON.stringify(match.value)}", now matched ${JSON.stringify(res.value)}`);
+                    }
+                    else {
+                        return failure(ctx, "expected single parser to match", [match]);
+                    }
+                }
+                match = res;
+            }
+            if (!furthestRes || furthestRes.ctx.index < res.ctx.index) {
+                furthestRes = res;
+            }
+        }
+        if (match) {
+            return match;
+        }
+        assert(furthestRes);
+        return furthestRes;
+    };
+};
+/**
+ * Try all parsers in sequence and keep track of which one consumed
+ * the most input, then return it.
+ *
+ * Fatal errors are propagated immediately.
+ */
+export const furthest = (...parsers) => {
+    return (ctx) => {
+        let furthestRes;
+        for (const parser of parsers) {
+            const res = parser(ctx);
+            // Fatal errors propagate immediately
+            if (!res.success && isFatal(res)) {
+                return res;
+            }
+            if (!furthestRes || furthestRes.ctx.index < res.ctx.index) {
+                furthestRes = res;
+            }
+        }
+        assert(furthestRes);
+        return furthestRes;
+    };
+};
+/**
+ * Try a parser. If it matches, return it, otherwise return a `null`
+ * result without consuming any input.
+ *
+ * Fatal errors are propagated - optional only catches non-fatal failures.
+ */
+export const optional = (parser) => {
+    return (ctx) => {
+        const res = parser(ctx);
+        if (res.success) {
+            return res;
+        }
+        // Fatal errors propagate - don't swallow them
+        if (isFatal(res)) {
+            return res;
+        }
+        return success(ctx, null);
+    };
+};
+/**
+ * Match the same parser until it fails. This parser never fails, so even
+ * if it doesn't match it's a succes.
+ *
+ * Fatal errors are propagated immediately.
+ */
+export const many = (parser) => {
+    return (ctx) => {
+        const values = [];
+        let nextCtx = ctx;
+        while (true) {
+            const res = parser(nextCtx);
+            if (!res.success) {
+                // Fatal errors propagate
+                if (isFatal(res)) {
+                    return res;
+                }
+                break;
+            }
+            values.push(res.value);
+            nextCtx = res.ctx;
+        }
+        return success(nextCtx, values);
+    };
+};
+/**
+ * Match the same parser until it fails. Needs to match at least
+ * once to be a success.
+ *
+ * Fatal errors are propagated immediately.
+ */
+export const many1 = (parser) => {
+    return (ctx) => {
+        const res = many(parser)(ctx);
+        // Propagate fatal errors
+        if (!res.success) {
+            return res;
+        }
+        if (ctx.index === res.ctx.index) {
+            return failure(res.ctx, "Expected at least one match");
+        }
+        return res;
+    };
+};
+/**
+ * Match parser until the second parser matches. The result is a tuple
+ * of results for the first parser, with the result of the second parser
+ * appended.
+ *
+ * Fatal errors from either parser are propagated immediately.
+ */
+export const manyTill = (parser, end) => {
+    return (ctx) => {
+        const values = [];
+        let nextCtx = ctx;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const maybeEnd = end(nextCtx);
+            if (maybeEnd.success) {
+                return success(maybeEnd.ctx, [...values, maybeEnd.value]);
+            }
+            // Fatal errors from end parser propagate
+            if (isFatal(maybeEnd)) {
+                return maybeEnd;
+            }
+            const res = parser(nextCtx);
+            if (!res.success) {
+                // Fatal errors from content parser propagate
+                if (isFatal(res)) {
+                    return res;
+                }
+                const maybeEnd = end(nextCtx);
+                if (maybeEnd.success) {
+                    return success(maybeEnd.ctx, [...values, maybeEnd.value]);
+                }
+                else {
+                    return maybeEnd;
+                }
+            }
+            values.push(res.value);
+            nextCtx = res.ctx;
+        }
+    };
+};
+/**
+ * Repeatedly match a parser
+ *
+ * Fatal errors are propagated immediately.
+ */
+export const repeat = (n, parser) => {
+    return (ctx) => {
+        const values = [];
+        let nextCtx = ctx;
+        let idx = 0;
+        while (idx < n) {
+            const res = parser(nextCtx);
+            if (!res.success) {
+                // Propagate fatal errors with their stack
+                if (isFatal(res)) {
+                    return res;
+                }
+                return failure(ctx, res.expected, [], res.stack);
+            }
+            values.push(res.value);
+            nextCtx = res.ctx;
+            idx++;
+        }
+        return success(nextCtx, values);
+    };
+};
+/**
+ * Useful for parsing separated lists. Repeatedly match a sequence of both
+ * parsers while they both match. Doesn't support trailing separators.
+ *
+ * const p = sepBy(number(), str(","));
+ *
+ * const ok = p("1,2,3"); // success
+ * const fail = p("1,2,3,"); // failure, expecting one more number
+ *
+ * If no matches are found, it's a success.
+ *
+ * Fatal errors are propagated immediately.
+ */
+export const sepBy = (parser, sep) => {
+    return (ctx) => {
+        const values = [];
+        let nextCtx = ctx;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const res = parser(nextCtx);
+            // Fatal errors propagate
+            if (!res.success && isFatal(res)) {
+                return res;
+            }
+            if (res.success) {
+                const sepCtx = res.ctx;
+                values.push(res.value);
+                const sepRes = sep(sepCtx);
+                // Fatal errors from separator propagate
+                if (!sepRes.success && isFatal(sepRes)) {
+                    return sepRes;
+                }
+                if (!sepRes.success) {
+                    return success(sepCtx, values);
+                }
+                nextCtx = sepRes.ctx;
+                values.push(sepRes.value);
+                continue;
+            }
+            return success(nextCtx, values);
+        }
+    };
+};
+/**
+ * Same as `sepBy`, but at least one match is required.
+ *
+ * Fatal errors are propagated immediately.
+ */
+export const sepBy1 = (parser, sep) => {
+    return (ctx) => {
+        const res = sepBy(parser, sep)(ctx);
+        // Propagate fatal errors
+        if (!res.success) {
+            return res;
+        }
+        if (res.ctx.index === ctx.index) {
+            const parserTest = parser(ctx);
+            if (parserTest.success) {
+                // This should never happen since `sepBy` didn't match - need to rewrite for statical guarantee
+                return failure(parserTest.ctx, "Unjustified error");
+            }
+            else {
+                return failure(res.ctx, "Expected at least one match", [parserTest]);
+            }
+        }
+        return res;
+    };
+};
+/**
+ * Skips matching parsers while consuming input.
+ *
+ * Fatal errors are propagated immediately.
+ */
+export const skipMany = (parser) => {
+    return (ctx) => {
+        const res = many(parser)(ctx);
+        // Propagate fatal errors
+        if (!res.success) {
+            return res;
+        }
+        return success(res.ctx, null);
+    };
+};
+/**
+ * Skips matching parsers while consuming input. At least one match is required.
+ *
+ * Fatal errors are propagated immediately.
+ */
+export const skipMany1 = (parser) => {
+    return (ctx) => {
+        const res = many1(parser)(ctx);
+        if (res.success) {
+            return success(res.ctx, null);
+        }
+        return res;
+    };
+};
+/**
+ * Match a parser, but don't consume any input.
+ */
+export const peek = (parser) => {
+    return (ctx) => {
+        const res = parser(ctx);
+        if (res.success) {
+            return success(ctx, null);
+        }
+        return failure(ctx, `lookahead failed, ${res.expected}`, [], res.stack);
+    };
+};
+/**
+ * Skips matching a single parser while consuming input.
+ */
+export const skip1 = (parser) => {
+    return (ctx) => {
+        const res = parser(ctx);
+        if (res.success) {
+            return success(res.ctx, null);
+        }
+        return res;
+    };
+};
+export const surrounded = (open, middle, close) => {
+    /* return (ctx) => {
+      const openRes = open(ctx);
+      if (openRes.success) {
+        let cursor = openRes.ctx;
+        let closeRes = close(cursor);
+        while (!closeRes.success) {
+          const res = middle(cursor);
+          if (res.success) {
+  
+          }
+        }
+      }
+    } */
+    return map(seq(open, middle, close), ([_open, middle, _close]) => middle);
+};
+export const minus = (a, b) => {
+    return (ctx) => {
+        const excludedRes = b(ctx);
+        if (excludedRes.success) {
+            return failure(ctx, `Matched excluded "${JSON.stringify(excludedRes.value)}"`);
+        }
+        return a(ctx);
+    };
+};
+export const not = (a) => {
+    return (ctx) => {
+        const res = a(ctx);
+        if (res.success) {
+            return failure(ctx, `Matched "${JSON.stringify(res.value)}"`);
+        }
+        return success(ctx, null);
+    };
+};
+export const keepNonNull = (parser) => map(parser, (matches) => matches.filter((v) => v !== null));
+export const seqNonNull = (...parsers) => keepNonNull(seq(...parsers));
+/**
+ * Parse left-associative infix expressions.
+ * Parses: term (op term)* and folds left using the combine function.
+ *
+ * This is useful for parsing binary operators with the same precedence level.
+ *
+ * @param term - Parser for the operands
+ * @param op - Parser for the operator(s)
+ * @param combine - Function to combine left operand, operator, and right operand
+ * @returns A parser that produces the left-folded result
+ *
+ * @example
+ * ```ts
+ * // Parse addition/subtraction: 1 + 2 - 3 => ((1 + 2) - 3)
+ * const addSub = chainl1(
+ *   numberParser,
+ *   any(str("+"), str("-")),
+ *   (left, op, right) => ({ type: "binary", op, left, right })
+ * );
+ * ```
+ *
+ * Fatal errors are propagated immediately.
+ */
+export const chainl1 = (term, op, combine) => {
+    return (ctx) => {
+        const firstRes = term(ctx);
+        if (!firstRes.success) {
+            return firstRes;
+        }
+        let acc = firstRes.value;
+        let nextCtx = firstRes.ctx;
+        while (true) {
+            const opRes = op(nextCtx);
+            if (!opRes.success) {
+                // Fatal errors propagate
+                if (isFatal(opRes)) {
+                    return opRes;
+                }
+                break;
+            }
+            const rightRes = term(opRes.ctx);
+            if (!rightRes.success) {
+                // Fatal errors propagate
+                if (isFatal(rightRes)) {
+                    return rightRes;
+                }
+                // Operator matched but operand didn't - this is a failure
+                return rightRes;
+            }
+            acc = combine(acc, opRes.value, rightRes.value);
+            nextCtx = rightRes.ctx;
+        }
+        return success(nextCtx, acc);
+    };
+};
+/**
+ * Parse right-associative infix expressions.
+ * Parses: term (op term)* and folds right using the combine function.
+ *
+ * This is useful for operators like exponentiation: 2 ** 3 ** 4 => 2 ** (3 ** 4)
+ *
+ * @param term - Parser for the operands
+ * @param op - Parser for the operator(s)
+ * @param combine - Function to combine left operand, operator, and right operand
+ * @returns A parser that produces the right-folded result
+ *
+ * @example
+ * ```ts
+ * // Parse exponentiation: 2 ** 3 ** 4 => 2 ** (3 ** 4)
+ * const pow = chainr1(
+ *   numberParser,
+ *   str("**"),
+ *   (left, op, right) => ({ type: "binary", op, left, right })
+ * );
+ * ```
+ *
+ * Fatal errors are propagated immediately.
+ */
+export const chainr1 = (term, op, combine) => {
+    return (ctx) => {
+        const firstRes = term(ctx);
+        if (!firstRes.success) {
+            return firstRes;
+        }
+        // Collect all terms and operators
+        const terms = [firstRes.value];
+        const ops = [];
+        let nextCtx = firstRes.ctx;
+        while (true) {
+            const opRes = op(nextCtx);
+            if (!opRes.success) {
+                // Fatal errors propagate
+                if (isFatal(opRes)) {
+                    return opRes;
+                }
+                break;
+            }
+            const rightRes = term(opRes.ctx);
+            if (!rightRes.success) {
+                // Fatal errors propagate
+                if (isFatal(rightRes)) {
+                    return rightRes;
+                }
+                // Operator matched but operand didn't - this is a failure
+                return rightRes;
+            }
+            ops.push(opRes.value);
+            terms.push(rightRes.value);
+            nextCtx = rightRes.ctx;
+        }
+        // Fold right: a op b op c => a op (b op c)
+        let acc = terms[terms.length - 1];
+        for (let i = terms.length - 2; i >= 0; i--) {
+            acc = combine(terms[i], ops[i], acc);
+        }
+        return success(nextCtx, acc);
+    };
+};

package/esm/src/internal_assert.d.ts

@@ -0,0 +1,2 @@
+export declare const assert: (condition: unknown, message?: string) => asserts condition;
+//# sourceMappingURL=internal_assert.d.ts.map

package/esm/src/internal_assert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal_assert.d.ts","sourceRoot":"","sources":["../../src/src/internal_assert.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,MAAM,EAAE,CACnB,SAAS,EAAE,OAAO,EAClB,OAAO,CAAC,EAAE,MAAM,KACb,OAAO,CAAC,SAOZ,CAAC"}

package/esm/src/internal_assert.js

@@ -0,0 +1,5 @@
+export const assert = (condition, message = "Assertion failed") => {
+    if (!condition) {
+        throw new Error(message);
+    }
+};

package/esm/src/language.d.ts

@@ -0,0 +1,12 @@
+import type { Parser } from "./Parser.js";
+export type BoundDefinition<T extends UnboundDefinition<any>> = {
+    [Key in keyof T]: ReturnType<T[Key]>;
+};
+export type UnboundDefinition<T extends BoundDefinition<any>> = {
+    [Key in keyof T]: (self: T) => T[Key];
+};
+export type UntypedLanguage = {
+    [key: string]: Parser<unknown>;
+};
+export declare const createLanguage: <T extends BoundDefinition<any> = UntypedLanguage>(map: UnboundDefinition<T>) => BoundDefinition<UnboundDefinition<T>>;
+//# sourceMappingURL=language.d.ts.map

package/esm/src/language.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language.d.ts","sourceRoot":"","sources":["../../src/src/language.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAG1C,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,iBAAiB,CAAC,GAAG,CAAC,IAAI;KAC7D,GAAG,IAAI,MAAM,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,eAAe,CAAC,GAAG,CAAC,IAAI;KAC7D,GAAG,IAAI,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;CAChC,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,CAAC,SAAS,eAAe,CAAC,GAAG,CAAC,yBAEzB,iBAAiB,CAAC,CAAC,CAAC,KACxB,eAAe,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAetC,CAAC"}

package/esm/src/language.js

@@ -0,0 +1,13 @@
+import { lazy } from "./utility.js";
+export const createLanguage = (map) => {
+    const LanguageDefinition = class LanguageDefinitionClass {
+        constructor() {
+            const bound = {};
+            for (const key of Object.keys(map)) {
+                bound[key] = lazy(() => map[key](this));
+            }
+            Object.assign(this, bound);
+        }
+    };
+    return new LanguageDefinition();
+};

package/esm/src/parsers.d.ts

@@ -0,0 +1,94 @@
+import { type Parser } from "./Parser.js";
+/**
+ * Matches a given string.
+ */
+export declare const str: (match: string) => Parser<string>;
+/**
+ * Matches any of the given strings by using a trie.
+ * Use instead of `any(str("..."), ...) when you want
+ * to match against many possible strings.
+ */
+export declare const trie: (matches: string[]) => Parser<string>;
+/**
+ * Matches a given character by UTF-16 code.
+ */
+export declare const char: (code: number) => Parser<string>;
+/**
+ * Matches any single character.
+ */
+export declare const anyChar: () => Parser<string>;
+/**
+ * Matches any character not matching the given UTF-16 code.
+ */
+export declare const notChar: (code: number) => Parser<string>;
+/**
+ * Matches any character based on a predicate.
+ */
+export declare const charWhere: (pred: (code: number) => boolean) => Parser<string>;
+/**
+ * Skips matching any character not matching the given UTF-16 code.
+ */
+export declare const skipCharWhere: (pred: (code: number) => boolean) => Parser<string | null>;
+/**
+ * Matches any single decimal digit
+ */
+export declare const digit: () => Parser<number>;
+/**
+ * Matches any single letter (case insesitive A-Z)
+ */
+export declare const letter: () => Parser<string>;
+/**
+ * Matches any whitespace
+ */
+export declare const space: () => Parser<string>;
+/**
+ * Matches any `count` characters as long as there's enough input
+ * left to parse.
+ */
+export declare const take: (count: number) => Parser<string>;
+/**
+ * Matches the rest of the input.
+ */
+export declare const takeText: () => Parser<string>;
+/**
+ * Matches an end of line marker
+ */
+export declare const eol: () => Parser<string>;
+/**
+ * Matches if there's no input left to parse
+ */
+export declare const eof: () => Parser<null>;
+/**
+ * Matches horizontal space (spaces/tabs), if at least one space
+ * follows.
+ */
+export declare const horizontalSpace: () => Parser<null>;
+/**
+ * Matches a positive integer
+ */
+export declare const int: () => Parser<number>;
+/**
+ * Matches a dot-separated double
+ */
+export declare const double: () => Parser<number>;
+/**
+ * Matches a hexadecimal digit
+ */
+export declare const hexDigit: () => Parser<string>;
+/**
+ * Matches a hexadecimal number (`0x` lead not allowed)
+ */
+export declare const hex: () => Parser<string>;
+/**
+ * Matches a positive decimal number
+ */
+export declare const number: () => Parser<number>;
+/**
+ * Matches a signed decimal number (with explicit +/- sign)
+ */
+export declare const signed: (nParser?: Parser<number>) => Parser<number>;
+/**
+ * Matches input for given regex
+ */
+export declare const regex: (re: RegExp, expected: string) => Parser<string>;
+//# sourceMappingURL=parsers.d.ts.map

package/esm/src/parsers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsers.d.ts","sourceRoot":"","sources":["../../src/src/parsers.ts"],"names":[],"mappings":"AACA,OAAO,EAAW,KAAK,MAAM,EAAW,MAAM,aAAa,CAAC;AAI5D;;GAEG;AACH,eAAO,MAAM,GAAG,UAAW,MAAM,KAAG,MAAM,CAAC,MAAM,CAShD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,IAAI,YAAa,MAAM,EAAE,KAAG,MAAM,CAAC,MAAM,CAwBrD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,IAAI,SAAU,MAAM,KAAG,MAAM,CAAC,MAAM,CAKhD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,OAAO,QAAO,MAAM,CAAC,MAAM,CAWvC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,OAAO,SAAU,MAAM,KAAG,MAAM,CAAC,MAAM,CAiBnD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS,SAAU,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,KAAG,MAAM,CAAC,MAAM,CAcxE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,SAClB,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,KAC9B,MAAM,CAAC,MAAM,GAAG,IAAI,CAStB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,KAAK,QAAO,MAAM,CAAC,MAAM,CAQrC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,MAAM,QAAO,MAAM,CAAC,MAAM,CAItC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,KAAK,QAAO,MAAM,CAAC,MAAM,CAIrC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,IAAI,UAAW,MAAM,KAAG,MAAM,CAAC,MAAM,CAYjD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,QAAQ,QAAO,MAAM,CAAC,MAAM,CAOxC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,GAAG,QAAO,MAAM,CAAC,MAAM,CAInC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,GAAG,QAAO,MAAM,CAAC,IAAI,CAQjC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,eAAe,QAAO,MAAM,CAAC,IAAI,CAM7C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,GAAG,QAAO,MAAM,CAAC,MAAM,CAInC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,MAAM,QAAO,MAAM,CAAC,MAAM,CAkBtC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,QAAQ,QAAO,MAAM,CAAC,MAAM,CAUxC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,GAAG,QAAO,MAAM,CAAC,MAAM,CASnC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,MAAM,QAAO,MAAM,CAAC,MAAM,CAEtC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,MAAM,aAAa,MAAM,CAAC,MAAM,CAAC,KAAc,MAAM,CAAC,MAAM,CAUxE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,KAAK,OAAQ,MAAM,YAAY,MAAM,KAAG,MAAM,CAAC,MAAM,CAgBjE,CAAC"}