@honua/sdk-esri-compat 0.1.12 → 0.1.14

package/query-planner/odata-protocol-module.js

@@ -0,0 +1,199 @@
+import { PROTOCOL_DEFAULT_CAPABILITIES } from "../contract/types.js";
+import { HonuaCapabilityNotSupportedError } from "../core/errors.js";
+import { HonuaOdataEntitySet } from "../core/odata.js";
+import { trimTrailingSlashes } from "../core/path-utils.js";
+import { bindOdataProtocolQueryOperation, odataProtocolQueryCompiler } from "./odata-v1.js";
+/**
+ * Project already-negotiated OData query params onto the credential-free
+ * deterministic artifact consumed by the module executor.
+ *
+ * `count` and `signal` are intentionally omitted: count is runtime response
+ * metadata policy, and cancellation can never participate in request identity.
+ */
+export function createOdataProtocolCompiledQuery(entitySet, operation, params) {
+    const request = Object.freeze({
+        compiler: "odata-v4-query-v1",
+        entitySet,
+        ...(params.filter !== undefined ? { filter: params.filter } : {}),
+        ...(params.select !== undefined ? { select: Object.freeze([...params.select]) } : {}),
+        ...(params.expand !== undefined ? { expand: Object.freeze([...params.expand]) } : {}),
+        ...(params.orderBy !== undefined ? { orderBy: Object.freeze([...params.orderBy]) } : {}),
+        ...(params.skip !== undefined ? { skip: params.skip } : {}),
+        ...(params.top !== undefined ? { top: params.top } : {}),
+    });
+    return bindOdataProtocolQueryOperation(request, operation);
+}
+/**
+ * Construct the first-party query-capable OData protocol module.
+ *
+ * Discovery is synchronous and performs no I/O. `$metadata` remains lazy on
+ * the returned `HonuaOdataEntitySet`, exactly as it was before the migration.
+ * The client stays in this module instance's closure; there is no global
+ * protocol registry or ambient authority.
+ */
+export function odataProtocolModule(client) {
+    return Object.freeze({
+        kind: "odata",
+        environments: Object.freeze(["browser", "node", "worker"]),
+        capabilities(descriptor) {
+            return descriptor.capabilities ?? PROTOCOL_DEFAULT_CAPABILITIES.odata;
+        },
+        discover(descriptor) {
+            const { entitySet, basePath } = requireOdataLocator(descriptor);
+            const adapter = new HonuaOdataEntitySet({ client, entitySet, basePath });
+            return Object.freeze({
+                descriptor,
+                capabilities: descriptor.capabilities ?? PROTOCOL_DEFAULT_CAPABILITIES.odata,
+                adapter,
+                diagnostics: Object.freeze([]),
+                dispose() {
+                    // HonuaOdataEntitySet retains only settled/in-flight promises and
+                    // opens no persistent handles. Disposal is deterministic and
+                    // synchronous with nothing to release.
+                },
+            });
+        },
+        compile: odataProtocolQueryCompiler.compile,
+        async execute(handle, input) {
+            assertExecutableOdataArtifact(handle.adapter, input.compiled, input.operation);
+            const logicalLimit = input.operation === "queryAll"
+                ? resolveOdataQueryAllLogicalLimit(input.compiled, input.query.limit)
+                : undefined;
+            const params = odataParamsFromCompiled(input.compiled, input.query.count, input.signal);
+            switch (input.operation) {
+                case "query": {
+                    const page = await handle.adapter.query(params);
+                    return odataProtocolResultFromPage(handle.descriptor, page, input.query.fields, input.query.returnGeometry, input.query.geometryColumn);
+                }
+                case "queryAll": {
+                    const drained = await handle.adapter.queryAll(params);
+                    const allFeatures = drained.rows.map((row) => odataRowToFeature(row, handle.descriptor, input.query.returnGeometry, input.query.geometryColumn));
+                    const { features, exceededTransferLimit: collectedExceeded } = applyLimit(allFeatures, logicalLimit);
+                    const countExceeded = typeof drained.totalCount === "number" &&
+                        typeof logicalLimit === "number" &&
+                        drained.totalCount > features.length;
+                    return {
+                        features,
+                        exceededTransferLimit: collectedExceeded || countExceeded,
+                        ...(typeof drained.totalCount === "number"
+                            ? { totalCount: drained.totalCount }
+                            : { totalCount: features.length }),
+                        ...(input.query.fields.length > 0 ? { fields: input.query.fields } : {}),
+                    };
+                }
+                case "queryAggregate":
+                    throw new HonuaCapabilityNotSupportedError("queryAggregate", handle.descriptor.protocol, handle.descriptor.id);
+            }
+        },
+    });
+}
+function requireOdataLocator(descriptor) {
+    const { entitySet, url, layerId } = descriptor.locator;
+    let resolvedEntitySet;
+    if (typeof entitySet === "string" && entitySet !== "") {
+        resolvedEntitySet = entitySet;
+    }
+    else if (typeof layerId === "number" && Number.isFinite(layerId)) {
+        resolvedEntitySet = `Layers(${layerId})/Features`;
+    }
+    if (resolvedEntitySet === undefined) {
+        throw new Error(`createDataset: source "${descriptor.id}" (odata) requires locator.entitySet or locator.layerId`);
+    }
+    const basePath = url ? extractOdataBasePath(url) : "/odata";
+    return { entitySet: resolvedEntitySet, basePath };
+}
+function extractOdataBasePath(url) {
+    try {
+        const parsed = new URL(url);
+        const pathname = trimTrailingSlashes(parsed.pathname);
+        return pathname === "" ? "/odata" : pathname;
+    }
+    catch {
+        return url.startsWith("/") ? trimTrailingSlashes(url) || "/odata" : `/${trimTrailingSlashes(url)}`;
+    }
+}
+function assertExecutableOdataArtifact(adapter, compiled, operation) {
+    if (compiled.compiler !== "odata-v4-protocol-query-v1") {
+        throw new TypeError("odata: protocol module requires an odata-v4-protocol-query-v1 artifact");
+    }
+    if (compiled.entitySet !== adapter.entitySet) {
+        throw new TypeError("odata: compiled entitySet does not match the discovered protocol handle");
+    }
+    if (compiled.operation !== operation) {
+        throw new TypeError("odata: compiled operation does not match the requested protocol operation");
+    }
+}
+/**
+ * Recover the caller-visible queryAll ceiling from the compiler-owned
+ * lookahead row and reject any runtime context that does not describe the
+ * same bounded request. This runs before the adapter performs I/O.
+ */
+function resolveOdataQueryAllLogicalLimit(compiled, requestedLimit) {
+    if (requestedLimit !== undefined && (!Number.isSafeInteger(requestedLimit) || requestedLimit < 0)) {
+        throw new TypeError("odata: queryAll logical limit must be a non-negative safe integer");
+    }
+    if (compiled.top === undefined) {
+        if (requestedLimit !== undefined) {
+            throw new TypeError("odata: queryAll compiled top does not match the logical limit");
+        }
+        return undefined;
+    }
+    if (!Number.isSafeInteger(compiled.top) || compiled.top < 1) {
+        throw new TypeError("odata: queryAll compiled top must contain one lookahead row");
+    }
+    const compiledLogicalLimit = compiled.top - 1;
+    if (requestedLimit !== undefined && requestedLimit !== compiledLogicalLimit) {
+        throw new TypeError("odata: queryAll compiled top does not match the logical limit");
+    }
+    return requestedLimit ?? compiledLogicalLimit;
+}
+function odataParamsFromCompiled(compiled, count, signal) {
+    return {
+        ...(compiled.filter !== undefined ? { filter: compiled.filter } : {}),
+        ...(compiled.select !== undefined ? { select: compiled.select } : {}),
+        ...(compiled.expand !== undefined ? { expand: compiled.expand } : {}),
+        ...(compiled.orderBy !== undefined ? { orderBy: compiled.orderBy } : {}),
+        ...(compiled.skip !== undefined ? { skip: compiled.skip } : {}),
+        ...(compiled.top !== undefined ? { top: compiled.top } : {}),
+        ...(count ? { count: true } : {}),
+        ...(signal ? { signal } : {}),
+    };
+}
+/** Internal shared result projection used by query execution and OData streaming. */
+export function odataProtocolResultFromPage(descriptor, page, fields, returnGeometry, geometryColumn) {
+    const features = page.rows.map((row) => odataRowToFeature(row, descriptor, returnGeometry, geometryColumn));
+    const exceededTransferLimit = typeof page.totalCount === "number" ? features.length < page.totalCount : Boolean(page.nextLink);
+    return {
+        features,
+        exceededTransferLimit,
+        ...(typeof page.totalCount === "number" ? { totalCount: page.totalCount } : {}),
+        ...(fields.length > 0 ? { fields } : {}),
+    };
+}
+function odataRowToFeature(row, descriptor, returnGeometry, geometryColumn) {
+    const geometryKey = geometryColumn ??
+        descriptor.schema?.fields?.find((field) => field.type === "esriFieldTypeGeometry")?.name ??
+        findGeometryKey(row);
+    if (geometryKey && row[geometryKey] !== undefined) {
+        const { [geometryKey]: geometry, ...attributes } = row;
+        return {
+            attributes: attributes,
+            geometry: returnGeometry === false ? null : (geometry ?? null),
+        };
+    }
+    return { attributes: row, geometry: null };
+}
+function findGeometryKey(row) {
+    for (const key of Object.keys(row)) {
+        const lower = key.toLowerCase();
+        if (lower === "geometry" || lower === "geography" || lower === "shape")
+            return key;
+    }
+    return undefined;
+}
+function applyLimit(features, limit) {
+    if (typeof limit !== "number" || limit < 0 || features.length <= limit) {
+        return { features, exceededTransferLimit: false };
+    }
+    return { features: features.slice(0, limit), exceededTransferLimit: true };
+}

