@honua/mcp-server 0.1.2-beta.0 → 0.1.4-beta.0

package/dist/src/certification/cql2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cql2.d.ts","sourceRoot":"","sources":["../../../src/certification/cql2.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,qBAAa,oBAAqB,SAAQ,KAAK;gBACjC,OAAO,EAAE,MAAM;CAI5B;AA2FD,KAAK,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AACnC,KAAK,SAAS,GAAG,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC;AAqQvC,2DAA2D;AAC3D,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAErD"}

package/dist/src/certification/cql2.js

@@ -0,0 +1,354 @@
+/**
+ * Minimal CQL2-text evaluator for the offline OGC API Features fixture (#1005).
+ *
+ * The neutral tool contract lowers `Query.filter` onto CQL2 text for the OGC
+ * family, so an offline fixture that ignored `filter=` would certify a filter
+ * path that never actually filtered. This evaluator parses the exact subset the
+ * SDK's CQL2 compiler emits — comparisons, `IN`, `BETWEEN`, `IS [NOT] NULL`,
+ * `LIKE`/`CASEI`, `AND`/`OR`/`NOT`, parentheses, and `DATE()`/`TIMESTAMP()`
+ * literals — and REFUSES anything else rather than silently matching every row,
+ * which would turn a filter regression into a passing test.
+ *
+ * It is a fixture, not a CQL2 implementation: spatial predicates are out of
+ * scope here (the fixture serves spatial constraints through the `bbox`
+ * parameter, exactly as OGC API Features Part 1 defines).
+ */
+export class Cql2UnsupportedError extends Error {
+    constructor(message) {
+        super(`cql2 fixture: ${message}`);
+        this.name = "Cql2UnsupportedError";
+    }
+}
+const KEYWORDS = new Set(["AND", "OR", "NOT", "IN", "IS", "NULL", "BETWEEN", "LIKE", "TRUE", "FALSE", "CASEI"]);
+/** Temporal predicates the fixture evaluates exactly. */
+const TEMPORAL_FUNCTIONS = new Set(["T_BEFORE", "T_AFTER", "T_DURING", "T_INTERSECTS"]);
+/**
+ * Spatial predicates. OGC API Features Part 1 expresses a spatial constraint
+ * through the `bbox` parameter, which this fixture serves exactly; the Part 3
+ * `S_*` predicates are refused rather than approximated, because a spatial
+ * predicate that silently matched the wrong rows would be worse than an error.
+ */
+const SPATIAL_FUNCTIONS = new Set([
+    "S_INTERSECTS",
+    "S_CONTAINS",
+    "S_WITHIN",
+    "S_CROSSES",
+    "S_TOUCHES",
+    "S_OVERLAPS",
+    "S_DISJOINT",
+    "S_EQUALS",
+]);
+function tokenize(input) {
+    const tokens = [];
+    let i = 0;
+    while (i < input.length) {
+        const ch = input[i];
+        if (ch === " " || ch === "\t" || ch === "\n" || ch === "\r") {
+            i += 1;
+            continue;
+        }
+        if (ch === "'") {
+            let value = "";
+            i += 1;
+            while (i < input.length) {
+                if (input[i] === "'") {
+                    if (input[i + 1] === "'") {
+                        value += "'";
+                        i += 2;
+                        continue;
+                    }
+                    i += 1;
+                    break;
+                }
+                value += input[i];
+                i += 1;
+            }
+            tokens.push({ kind: "string", value });
+            continue;
+        }
+        if (ch === "(" || ch === ")" || ch === ",") {
+            tokens.push({ kind: "symbol", value: ch });
+            i += 1;
+            continue;
+        }
+        const twoChar = input.slice(i, i + 2);
+        if (twoChar === "<=" || twoChar === ">=" || twoChar === "<>") {
+            tokens.push({ kind: "symbol", value: twoChar });
+            i += 2;
+            continue;
+        }
+        if (ch === "=" || ch === "<" || ch === ">") {
+            tokens.push({ kind: "symbol", value: ch });
+            i += 1;
+            continue;
+        }
+        const numberMatch = /^-?\d+(?:\.\d+)?/.exec(input.slice(i));
+        if (numberMatch && /[-\d]/.test(ch)) {
+            tokens.push({ kind: "number", value: numberMatch[0] });
+            i += numberMatch[0].length;
+            continue;
+        }
+        const identMatch = /^[A-Za-z_][A-Za-z0-9_.:]*/.exec(input.slice(i));
+        if (identMatch) {
+            const upper = identMatch[0].toUpperCase();
+            tokens.push({
+                kind: KEYWORDS.has(upper) ? "keyword" : "ident",
+                value: KEYWORDS.has(upper) ? upper : identMatch[0],
+            });
+            i += identMatch[0].length;
+            continue;
+        }
+        throw new Cql2UnsupportedError(`unexpected character "${ch}" in ${JSON.stringify(input)}`);
+    }
+    return tokens;
+}
+class Parser {
+    tokens;
+    index = 0;
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+    peek() {
+        return this.tokens[this.index];
+    }
+    next() {
+        const token = this.tokens[this.index];
+        if (!token)
+            throw new Cql2UnsupportedError("unexpected end of expression");
+        this.index += 1;
+        return token;
+    }
+    accept(kind, value) {
+        const token = this.peek();
+        if (token && token.kind === kind && token.value === value) {
+            this.index += 1;
+            return true;
+        }
+        return false;
+    }
+    expect(kind, value) {
+        if (!this.accept(kind, value)) {
+            throw new Cql2UnsupportedError(`expected "${value}" but found ${JSON.stringify(this.peek()?.value ?? "<end>")}`);
+        }
+    }
+    parse() {
+        const predicate = this.parseOr();
+        if (this.index !== this.tokens.length) {
+            throw new Cql2UnsupportedError(`trailing input at ${JSON.stringify(this.peek()?.value)}`);
+        }
+        return predicate;
+    }
+    parseOr() {
+        let left = this.parseAnd();
+        while (this.accept("keyword", "OR")) {
+            const right = this.parseAnd();
+            const previous = left;
+            left = (row) => previous(row) || right(row);
+        }
+        return left;
+    }
+    parseAnd() {
+        let left = this.parseFactor();
+        while (this.accept("keyword", "AND")) {
+            const right = this.parseFactor();
+            const previous = left;
+            left = (row) => previous(row) && right(row);
+        }
+        return left;
+    }
+    parseFactor() {
+        if (this.accept("keyword", "NOT")) {
+            const inner = this.parseFactor();
+            return (row) => !inner(row);
+        }
+        if (this.accept("symbol", "(")) {
+            const inner = this.parseOr();
+            this.expect("symbol", ")");
+            return inner;
+        }
+        const upcoming = this.peek();
+        if (upcoming?.kind === "ident") {
+            const name = upcoming.value.toUpperCase();
+            if (SPATIAL_FUNCTIONS.has(name)) {
+                throw new Cql2UnsupportedError(`spatial predicate ${name} requires OGC API Features Part 3 filtering, which this endpoint does not publish. Use bbox for an envelope-intersects constraint.`);
+            }
+            if (TEMPORAL_FUNCTIONS.has(name)) {
+                return this.parseTemporal(name);
+            }
+        }
+        return this.parsePredicate();
+    }
+    /** `T_BEFORE(field, TIMESTAMP('…'))` / `T_DURING(field, INTERVAL('…','…'))`. */
+    parseTemporal(name) {
+        this.next();
+        this.expect("symbol", "(");
+        const property = this.next();
+        if (property.kind !== "ident") {
+            throw new Cql2UnsupportedError(`${name} expects a property reference, found ${JSON.stringify(property.value)}`);
+        }
+        this.expect("symbol", ",");
+        const bound = this.parseTemporalOperand();
+        this.expect("symbol", ")");
+        const field = property.value;
+        return (row) => {
+            const raw = row[field];
+            if (typeof raw !== "string")
+                return false;
+            const value = Date.parse(raw);
+            if (Number.isNaN(value))
+                return false;
+            switch (name) {
+                case "T_BEFORE":
+                    return value < bound.start;
+                case "T_AFTER":
+                    return value > bound.end;
+                case "T_DURING":
+                    return value >= bound.start && value <= bound.end;
+                default:
+                    return value >= bound.start && value <= bound.end;
+            }
+        };
+    }
+    parseTemporalOperand() {
+        const token = this.next();
+        if (token.kind !== "ident") {
+            throw new Cql2UnsupportedError(`expected a temporal literal, found ${JSON.stringify(token.value)}`);
+        }
+        const name = token.value.toUpperCase();
+        this.expect("symbol", "(");
+        if (name === "INTERVAL") {
+            const start = this.next();
+            this.expect("symbol", ",");
+            const end = this.next();
+            this.expect("symbol", ")");
+            return { start: Date.parse(start.value), end: Date.parse(end.value) };
+        }
+        if (name === "DATE" || name === "TIMESTAMP") {
+            const instant = this.next();
+            this.expect("symbol", ")");
+            const parsed = Date.parse(instant.value);
+            return { start: parsed, end: parsed };
+        }
+        throw new Cql2UnsupportedError(`unsupported temporal literal "${name}"`);
+    }
+    /** `CASEI(x)` wraps either a property reference or a literal. */
+    parseOperand() {
+        if (this.accept("keyword", "CASEI")) {
+            this.expect("symbol", "(");
+            const inner = this.parseOperand();
+            this.expect("symbol", ")");
+            return { ...inner, caseInsensitive: true };
+        }
+        const token = this.next();
+        if (token.kind === "ident") {
+            // Temporal literals arrive as DATE('…') / TIMESTAMP('…').
+            if ((token.value === "DATE" || token.value === "TIMESTAMP") && this.accept("symbol", "(")) {
+                const literal = this.next();
+                this.expect("symbol", ")");
+                return { literal: literal.value, caseInsensitive: false };
+            }
+            return { property: token.value, caseInsensitive: false };
+        }
+        if (token.kind === "string")
+            return { literal: token.value, caseInsensitive: false };
+        if (token.kind === "number")
+            return { literal: Number(token.value), caseInsensitive: false };
+        if (token.kind === "keyword" && (token.value === "TRUE" || token.value === "FALSE")) {
+            return { literal: token.value === "TRUE", caseInsensitive: false };
+        }
+        if (token.kind === "keyword" && token.value === "NULL")
+            return { literal: null, caseInsensitive: false };
+        throw new Cql2UnsupportedError(`unsupported operand ${JSON.stringify(token.value)}`);
+    }
+    parsePredicate() {
+        const left = this.parseOperand();
+        const read = (row) => (left.property !== undefined ? row[left.property] : left.literal);
+        if (this.accept("keyword", "IS")) {
+            const negated = this.accept("keyword", "NOT");
+            this.expect("keyword", "NULL");
+            return (row) => {
+                const value = read(row);
+                const isNull = value === null || value === undefined;
+                return negated ? !isNull : isNull;
+            };
+        }
+        if (this.accept("keyword", "IN")) {
+            this.expect("symbol", "(");
+            const values = [];
+            do {
+                values.push(this.parseOperand().literal);
+            } while (this.accept("symbol", ","));
+            this.expect("symbol", ")");
+            return (row) => values.some((candidate) => looseEquals(read(row), candidate));
+        }
+        if (this.accept("keyword", "BETWEEN")) {
+            const lower = this.parseOperand().literal;
+            this.expect("keyword", "AND");
+            const upper = this.parseOperand().literal;
+            return (row) => {
+                const value = read(row);
+                return compare(value, lower) >= 0 && compare(value, upper) <= 0;
+            };
+        }
+        if (this.accept("keyword", "LIKE")) {
+            const right = this.parseOperand();
+            const caseInsensitive = left.caseInsensitive || right.caseInsensitive;
+            const pattern = likeToRegExp(String(right.literal ?? ""), caseInsensitive);
+            return (row) => {
+                const value = read(row);
+                return value !== null && value !== undefined && pattern.test(String(value));
+            };
+        }
+        const operatorToken = this.next();
+        if (operatorToken.kind !== "symbol") {
+            throw new Cql2UnsupportedError(`expected a comparison operator, found ${JSON.stringify(operatorToken.value)}`);
+        }
+        const right = this.parseOperand();
+        const rightValue = (row) => (right.property !== undefined ? row[right.property] : right.literal);
+        const operator = operatorToken.value;
+        return (row) => {
+            const a = read(row);
+            const b = rightValue(row);
+            if (a === null || a === undefined || b === null || b === undefined) {
+                return operator === "<>" ? a !== b : false;
+            }
+            switch (operator) {
+                case "=":
+                    return looseEquals(a, b);
+                case "<>":
+                    return !looseEquals(a, b);
+                case "<":
+                    return compare(a, b) < 0;
+                case "<=":
+                    return compare(a, b) <= 0;
+                case ">":
+                    return compare(a, b) > 0;
+                case ">=":
+                    return compare(a, b) >= 0;
+                default:
+                    throw new Cql2UnsupportedError(`unsupported operator "${operator}"`);
+            }
+        };
+    }
+}
+function looseEquals(a, b) {
+    if (typeof a === "number" || typeof b === "number")
+        return Number(a) === Number(b);
+    return String(a) === String(b);
+}
+function compare(a, b) {
+    if (typeof a === "number" && typeof b === "number")
+        return a === b ? 0 : a < b ? -1 : 1;
+    const as = String(a);
+    const bs = String(b);
+    return as === bs ? 0 : as < bs ? -1 : 1;
+}
+function likeToRegExp(pattern, caseInsensitive) {
+    const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const translated = escaped.replace(/%/g, "[\\s\\S]*").replace(/_/g, "[\\s\\S]");
+    return new RegExp(`^${translated}$`, caseInsensitive ? "i" : "");
+}
+/** Compile a CQL2-text expression into a row predicate. */
+export function compileCql2(filter) {
+    return new Parser(tokenize(filter)).parse();
+}

