@qlever-llc/trellis 0.7.0-rc.5 → 0.7.0

package/esm/contracts/mod.js

@@ -1,558 +0,0 @@
-import { canonicalizeJson, digestJson, isJsonValue, sha256Base64urlSync, } from "./canonical.js";
-import { schema, unwrapSchema, } from "./runtime.js";
-import { assertDataPointersExistAndAreTokenable, } from "./schema_pointers.js";
-export { ContractJobQueueResourceSchema, ContractJobsResourceSchema, ContractKvResourceSchema, ContractResourceBindingsSchema, ContractResourcesSchema, ContractSchemaRefSchema, ContractStoreResourceSchema, ContractStreamResourceSchema, EventHeaderSchema, InstalledServiceContractSchema, IsoDateSchema, JobsQueueBindingSchema, JobsResourceBindingSchema, KvResourceBindingSchema, StoreResourceBindingSchema, PaginatedSchema, StreamResourceBindingSchema, } from "./protocol.js";
-export const CONTRACT_FORMAT_V1 = "trellis.contract.v1";
-export const CATALOG_FORMAT_V1 = "trellis.catalog.v1";
-const CONTRACT_MODULE_METADATA = Symbol.for("@qlever-llc/trellis-contracts/contract-module");
-function cloneSchema(schemaValue) {
-    const cloned = JSON.parse(JSON.stringify(schemaValue));
-    if (!isJsonValue(cloned)) {
-        throw new Error("Contract schema is not JSON-serializable");
-    }
-    return cloned;
-}
-function cloneSchemas(schemas) {
-    if (!schemas) {
-        return undefined;
-    }
-    return Object.fromEntries(Object.entries(schemas).map(([name, schemaValue]) => [name, cloneSchema(schemaValue)]));
-}
-function assertSchemaRefExists(schemas, ref, context) {
-    if (!schemas || !Object.hasOwn(schemas, ref.schema)) {
-        throw new Error(`${context} references unknown schema '${ref.schema}'`);
-    }
-}
-function resolveSchemaRef(schemas, ref, context) {
-    assertSchemaRefExists(schemas, ref, context);
-    return cloneSchema(schemas[ref.schema]);
-}
-function digestCanonicalJson(value) {
-    return sha256Base64urlSync(canonicalizeJson(value));
-}
-function rpcSubject(name, version) {
-    return `rpc.${version}.${name}`;
-}
-function operationSubject(name, version) {
-    return `operations.${version}.${name}`;
-}
-function eventSubject(name, version, params) {
-    const suffix = params && params.length > 0
-        ? `.${params.map((pointer) => `{${pointer}}`).join(".")}`
-        : "";
-    return `events.${version}.${name}${suffix}`;
-}
-function emitResources(resources) {
-    if (!resources?.kv && !resources?.store && !resources?.streams && !resources?.jobs) {
-        return undefined;
-    }
-    return {
-        ...(resources.kv
-            ? {
-                kv: Object.fromEntries(Object.entries(resources.kv).map(([alias, resource]) => [
-                    alias,
-                    {
-                        purpose: resource.purpose,
-                        required: resource.required ?? true,
-                        history: resource.history ?? 1,
-                        ttlMs: resource.ttlMs ?? 0,
-                        ...(resource.maxValueBytes
-                            ? { maxValueBytes: resource.maxValueBytes }
-                            : {}),
-                    },
-                ])),
-            }
-            : {}),
-        ...(resources.store
-            ? {
-                store: Object.fromEntries(Object.entries(resources.store).map(([alias, resource]) => [
-                    alias,
-                    {
-                        purpose: resource.purpose,
-                        required: resource.required ?? true,
-                        ttlMs: resource.ttlMs ?? 0,
-                        ...(resource.maxObjectBytes !== undefined
-                            ? { maxObjectBytes: resource.maxObjectBytes }
-                            : {}),
-                        ...(resource.maxTotalBytes !== undefined
-                            ? { maxTotalBytes: resource.maxTotalBytes }
-                            : {}),
-                    },
-                ])),
-            }
-            : {}),
-        ...(resources.streams
-            ? {
-                streams: Object.fromEntries(Object.entries(resources.streams).map(([alias, resource]) => [
-                    alias,
-                    {
-                        purpose: resource.purpose,
-                        required: resource.required ?? true,
-                        subjects: [...resource.subjects],
-                    },
-                ])),
-            }
-            : {}),
-        ...(resources.jobs
-            ? {
-                jobs: {
-                    queues: Object.fromEntries(Object.entries(resources.jobs.queues).map(([queueType, queue]) => [
-                        queueType,
-                        {
-                            payload: { ...queue.payload },
-                            ...(queue.result ? { result: { ...queue.result } } : {}),
-                            ...(queue.maxDeliver !== undefined
-                                ? { maxDeliver: queue.maxDeliver }
-                                : {}),
-                            ...(queue.backoffMs ? { backoffMs: [...queue.backoffMs] } : {}),
-                            ...(queue.ackWaitMs !== undefined
-                                ? { ackWaitMs: queue.ackWaitMs }
-                                : {}),
-                            ...(queue.defaultDeadlineMs !== undefined
-                                ? { defaultDeadlineMs: queue.defaultDeadlineMs }
-                                : {}),
-                            ...(queue.progress !== undefined
-                                ? { progress: queue.progress }
-                                : {}),
-                            ...(queue.logs !== undefined ? { logs: queue.logs } : {}),
-                            ...(queue.dlq !== undefined ? { dlq: queue.dlq } : {}),
-                            ...(queue.concurrency !== undefined
-                                ? { concurrency: queue.concurrency }
-                                : {}),
-                        },
-                    ])),
-                },
-            }
-            : {}),
-    };
-}
-function emitUses(uses) {
-    if (!uses) {
-        return undefined;
-    }
-    return Object.fromEntries(Object.entries(uses).map(([alias, use]) => [
-        alias,
-        {
-            contract: use.contract,
-            ...(use.rpc?.call ? { rpc: { call: [...use.rpc.call] } } : {}),
-            ...(use.operations?.call
-                ? { operations: { call: [...use.operations.call] } }
-                : {}),
-            ...((use.events?.publish || use.events?.subscribe)
-                ? {
-                    events: {
-                        ...(use.events.publish
-                            ? { publish: [...use.events.publish] }
-                            : {}),
-                        ...(use.events.subscribe
-                            ? { subscribe: [...use.events.subscribe] }
-                            : {}),
-                    },
-                }
-                : {}),
-            ...((use.subjects?.publish || use.subjects?.subscribe)
-                ? {
-                    subjects: {
-                        ...(use.subjects.publish
-                            ? { publish: [...use.subjects.publish] }
-                            : {}),
-                        ...(use.subjects.subscribe
-                            ? { subscribe: [...use.subjects.subscribe] }
-                            : {}),
-                    },
-                }
-                : {}),
-        },
-    ]));
-}
-function emitContract(source) {
-    const rpc = source.rpc
-        ? Object.fromEntries(Object.entries(source.rpc).map(([name, method]) => {
-            const emitted = {
-                version: method.version,
-                subject: method.subject ?? rpcSubject(name, method.version),
-                input: { ...method.input },
-                output: { ...method.output },
-            };
-            if (method.capabilities?.call) {
-                emitted.capabilities = { call: [...method.capabilities.call] };
-            }
-            if (method.errors && method.errors.length > 0) {
-                emitted.errors = method.errors.map((type) => ({ type }));
-            }
-            return [name, emitted];
-        }))
-        : undefined;
-    const operations = source.operations
-        ? Object.fromEntries(Object.entries(source.operations).map(([name, operation]) => {
-            const emitted = {
-                version: operation.version,
-                subject: operation.subject ??
-                    operationSubject(name, operation.version),
-                input: { ...operation.input },
-            };
-            if (operation.progress) {
-                emitted.progress = { ...operation.progress };
-            }
-            if (operation.output) {
-                emitted.output = { ...operation.output };
-            }
-            if (operation.capabilities?.call || operation.capabilities?.read ||
-                operation.capabilities?.cancel) {
-                emitted.capabilities = {
-                    ...(operation.capabilities.call
-                        ? { call: [...operation.capabilities.call] }
-                        : {}),
-                    ...(operation.capabilities.read
-                        ? { read: [...operation.capabilities.read] }
-                        : {}),
-                    ...(operation.capabilities.cancel
-                        ? { cancel: [...operation.capabilities.cancel] }
-                        : {}),
-                };
-            }
-            if (operation.cancel !== undefined) {
-                emitted.cancel = operation.cancel;
-            }
-            return [name, emitted];
-        }))
-        : undefined;
-    const events = source.events
-        ? Object.fromEntries(Object.entries(source.events).map(([name, event]) => {
-            if (event.params && event.params.length > 0) {
-                assertDataPointersExistAndAreTokenable(name, resolveSchemaRef(source.schemas, event.event, `event '${name}'`), event.params);
-            }
-            const emitted = {
-                version: event.version,
-                subject: event.subject ??
-                    eventSubject(name, event.version, event.params),
-                event: { ...event.event },
-            };
-            if (event.params && event.params.length > 0) {
-                emitted.params = [...event.params];
-            }
-            if (event.capabilities?.publish || event.capabilities?.subscribe) {
-                emitted.capabilities = {
-                    ...(event.capabilities.publish
-                        ? { publish: [...event.capabilities.publish] }
-                        : {}),
-                    ...(event.capabilities.subscribe
-                        ? { subscribe: [...event.capabilities.subscribe] }
-                        : {}),
-                };
-            }
-            return [name, emitted];
-        }))
-        : undefined;
-    const subjects = source.subjects
-        ? Object.fromEntries(Object.entries(source.subjects).map(([name, subject]) => {
-            const emitted = {
-                subject: subject.subject,
-            };
-            if (subject.message) {
-                emitted.message = { ...subject.message };
-            }
-            if (subject.capabilities?.publish || subject.capabilities?.subscribe) {
-                emitted.capabilities = {
-                    ...(subject.capabilities.publish
-                        ? { publish: [...subject.capabilities.publish] }
-                        : {}),
-                    ...(subject.capabilities.subscribe
-                        ? { subscribe: [...subject.capabilities.subscribe] }
-                        : {}),
-                };
-            }
-            return [name, emitted];
-        }))
-        : undefined;
-    const errors = source.errors
-        ? Object.fromEntries(Object.entries(source.errors).map(([name, error]) => {
-            const emitted = { type: error.type };
-            if (error.schema) {
-                emitted.schema = { ...error.schema };
-            }
-            return [name, emitted];
-        }))
-        : undefined;
-    const resources = emitResources(source.resources);
-    const uses = emitUses(source.uses);
-    return {
-        format: CONTRACT_FORMAT_V1,
-        id: source.id,
-        displayName: source.displayName,
-        description: source.description,
-        kind: source.kind,
-        ...(source.schemas ? { schemas: cloneSchemas(source.schemas) } : {}),
-        ...(uses ? { uses } : {}),
-        ...(rpc ? { rpc } : {}),
-        ...(operations ? { operations } : {}),
-        ...(events ? { events } : {}),
-        ...(subjects ? { subjects } : {}),
-        ...(errors ? { errors } : {}),
-        ...(resources ? { resources } : {}),
-    };
-}
-function buildOwnedApi(source) {
-    const rpc = Object.fromEntries(Object.entries(source.rpc ?? {}).map(([name, method]) => [
-        name,
-        {
-            subject: method.subject ?? rpcSubject(name, method.version),
-            input: schema(resolveSchemaRef(source.schemas, method.input, `rpc '${name}' input`)),
-            output: schema(resolveSchemaRef(source.schemas, method.output, `rpc '${name}' output`)),
-            callerCapabilities: method.capabilities?.call ?? [],
-            authRequired: method.authRequired ?? true,
-            errors: method.errors,
-        },
-    ]));
-    const operations = Object.fromEntries(Object.entries(source.operations ?? {}).map(([name, operation]) => [
-        name,
-        {
-            subject: operation.subject ?? operationSubject(name, operation.version),
-            input: schema(resolveSchemaRef(source.schemas, operation.input, `operation '${name}' input`)),
-            progress: operation.progress
-                ? schema(resolveSchemaRef(source.schemas, operation.progress, `operation '${name}' progress`))
-                : undefined,
-            output: operation.output
-                ? schema(resolveSchemaRef(source.schemas, operation.output, `operation '${name}' output`))
-                : undefined,
-            callerCapabilities: operation.capabilities?.call ?? [],
-            readCapabilities: operation.capabilities?.read ?? [],
-            cancelCapabilities: operation.capabilities?.cancel ?? [],
-            cancel: operation.cancel,
-        },
-    ]));
-    const events = Object.fromEntries(Object.entries(source.events ?? {}).map(([name, event]) => {
-        if (event.params && event.params.length > 0) {
-            assertDataPointersExistAndAreTokenable(name, resolveSchemaRef(source.schemas, event.event, `event '${name}'`), event.params);
-        }
-        return [
-            name,
-            {
-                subject: event.subject ??
-                    eventSubject(name, event.version, event.params),
-                params: event.params,
-                event: schema(resolveSchemaRef(source.schemas, event.event, `event '${name}'`)),
-                publishCapabilities: event.capabilities?.publish ?? [],
-                subscribeCapabilities: event.capabilities?.subscribe ?? [],
-            },
-        ];
-    }));
-    const subjects = Object.fromEntries(Object.entries(source.subjects ?? {}).map(([name, subject]) => [
-        name,
-        {
-            subject: subject.subject,
-            schema: subject.message
-                ? schema(resolveSchemaRef(source.schemas, subject.message, `subject '${name}'`))
-                : undefined,
-            publishCapabilities: subject.capabilities?.publish ?? [],
-            subscribeCapabilities: subject.capabilities?.subscribe ?? [],
-        },
-    ]));
-    return { rpc, operations, events, subjects };
-}
-function mergeRecord(kind, out, next) {
-    for (const [key, value] of Object.entries(next)) {
-        if (Object.hasOwn(out, key)) {
-            throw new Error(`Duplicate ${kind} key '${key}' while deriving contract API`);
-        }
-        out[key] = value;
-    }
-}
-function assertSelectedKeysExist(contractId, kind, keys, api) {
-    if (!keys) {
-        return;
-    }
-    for (const key of keys) {
-        if (!Object.hasOwn(api, key)) {
-            throw new Error(`Contract '${contractId}' does not expose ${kind} key '${key}'`);
-        }
-    }
-}
-function assertValidUseSpec(contractId, spec, api) {
-    assertSelectedKeysExist(contractId, "rpc", spec.rpc?.call, api.rpc);
-    assertSelectedKeysExist(contractId, "operations", spec.operations?.call, api.operations);
-    assertSelectedKeysExist(contractId, "events", spec.events?.publish, api.events);
-    assertSelectedKeysExist(contractId, "events", spec.events?.subscribe, api.events);
-    assertSelectedKeysExist(contractId, "subjects", spec.subjects?.publish, api.subjects);
-    assertSelectedKeysExist(contractId, "subjects", spec.subjects?.subscribe, api.subjects);
-}
-function attachContractModuleMetadata(value, contractModule) {
-    Object.defineProperty(value, CONTRACT_MODULE_METADATA, {
-        value: contractModule,
-        enumerable: false,
-    });
-    return value;
-}
-function createUseHelper(getContractModule) {
-    return ((spec) => {
-        const contractModule = getContractModule();
-        assertValidUseSpec(contractModule.CONTRACT_ID, spec, contractModule.API.owned);
-        const dependencyUse = {
-            contract: contractModule.CONTRACT_ID,
-            ...(spec.rpc?.call ? { rpc: { call: [...spec.rpc.call] } } : {}),
-            ...(spec.operations?.call
-                ? { operations: { call: [...spec.operations.call] } }
-                : {}),
-            ...((spec.events?.publish || spec.events?.subscribe)
-                ? {
-                    events: {
-                        ...(spec.events.publish
-                            ? { publish: [...spec.events.publish] }
-                            : {}),
-                        ...(spec.events.subscribe
-                            ? { subscribe: [...spec.events.subscribe] }
-                            : {}),
-                    },
-                }
-                : {}),
-            ...((spec.subjects?.publish || spec.subjects?.subscribe)
-                ? {
-                    subjects: {
-                        ...(spec.subjects.publish
-                            ? { publish: [...spec.subjects.publish] }
-                            : {}),
-                        ...(spec.subjects.subscribe
-                            ? { subscribe: [...spec.subjects.subscribe] }
-                            : {}),
-                    },
-                }
-                : {}),
-        };
-        return attachContractModuleMetadata(dependencyUse, contractModule);
-    });
-}
-function getContractModuleFromUse(alias, useValue) {
-    const contractModule = useValue[CONTRACT_MODULE_METADATA];
-    if (!contractModule) {
-        throw new Error(`Contract use '${alias}' must be created with contractModule.use(...) from @qlever-llc/trellis-contracts`);
-    }
-    return contractModule;
-}
-function normalizeUses(uses) {
-    if (!uses) {
-        return {
-            manifestUses: undefined,
-            usedApi: { rpc: {}, operations: {}, events: {}, subjects: {} },
-        };
-    }
-    const manifestUses = {};
-    const usedApi = {
-        rpc: {},
-        operations: {},
-        events: {},
-        subjects: {},
-    };
-    for (const [alias, useValue] of Object.entries(uses)) {
-        const contractModule = getContractModuleFromUse(alias, useValue);
-        if (useValue.contract !== contractModule.CONTRACT_ID) {
-            throw new Error(`Contract use '${alias}' references '${useValue.contract}' but module id is '${contractModule.CONTRACT_ID}'`);
-        }
-        assertValidUseSpec(contractModule.CONTRACT_ID, useValue, contractModule.API.owned);
-        manifestUses[alias] = {
-            contract: contractModule.CONTRACT_ID,
-            ...(useValue.rpc?.call ? { rpc: { call: [...useValue.rpc.call] } } : {}),
-            ...(useValue.operations?.call
-                ? { operations: { call: [...useValue.operations.call] } }
-                : {}),
-            ...((useValue.events?.publish || useValue.events?.subscribe)
-                ? {
-                    events: {
-                        ...(useValue.events.publish
-                            ? { publish: [...useValue.events.publish] }
-                            : {}),
-                        ...(useValue.events.subscribe
-                            ? { subscribe: [...useValue.events.subscribe] }
-                            : {}),
-                    },
-                }
-                : {}),
-            ...((useValue.subjects?.publish || useValue.subjects?.subscribe)
-                ? {
-                    subjects: {
-                        ...(useValue.subjects.publish
-                            ? { publish: [...useValue.subjects.publish] }
-                            : {}),
-                        ...(useValue.subjects.subscribe
-                            ? { subscribe: [...useValue.subjects.subscribe] }
-                            : {}),
-                    },
-                }
-                : {}),
-        };
-        const rpcKeys = selectedKeys(useValue.rpc?.call);
-        if (rpcKeys.length > 0) {
-            mergeRecord("rpc", usedApi.rpc, Object.fromEntries(rpcKeys.map((key) => [key, contractModule.API.owned.rpc[key]])));
-        }
-        const operationKeys = selectedKeys(useValue.operations?.call);
-        if (operationKeys.length > 0) {
-            mergeRecord("operations", usedApi.operations, Object.fromEntries(operationKeys.map((key) => [key, contractModule.API.owned.operations[key]])));
-        }
-        const eventKeys = new Set([
-            ...selectedKeys(useValue.events?.publish),
-            ...selectedKeys(useValue.events?.subscribe),
-        ]);
-        if (eventKeys.size > 0) {
-            mergeRecord("events", usedApi.events, Object.fromEntries([...eventKeys].map((key) => [key, contractModule.API.owned.events[key]])));
-        }
-        const subjectKeys = new Set([
-            ...selectedKeys(useValue.subjects?.publish),
-            ...selectedKeys(useValue.subjects?.subscribe),
-        ]);
-        if (subjectKeys.size > 0) {
-            mergeRecord("subjects", usedApi.subjects, Object.fromEntries([...subjectKeys].map((key) => [key, contractModule.API.owned.subjects[key]])));
-        }
-    }
-    return { manifestUses, usedApi };
-}
-function selectedKeys(keys) {
-    return keys ?? [];
-}
-function mergeApiSection(kind, usedEntries, ownedEntries) {
-    const merged = {};
-    mergeRecord(kind, merged, usedEntries);
-    mergeRecord(kind, merged, ownedEntries);
-    return merged;
-}
-function mergeDerivedApis(ownedApi, usedApi) {
-    return {
-        rpc: mergeApiSection("rpc", usedApi.rpc, ownedApi.rpc),
-        operations: mergeApiSection("operations", usedApi.operations, ownedApi.operations),
-        events: mergeApiSection("events", usedApi.events, ownedApi.events),
-        subjects: mergeApiSection("subjects", usedApi.subjects, ownedApi.subjects),
-    };
-}
-export function defineContract(source) {
-    const { manifestUses, usedApi } = normalizeUses(source.uses);
-    const emittedSource = {
-        id: source.id,
-        displayName: source.displayName,
-        description: source.description,
-        kind: source.kind,
-        ...(source.schemas ? { schemas: source.schemas } : {}),
-        ...(manifestUses ? { uses: manifestUses } : {}),
-        ...(source.rpc ? { rpc: source.rpc } : {}),
-        ...(source.operations ? { operations: source.operations } : {}),
-        ...(source.events ? { events: source.events } : {}),
-        ...(source.subjects ? { subjects: source.subjects } : {}),
-        ...(source.errors ? { errors: source.errors } : {}),
-        ...(source.resources ? { resources: source.resources } : {}),
-    };
-    const ownedApi = buildOwnedApi(emittedSource);
-    const trellisApi = mergeDerivedApis(ownedApi, usedApi);
-    const CONTRACT = emitContract(emittedSource);
-    const CONTRACT_DIGEST = digestCanonicalJson(CONTRACT);
-    let contract;
-    contract = {
-        CONTRACT_ID: source.id,
-        CONTRACT,
-        CONTRACT_DIGEST,
-        API: {
-            owned: ownedApi,
-            used: usedApi,
-            trellis: trellisApi,
-        },
-        use: createUseHelper(() => contract),
-    };
-    return contract;
-}
-export { canonicalizeJson, digestJson, isJsonValue, schema, unwrapSchema };