package/query-planner/odata-v1.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Lightweight deterministic OData v4 compiler.
+ *
+ * Kept separate from the semantic OData compiler so importing the public
+ * `odataProtocolModule()` does not pull the larger semantic compiler graph
+ * into contract-only bundles.
+ */
+import type { ProtocolModuleQueryCompileInput, ProtocolModuleQueryOperation } from "../contract/protocol-module.js";
+import type { CanonicalQuery, OdataCompiledQueryV1, OdataProtocolCompiledQueryV1, QueryIrSourceIdentity } from "./types.js";
+/** Compile canonical query IR to a deterministic OData v4 entity-set request. */
+export declare function compileOdataQuery(source: QueryIrSourceIdentity, query: CanonicalQuery): OdataCompiledQueryV1;
+/**
+ * The deterministic compiler hook installed on the first-party OData
+ * ProtocolModule. Planner dispatch and module consumers call this exact
+ * object, while runtime authority remains outside the compiler.
+ */
+export declare const odataProtocolQueryCompiler: Readonly<{
+    kind: "odata";
+    compile(input: ProtocolModuleQueryCompileInput<QueryIrSourceIdentity, CanonicalQuery>): OdataProtocolCompiledQueryV1;
+}>;
+/** Bind a legacy wire request to the exact operation authorized to execute it. */
+export declare function bindOdataProtocolQueryOperation(compiled: OdataCompiledQueryV1, operation: ProtocolModuleQueryOperation): OdataProtocolCompiledQueryV1;
+//# sourceMappingURL=odata-v1.d.ts.map