package/dist/src/certification/fixtures.d.ts

@@ -12,6 +12,14 @@ export interface RoundTripEnv {
     layerId: number;
     address: string;
     styleId: string | undefined;
+    /**
+     * Protocol-neutral source reference the source-addressed tools round-trip
+     * against (#1005). Defaults to the GeoServices pair so existing targets are
+     * unchanged; the non-GeoServices lane overrides it with an OGC collection.
+     */
+    sourceRef?: string;
+    /** Numeric field on `sourceRef` usable for an aggregate round trip. */
+    statisticField?: string;
 }
 /** Resolve round-trip identifiers from the environment, with safe fallbacks. */
 export declare function resolveRoundTripEnv(env?: NodeJS.ProcessEnv): RoundTripEnv;

package/dist/src/certification/fixtures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../../src/certification/fixtures.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;CAC7B;AAED,gFAAgF;AAChF,wBAAgB,mBAAmB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,YAAY,CAQtF;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAsC/F;AAED,uEAAuE;AACvE,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,UAAU,CAOlF;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAMhF"}
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../../src/certification/fixtures.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,gFAAgF;AAChF,wBAAgB,mBAAmB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,YAAY,CAiBtF;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CA6C/F;AAED,uEAAuE;AACvE,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,UAAU,CAOlF;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAMhF"}