package/esm/contracts/protocol.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../src/contracts/protocol.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAmB5C,eAAO,MAAM,wBAAwB;;;;;;EAMF,CAAC;AAEpC,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAEzE,eAAO,MAAM,2BAA2B;;;;;;EAML,CAAC;AAEpC,MAAM,MAAM,qBAAqB,GAAG,MAAM,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAE/E,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;EAgBN,CAAC;AAEpC,MAAM,MAAM,sBAAsB,GAAG,MAAM,CACzC,OAAO,4BAA4B,CACpC,CAAC;AAEF,eAAO,MAAM,uBAAuB;;EAED,CAAC;AAEpC,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAEvE,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;EAWR,CAAC;AAEpC,MAAM,MAAM,wBAAwB,GAAG,MAAM,CAC3C,OAAO,8BAA8B,CACtC,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;EAKJ,CAAC;AAEpC,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE7E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAEvE,eAAO,MAAM,uBAAuB;;;;;EAKD,CAAC;AAEpC,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAEvE,eAAO,MAAM,0BAA0B;;;;;EAKJ,CAAC;AAEpC,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE7E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;EAgBL,CAAC;AAEpC,MAAM,MAAM,qBAAqB,GAAG,MAAM,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAE/E,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;EAeA,CAAC;AAEpC,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAErE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;EAGH,CAAC;AAEpC,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE3E,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWzC,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,MAAM,CAC3C,OAAO,8BAA8B,CACtC,CAAC;AAEF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIR,CAAC;AAEpC,MAAM,MAAM,wBAAwB,GAAG,MAAM,CAC3C,OAAO,8BAA8B,CACtC,CAAC;AAEF,eAAO,MAAM,aAAa,iCAIsB,CAAC;AAEjD,eAAO,MAAM,iBAAiB;;;;;EAK5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE3D,eAAO,MAAM,eAAe;;;;;;EAM1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,OAAO,eAAe,CAAC,CAAC"}