package/query-planner/odata-v1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"odata-v1.d.ts","sourceRoot":"","sources":["../../../src/query-planner/odata-v1.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,+BAA+B,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAIpH,OAAO,KAAK,EACV,cAAc,EACd,oBAAoB,EACpB,4BAA4B,EAC5B,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAGpB,iFAAiF;AACjF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,qBAAqB,EAAE,KAAK,EAAE,cAAc,GAAG,oBAAoB,CAqH5G;AAED;;;;GAIG;AACH,eAAO,MAAM,0BAA0B;;mBAEtB,+BAA+B,CAAC,qBAAqB,EAAE,cAAc,CAAC,GAAG,4BAA4B;EAGpH,CAAC;AAEH,kFAAkF;AAClF,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,oBAAoB,EAC9B,SAAS,EAAE,4BAA4B,GACtC,4BAA4B,CAsB9B"}

package/query-planner/odata-v1.js

@@ -0,0 +1,202 @@
+import { compileQueryFilterToOData } from "../contract/query-filter.js";
+import { buildOdataSpatialFilter, rewriteWhereToOdataFilter } from "../core/odata.js";
+import { canonicalFilterParts, refuseCanonicalFilter } from "./canonical-filter.js";
+import { HonuaQueryPlanningError } from "./types.js";
+/** Compile canonical query IR to a deterministic OData v4 entity-set request. */
+export function compileOdataQuery(source, query) {
+    if (source.protocol !== "odata") {
+        throw new HonuaQueryPlanningError("unsupported-compiler", `odata-v4-query-v1 does not compile protocol "${source.protocol}"`);
+    }
+    if (!source.entitySet) {
+        throw new HonuaQueryPlanningError("invalid-query", `Source "${source.id}" requires locator.entitySet for OData planning`);
+    }
+    if (query.aggregation) {
+        throw new HonuaQueryPlanningError("unsupported-query", "Canonical OData aggregation is not portable; use the typed $apply escape hatch");
+    }
+    if (query.outSr !== undefined) {
+        throw new HonuaQueryPlanningError("unsupported-query", "OData v4 has no portable output-CRS query option; omit outSr or use the typed OData escape hatch");
+    }
+    const ctx = {
+        protocol: source.protocol,
+        sourceId: source.id,
+        ...(source.geometryProperty !== undefined ? { geometryProperty: source.geometryProperty } : {}),
+    };
+    const parts = canonicalFilterParts(query, ctx);
+    if (parts.protocolTime) {
+        refuseCanonicalFilter("Query.temporalFilter without a field", "OData v4", "the protocol has no time parameter; name the temporal field so the predicate stays exact");
+    }
+    const filterParts = [];
+    try {
+        if (query.where) {
+            assertSupportedWhere(query.where.expression);
+            const rewritten = rewriteWhereToOdataFilter(query.where.expression);
+            if (rewritten)
+                filterParts.push(rewritten);
+        }
+        if (parts.expression) {
+            filterParts.push(compileQueryFilterToOData(parts.expression, ctx, (node) => {
+                if (!source.geometryProperty) {
+                    throw new Error("descriptor schema does not identify the OData geometry column");
+                }
+                if (node.operator !== "intersects" && node.operator !== "bbox-intersects") {
+                    throw new Error(`OData v4 has no standard ${node.operator} geo function`);
+                }
+                return buildOdataSpatialFilter({
+                    geometry: node.geometry.geometry,
+                    geometryType: node.geometry.geometryType,
+                    spatialRel: "esriSpatialRelIntersects",
+                }, { geometryColumn: source.geometryProperty });
+            }));
+        }
+        if (query.spatialFilter) {
+            if (!source.geometryProperty) {
+                throw new Error("descriptor schema does not identify the OData geometry column");
+            }
+            filterParts.push(buildOdataSpatialFilter({
+                geometry: query.spatialFilter.geometry,
+                geometryType: query.spatialFilter.geometryType,
+                ...(query.spatialFilter.spatialRel ? { spatialRel: query.spatialFilter.spatialRel } : {}),
+            }, { geometryColumn: source.geometryProperty }));
+        }
+    }
+    catch (error) {
+        throw new HonuaQueryPlanningError("unsupported-query", `OData query cannot preserve the requested predicate: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let projection;
+    if (query.outFields && query.outFields.length > 0) {
+        projection = splitProjection(query.outFields, query.returnGeometry === false ? source.geometryProperty : undefined);
+        if (query.returnGeometry !== false &&
+            source.geometryProperty &&
+            !projection.select.includes(source.geometryProperty)) {
+            projection = { ...projection, select: [...projection.select, source.geometryProperty] };
+        }
+    }
+    else if (query.returnGeometry === false) {
+        throw new HonuaQueryPlanningError("unsupported-query", "Metadata-free OData planning requires explicit outFields to prove returnGeometry=false on the wire");
+    }
+    return {
+        compiler: "odata-v4-query-v1",
+        entitySet: source.entitySet,
+        ...(filterParts.length > 0 ? { filter: filterParts.join(" and ") } : {}),
+        ...(projection && projection.select.length > 0 ? { select: projection.select } : {}),
+        ...(projection && projection.expand.length > 0 ? { expand: projection.expand } : {}),
+        ...(query.orderBy && query.orderBy.length > 0
+            ? { orderBy: query.orderBy.map((sort) => `${sort.field}${sort.direction === "desc" ? " desc" : ""}`) }
+            : {}),
+        ...(query.pagination?.offset !== undefined ? { skip: query.pagination.offset } : {}),
+        ...(query.pagination?.limit !== undefined ? { top: query.pagination.limit } : {}),
+    };
+}
+/**
+ * The deterministic compiler hook installed on the first-party OData
+ * ProtocolModule. Planner dispatch and module consumers call this exact
+ * object, while runtime authority remains outside the compiler.
+ */
+export const odataProtocolQueryCompiler = Object.freeze({
+    kind: "odata",
+    compile(input) {
+        return bindOdataProtocolQueryOperation(compileOdataQuery(input.source, input.query), input.operation);
+    },
+});
+/** Bind a legacy wire request to the exact operation authorized to execute it. */
+export function bindOdataProtocolQueryOperation(compiled, operation) {
+    let top = compiled.top;
+    if (operation === "queryAll" && top !== undefined) {
+        if (!Number.isSafeInteger(top) || top < 0 || top >= Number.MAX_SAFE_INTEGER) {
+            throw new HonuaQueryPlanningError("invalid-query", "OData queryAll pagination.limit must leave room for one lookahead row");
+        }
+        top += 1;
+    }
+    return Object.freeze({
+        compiler: "odata-v4-protocol-query-v1",
+        operation,
+        entitySet: compiled.entitySet,
+        ...(compiled.filter !== undefined ? { filter: compiled.filter } : {}),
+        ...(compiled.select !== undefined ? { select: compiled.select } : {}),
+        ...(compiled.expand !== undefined ? { expand: compiled.expand } : {}),
+        ...(compiled.orderBy !== undefined ? { orderBy: compiled.orderBy } : {}),
+        ...(compiled.skip !== undefined ? { skip: compiled.skip } : {}),
+        ...(top !== undefined ? { top } : {}),
+    });
+}
+function assertSupportedWhere(where) {
+    const code = outsideQuotedStrings(where);
+    if (code === undefined)
+        throw new Error("unterminated OData string literal");
+    const unsupported = [
+        { expression: /\bLIKE\b/i, name: "LIKE" },
+        { expression: /\bBETWEEN\b/i, name: "BETWEEN" },
+        { expression: /==/, name: "==" },
+        { expression: /!=/, name: "!=" },
+        { expression: /;/, name: ";" },
+    ];
+    for (const candidate of unsupported) {
+        if (candidate.expression.test(code)) {
+            throw new Error(`operator ${candidate.name} is not translated by the OData compiler`);
+        }
+    }
+}
+/** Return only non-literal spans, or undefined for an unterminated literal. */
+function outsideQuotedStrings(input) {
+    let output = "";
+    let quoted = false;
+    for (let index = 0; index < input.length; index += 1) {
+        const character = input[index];
+        if (character !== "'") {
+            if (!quoted)
+                output += character;
+            continue;
+        }
+        if (quoted && input[index + 1] === "'") {
+            index += 1;
+            continue;
+        }
+        quoted = !quoted;
+    }
+    return quoted ? undefined : output;
+}
+function splitProjection(fields, excludedGeometry) {
+    const root = { select: [], children: new Map() };
+    for (const field of fields) {
+        if (excludedGeometry && field === excludedGeometry)
+            continue;
+        const segments = field.split(".").filter(Boolean);
+        if (segments.length === 0)
+            continue;
+        let cursor = root;
+        for (let index = 0; index < segments.length - 1; index += 1) {
+            const segment = segments[index];
+            if (!segment)
+                continue;
+            let child = cursor.children.get(segment);
+            if (!child) {
+                child = { select: [], children: new Map() };
+                cursor.children.set(segment, child);
+            }
+            cursor = child;
+        }
+        const leaf = segments.at(-1);
+        if (leaf)
+            cursor.select.push(leaf);
+    }
+    const serialize = (node) => {
+        const parts = [];
+        if (node.select.length > 0)
+            parts.push(`$select=${node.select.join(",")}`);
+        if (node.children.size > 0) {
+            const children = [...node.children.entries()].map(([name, child]) => {
+                const inner = serialize(child);
+                return inner ? `${name}(${inner})` : name;
+            });
+            parts.push(`$expand=${children.join(",")}`);
+        }
+        return parts.join(";");
+    };
+    return {
+        select: root.select,
+        expand: [...root.children.entries()].map(([name, child]) => {
+            const inner = serialize(child);
+            return inner ? `${name}(${inner})` : name;
+        }),
+    };
+}

package/query-planner/odata.d.ts

@@ -0,0 +1,45 @@
+import type { ExecutableCrsBinding, SourceSchemaV2 } from "../contract/schema.js";
+import { type SemanticCompilationResult } from "./semantic-compiler.js";
+import { type SemanticCompilerFieldMapping } from "./semantic-literals.js";
+import type { SemanticQuery, SourceSpatiality } from "./semantic-types.js";
+export type SemanticOdataSpatialFunction = "geo.intersects" | "geo.distance";
+/** Static, credential-free OData endpoint evidence used by the semantic compiler. */
+export interface SemanticOdataSourceIdentity {
+    readonly entitySet: string;
+    readonly sourceVersion?: string;
+    /** Spatial functions explicitly advertised or certified for this service. */
+    readonly supportedSpatialFunctions?: readonly SemanticOdataSpatialFunction[];
+}
+export interface SemanticOdataCompileOptions<TRecord = Record<string, unknown>, TSpatiality extends SourceSpatiality = SourceSpatiality> {
+    readonly query: SemanticQuery<TRecord, "odata", TSpatiality>;
+    readonly schema: SourceSchemaV2;
+    readonly source: SemanticOdataSourceIdentity;
+}
+export interface SemanticOdataOutputGeometry {
+    readonly field: string;
+    readonly propertyPath: string;
+    readonly spatialType: "geography" | "geometry";
+    readonly crs: ExecutableCrsBinding;
+    readonly layout: "xy";
+}
+/** Canonical pre-image of an OData v4 entity-set request. */
+export interface SemanticOdataCompiledQueryV1 {
+    readonly compiler: "odata-v4-semantic-query-v1";
+    readonly dialect: "odata-4.0";
+    readonly schemaFingerprint: SourceSchemaV2["fingerprint"];
+    readonly queryFingerprint: `sha256:${string}`;
+    readonly requestFingerprint: `sha256:${string}`;
+    readonly entitySet: string;
+    readonly sourceVersion?: string;
+    readonly filter?: string;
+    readonly select: readonly string[];
+    readonly orderBy?: readonly string[];
+    readonly skip?: number;
+    readonly top?: number;
+    readonly outputGeometry?: SemanticOdataOutputGeometry;
+    readonly fieldMappings: readonly SemanticCompilerFieldMapping[];
+    readonly usesNativeFilter: boolean;
+}
+/** Compile a validated semantic AST to exact OData v4 system query options. */
+export declare function compileSemanticOdataQuery<TRecord, TSpatiality extends SourceSpatiality>(options: SemanticOdataCompileOptions<TRecord, TSpatiality>): SemanticCompilationResult<SemanticOdataCompiledQueryV1>;
+//# sourceMappingURL=odata.d.ts.map

package/query-planner/odata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"odata.d.ts","sourceRoot":"","sources":["../../../src/query-planner/odata.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGV,oBAAoB,EAOpB,cAAc,EACf,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAEL,KAAK,yBAAyB,EAO/B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,KAAK,4BAA4B,EAWlC,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAe,aAAa,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAGxF,MAAM,MAAM,4BAA4B,GAAG,gBAAgB,GAAG,cAAc,CAAC;AAE7E,qFAAqF;AACrF,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,6EAA6E;IAC7E,QAAQ,CAAC,yBAAyB,CAAC,EAAE,SAAS,4BAA4B,EAAE,CAAC;CAC9E;AAED,MAAM,WAAW,2BAA2B,CAC1C,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,WAAW,SAAS,gBAAgB,GAAG,gBAAgB;IAEvD,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC;IAC7D,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,2BAA2B,CAAC;CAC9C;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,WAAW,EAAE,WAAW,GAAG,UAAU,CAAC;IAC/C,QAAQ,CAAC,GAAG,EAAE,oBAAoB,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;CACvB;AAED,6DAA6D;AAC7D,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,QAAQ,EAAE,4BAA4B,CAAC;IAChD,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,iBAAiB,EAAE,cAAc,CAAC,aAAa,CAAC,CAAC;IAC1D,QAAQ,CAAC,gBAAgB,EAAE,UAAU,MAAM,EAAE,CAAC;IAC9C,QAAQ,CAAC,kBAAkB,EAAE,UAAU,MAAM,EAAE,CAAC;IAChD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,cAAc,CAAC,EAAE,2BAA2B,CAAC;IACtD,QAAQ,CAAC,aAAa,EAAE,SAAS,4BAA4B,EAAE,CAAC;IAChE,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;CACpC;AA0BD,+EAA+E;AAC/E,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,WAAW,SAAS,gBAAgB,EACrF,OAAO,EAAE,2BAA2B,CAAC,OAAO,EAAE,WAAW,CAAC,GACzD,yBAAyB,CAAC,4BAA4B,CAAC,CA4CzD"}