package/dist/src/certification/fixtures.js

@@ -15,7 +15,16 @@ export function resolveRoundTripEnv(env = process.env) {
     const layerId = Number.isFinite(parsedLayer) && parsedLayer >= 0 ? parsedLayer : 0;
     const address = env.HONUA_MCP_ADDRESS ?? "1600 Pennsylvania Ave NW, Washington DC";
     const styleId = env.HONUA_MCP_STYLE_ID ?? env.HONUA_STYLE_ID;
-    return { serviceId, layerId, address, styleId };
+    const sourceRef = env.HONUA_MCP_SOURCE;
+    const statisticField = env.HONUA_MCP_STATISTIC_FIELD;
+    return {
+        serviceId,
+        layerId,
+        address,
+        styleId,
+        ...(sourceRef ? { sourceRef } : {}),
+        ...(statisticField ? { statisticField } : {}),
+    };
 }
 /**
  * Build the read-only round-trip argument map keyed by advertised tool name.
@@ -25,23 +34,30 @@ export function resolveRoundTripEnv(env = process.env) {
  */
 export function buildRoundTripInputs(env) {
     const { serviceId, layerId, address } = env;
+    // Source-addressed tools round-trip through the protocol-neutral reference
+    // when the target provides one (#1005), and otherwise through the deprecated
+    // GeoServices pair — so both addressing modes stay certified.
+    const target = env.sourceRef ? { source: env.sourceRef } : { serviceId, layerId };
+    const statisticField = env.statisticField ?? "OBJECTID";
     return {
-        // ── Platform-free standalone surface tools (issue #369). Round-tripped by the
-        // `standalone` cert target against a plain public FeatureServer fixture. The
-        // Honua-only style tools resolve to a structured "not available on this
-        // target" result (non-error) — certifying graceful degradation, not a crash.
+        // ── Platform-free standalone surface tools (issues #369, #1005). Round-tripped
+        // by the `standalone` (Esri FeatureServer) and `standalone-ogc` (OGC API
+        // Features) cert targets. The Honua-only style tools resolve to a structured
+        // "not available on this target" result (non-error) — certifying graceful
+        // degradation, not a crash.
+        honua_list_sources: {},
         honua_list_services: {},
-        honua_describe_layer: { serviceId, layerId },
-        honua_count_features: { serviceId, layerId },
-        honua_get_extent: { serviceId, layerId },
-        honua_statistics: { serviceId, layerId, statisticType: "count", onField: "OBJECTID" },
+        honua_describe_layer: { ...target },
+        honua_count_features: { ...target },
+        honua_get_extent: { ...target },
+        honua_statistics: { ...target, statisticType: "count", onField: statisticField },
         honua_explain_capability_gap: { capability: "query", protocol: "wmts" },
         honua_get_style: {},
         honua_apply_style_preset: { styleId: "topographic" },
         // ── Honua-enhanced operator catalog tools (offline/remote/stdio-proxy targets).
         honua_list_layers: {},
         honua_list_capabilities: {},
-        honua_query_features: { serviceId, layerId, limit: 1 },
+        honua_query_features: { ...target, limit: 1 },
         honua_render_map: { layers: [{ serviceId, layerId }], bbox: [-77.1, 38.8, -76.9, 39.0] },
         honua_geocode_address: { address },
         honua_solve_route: {

package/dist/src/certification/ogc-data.d.ts

@@ -0,0 +1,30 @@
+/** A recorded OGC API Features collection: metadata, queryables, and every item. */
+export interface OgcFixtureCollection {
+    readonly collection: {
+        readonly id: string;
+        readonly title: string | null;
+        readonly description: string | null;
+        readonly extent: unknown;
+        readonly crs: readonly string[] | null;
+        readonly itemType: string;
+    };
+    readonly queryables: Record<string, {
+        type?: string;
+        title?: string;
+        [key: string]: unknown;
+    }> | null;
+    readonly features: ReadonlyArray<{
+        readonly type: "Feature";
+        readonly id?: string | number;
+        readonly geometry: Record<string, unknown> | null;
+        readonly properties: Record<string, unknown> | null;
+    }>;
+    readonly numberMatched: number;
+}
+/** The public OGC API Features endpoint these fixtures were recorded from. */
+export declare const OGC_ENDPOINT = "https://demo.pygeoapi.io/master";
+/** Recorded collections, keyed by collection id. */
+export declare const OGC_COLLECTIONS: Readonly<Record<string, OgcFixtureCollection>>;
+/** Collection ids in advertised order. */
+export declare const OGC_COLLECTION_IDS: readonly string[];
+//# sourceMappingURL=ogc-data.d.ts.map

package/dist/src/certification/ogc-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ogc-data.d.ts","sourceRoot":"","sources":["../../../src/certification/ogc-data.ts"],"names":[],"mappings":"AAeA,oFAAoF;AACpF,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,UAAU,EAAE;QACnB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;QAC9B,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;QACpC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;QACzB,QAAQ,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;QACvC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;KAC3B,CAAC;IACF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC,GAAG,IAAI,CAAC;IACtG,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;QAC/B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;QACzB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;QAClD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;KACrD,CAAC,CAAC;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED,8EAA8E;AAC9E,eAAO,MAAM,YAAY,oCAAoC,CAAC;AAE9D,oDAAoD;AACpD,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAmsBjE,CAAC;AAEX,0CAA0C;AAC1C,eAAO,MAAM,kBAAkB,EAAE,SAAS,MAAM,EAAmC,CAAC"}