@antelopejs/interface-dms-builder 0.4.0 → 0.5.0

package/dist/database.d.ts

@@ -0,0 +1,230 @@
+import type { ProjectConfigOpts, ProjectConfigResult } from "./project";
+import type { OpResult } from "./results";
+/**
+ * The engines a database can be checked on, by the name `CheckDatabaseConnection` takes, each with
+ * the URL schemes it accepts, colon included. `mysql` covers MariaDB too: the same client and the
+ * same catalog answer both.
+ */
+export declare const DATABASE_ENGINE_SCHEMES: {
+    readonly postgres: readonly ["postgres:", "postgresql:"];
+    readonly mysql: readonly ["mysql:"];
+    readonly mongodb: readonly ["mongodb:", "mongodb+srv:"];
+    readonly rethinkdb: readonly ["rethinkdb:"];
+};
+/** An engine of `DATABASE_ENGINE_SCHEMES`. */
+export type DatabaseEngine = keyof typeof DATABASE_ENGINE_SCHEMES;
+/** The database to check: its engine, and a URL of that engine's scheme. */
+export interface DatabaseCheckInput {
+    engine: DatabaseEngine;
+    url: string;
+}
+/** What a live check of a database found. */
+export interface DatabaseAccess {
+    /** Whether a server answered, even to refuse the sign-in. */
+    reachable: boolean;
+    /** The round trip of the first query the signed-in account made. */
+    latencyMs?: number;
+    /** The account the server reports. */
+    user?: string;
+    canRead: boolean;
+    canWrite: boolean;
+    /** A short sentence for the person who connects, whenever the database cannot be read. Never holds the URL, the password or a query. */
+    reason?: string;
+}
+/** One of the builder's catalog connections, with what its provider's `Info()` answers about it. */
+export interface CatalogConnectionEntry {
+    id: string;
+    /** The engine's name, e.g. `postgresql`. */
+    engine?: string;
+    /** The server's version. */
+    version?: string;
+    /** The database the connection is on. */
+    database?: string;
+    /** The role the connection runs as. */
+    role?: string;
+    /** Why the provider did not answer, in place of the fields above. */
+    error?: string;
+}
+/**
+ * The `interface-database` pin a module needs once a module that uses it pins another database:
+ * core passes that pin on to the modules that import it, which would then be reached with two
+ * bindings.
+ */
+export interface DatabasePin {
+    module: string;
+    provider: string;
+}
+/** A driver module of an engine, and the range of its versions a project can install. */
+export interface DriverPackage {
+    package: string;
+    version: string;
+}
+/** What connecting a database needs to know about the project. */
+export interface DatabaseProject {
+    /** The modules the project's configuration lists, by id. */
+    modules: string[];
+    /** The id of the module the builder runs in, the entry its catalog connections are declared on. */
+    self: string;
+    /** The project's own `interface-database` provider, when it has one. */
+    ownDatabase?: string;
+    /** The modules to pin to the own database before another one is connected. */
+    databasePins: DatabasePin[];
+    /** The id the configuration gives dms-database, when the project has it. */
+    dmsDatabase?: string;
+    /** The version of `@antelopejs/interface-database` the project resolves, when it resolves one. */
+    interfaceDatabase?: string;
+    /**
+     * The driver to add for each engine, with a range of only the versions built for
+     * `interfaceDatabase`. An engine with no driver built for it is absent.
+     */
+    drivers: Partial<Record<DatabaseEngine, DriverPackage>>;
+}
+/** A local module of the project, by its id in the configuration and its folder. */
+export interface ConnectionModule {
+    id: string;
+    path: string;
+}
+/** What a connection wired into the configuration, by module id. */
+export interface ConnectionWiring {
+    connection: string;
+    driver: string;
+    /** The local modules holding its tables: read through the driver, their record naming the connection. */
+    modules: ConnectionModule[];
+    /**
+     * Local modules read through the driver whose record names no connection, as one made before
+     * the record was: shown as the connection's tables module when it has no other, never removed.
+     */
+    unrecorded: ConnectionModule[];
+    /**
+     * Whether the driver was added for this connection alone, and goes with it: it is not the
+     * project's own database, and no module or connection the removal leaves names it.
+     */
+    ownsDriver: boolean;
+    /** The variable supplying the driver's `url`, when one does. */
+    variable?: string;
+    /** Every variable supplying the driver's configuration, `variable` among them. */
+    variables: string[];
+}
+/** A connection's details as its URL holds them, the password left out. */
+export interface ConnectionDetails {
+    scheme: string;
+    host: string;
+    port: string;
+    database: string;
+    user: string;
+    hasPassword: boolean;
+    /** The URL parameters, `sslmode` among them. */
+    options: Record<string, string>;
+}
+/** A connection's wiring, and its details when its URL can be read. */
+export interface DatabaseConnection {
+    wiring: ConnectionWiring;
+    details?: ConnectionDetails;
+}
+/** One `interface-database` or `interface-database-catalog` binding a module entry declares. */
+export interface EntryConnection {
+    interface: string;
+    /** The module that provides the interface. */
+    source: string;
+    /** The connection's id; absent for a plain pin. */
+    id?: string;
+    /**
+     * The access dms-database grants the connection: `read-write` only when its
+     * `config.externalConnections.<id>.access` says so, else `read`. Absent for a plain pin.
+     */
+    access?: "read" | "read-write";
+}
+/** The rows to sample from a relation of a catalog connection. */
+export interface RowSampleRequest {
+    relation: string;
+    columns?: string[];
+    /** At most the catalog's sample limit. */
+    limit: number;
+}
+/** A sampled value as text, cut at the catalog's text length. */
+export interface SampledText {
+    text: string;
+    truncated: boolean;
+}
+/** A binary value, answered by its length only. */
+export interface SampledBinary {
+    bytes: number;
+}
+export type SampledValue = SampledText | SampledBinary | null;
+/** Rows of a relation, each value in the order of `columns`. */
+export interface RowSample {
+    relation: string;
+    columns: string[];
+    rows: SampledValue[][];
+    /** How the relation was sampled before its first rows were read, when it was. */
+    sample: {
+        percent: number;
+        rows: number;
+    } | null;
+}
+/**
+ * The builder's catalog connections, each with its provider's `Info()` or why it did not answer.
+ *
+ * Owner path only: no MCP tool exposes it, so only an owner-authenticated entry calls it.
+ */
+export declare const ListDatabaseConnections: () => Promise<CatalogConnectionEntry[]>;
+/**
+ * Connects to a database the caller names and reports what its account may do, before any
+ * connection is written. In development only: elsewhere it fails with `unsupported`. An input that
+ * is not an engine and a URL of that engine's scheme fails with `invalid_config`, naming the fields
+ * and never their values. The engine's client package must be installed in the project.
+ *
+ * Owner path only: no MCP tool exposes it, so only an owner-authenticated entry calls it.
+ */
+export declare const CheckDatabaseConnection: (input: DatabaseCheckInput) => Promise<OpResult<DatabaseAccess>>;
+/**
+ * Adds what the configuration of each connection made before the connect flow registered it with
+ * dms-database is missing. Succeeds with no file when nothing is.
+ *
+ * Owner path only: no MCP tool exposes it, so only an owner-authenticated entry calls it.
+ */
+export declare const RepairDatabaseConnections: (opts?: ProjectConfigOpts | undefined) => Promise<OpResult<ProjectConfigResult>>;
+/**
+ * The project's modules and the database pins connecting another database needs.
+ *
+ * Owner path only: no MCP tool exposes it, so only an owner-authenticated entry calls it.
+ */
+export declare const GetDatabaseProject: () => Promise<OpResult<DatabaseProject>>;
+/**
+ * One connection's wiring and details; `not_found` when no module declares it.
+ *
+ * Owner path only: no MCP tool exposes it, so only an owner-authenticated entry calls it.
+ */
+export declare const GetDatabaseConnection: (connection: string) => Promise<OpResult<DatabaseConnection>>;
+/**
+ * Takes a connection out of the configuration: its catalog connections, its tables module and
+ * that module's folder, and its driver when it was added for this connection alone.
+ *
+ * Owner path only: no MCP tool exposes it, so only an owner-authenticated entry calls it.
+ */
+export declare const RemoveDatabaseConnection: (connection: string, opts?: ProjectConfigOpts | undefined) => Promise<OpResult<ProjectConfigResult>>;
+/**
+ * Writes a connection's URL into the variable that supplies it. A URL with no password keeps the
+ * current one. Answers the variable's name.
+ *
+ * Owner path only: no MCP tool exposes it, so only an owner-authenticated entry calls it.
+ */
+export declare const SetDatabaseConnectionUrl: (connection: string, url: string) => Promise<OpResult<{
+    variable: string;
+}>>;
+/**
+ * The `interface-database` and `interface-database-catalog` bindings of the module entry `module`,
+ * read from `antelope.config.ts` as written, whether core loads the module or not: a
+ * `disabled: true` entry answers too. `not_found` when no entry has that id. An entry, its
+ * `importOverrides` or a binding written in a way the builder cannot read, such as a variable or a
+ * spread, fails with `invalid_config` rather than leaving a binding out. Writes nothing.
+ *
+ * Owner path only: no MCP tool exposes it, so only an owner-authenticated entry calls it.
+ */
+export declare const ListEntryConnections: (module: string) => Promise<OpResult<EntryConnection[]>>;
+/**
+ * Sample rows of a relation of a catalog connection; `not_found` for an unknown connection.
+ *
+ * Owner path only: no MCP tool exposes it, so only an owner-authenticated entry calls it.
+ */
+export declare const SampleDatabaseRows: (connection: string, request: RowSampleRequest) => Promise<OpResult<RowSample>>;

package/dist/database.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SampleDatabaseRows = exports.ListEntryConnections = exports.SetDatabaseConnectionUrl = exports.RemoveDatabaseConnection = exports.GetDatabaseConnection = exports.GetDatabaseProject = exports.RepairDatabaseConnections = exports.CheckDatabaseConnection = exports.ListDatabaseConnections = exports.DATABASE_ENGINE_SCHEMES = void 0;
+const interface_core_1 = require("@antelopejs/interface-core");
+/**
+ * The engines a database can be checked on, by the name `CheckDatabaseConnection` takes, each with
+ * the URL schemes it accepts, colon included. `mysql` covers MariaDB too: the same client and the
+ * same catalog answer both.
+ */
+exports.DATABASE_ENGINE_SCHEMES = {
+    postgres: ["postgres:", "postgresql:"],
+    mysql: ["mysql:"],
+    mongodb: ["mongodb:", "mongodb+srv:"],
+    rethinkdb: ["rethinkdb:"],
+};
+/**
+ * The builder's catalog connections, each with its provider's `Info()` or why it did not answer.
+ *
+ * Owner path only: no MCP tool exposes it, so only an owner-authenticated entry calls it.
+ */
+exports.ListDatabaseConnections = (0, interface_core_1.InterfaceFunction)();
+/**
+ * Connects to a database the caller names and reports what its account may do, before any
+ * connection is written. In development only: elsewhere it fails with `unsupported`. An input that
+ * is not an engine and a URL of that engine's scheme fails with `invalid_config`, naming the fields
+ * and never their values. The engine's client package must be installed in the project.
+ *
+ * Owner path only: no MCP tool exposes it, so only an owner-authenticated entry calls it.
+ */
+exports.CheckDatabaseConnection = (0, interface_core_1.InterfaceFunction)();
+/**
+ * Adds what the configuration of each connection made before the connect flow registered it with
+ * dms-database is missing. Succeeds with no file when nothing is.
+ *
+ * Owner path only: no MCP tool exposes it, so only an owner-authenticated entry calls it.
+ */
+exports.RepairDatabaseConnections = (0, interface_core_1.InterfaceFunction)();
+/**
+ * The project's modules and the database pins connecting another database needs.
+ *
+ * Owner path only: no MCP tool exposes it, so only an owner-authenticated entry calls it.
+ */
+exports.GetDatabaseProject = (0, interface_core_1.InterfaceFunction)();
+/**
+ * One connection's wiring and details; `not_found` when no module declares it.
+ *
+ * Owner path only: no MCP tool exposes it, so only an owner-authenticated entry calls it.
+ */
+exports.GetDatabaseConnection = (0, interface_core_1.InterfaceFunction)();
+/**
+ * Takes a connection out of the configuration: its catalog connections, its tables module and
+ * that module's folder, and its driver when it was added for this connection alone.
+ *
+ * Owner path only: no MCP tool exposes it, so only an owner-authenticated entry calls it.
+ */
+exports.RemoveDatabaseConnection = (0, interface_core_1.InterfaceFunction)();
+/**
+ * Writes a connection's URL into the variable that supplies it. A URL with no password keeps the
+ * current one. Answers the variable's name.
+ *
+ * Owner path only: no MCP tool exposes it, so only an owner-authenticated entry calls it.
+ */
+exports.SetDatabaseConnectionUrl = (0, interface_core_1.InterfaceFunction)();
+/**
+ * The `interface-database` and `interface-database-catalog` bindings of the module entry `module`,
+ * read from `antelope.config.ts` as written, whether core loads the module or not: a
+ * `disabled: true` entry answers too. `not_found` when no entry has that id. An entry, its
+ * `importOverrides` or a binding written in a way the builder cannot read, such as a variable or a
+ * spread, fails with `invalid_config` rather than leaving a binding out. Writes nothing.
+ *
+ * Owner path only: no MCP tool exposes it, so only an owner-authenticated entry calls it.
+ */
+exports.ListEntryConnections = (0, interface_core_1.InterfaceFunction)();
+/**
+ * Sample rows of a relation of a catalog connection; `not_found` for an unknown connection.
+ *
+ * Owner path only: no MCP tool exposes it, so only an owner-authenticated entry calls it.
+ */
+exports.SampleDatabaseRows = (0, interface_core_1.InterfaceFunction)();
+//# sourceMappingURL=database.js.map

package/dist/database.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.js","sourceRoot":"","sources":["../src/database.ts"],"names":[],"mappings":";;;AAAA,+DAA+D;AAI/D;;;;GAIG;AACU,QAAA,uBAAuB,GAAG;IACrC,QAAQ,EAAE,CAAC,WAAW,EAAE,aAAa,CAAC;IACtC,KAAK,EAAE,CAAC,QAAQ,CAAC;IACjB,OAAO,EAAE,CAAC,UAAU,EAAE,cAAc,CAAC;IACrC,SAAS,EAAE,CAAC,YAAY,CAAC;CACqC,CAAC;AAuKjE;;;;GAIG;AACU,QAAA,uBAAuB,GAClC,IAAA,kCAAiB,GAA2C,CAAC;AAE/D;;;;;;;GAOG;AACU,QAAA,uBAAuB,GAClC,IAAA,kCAAiB,GAEd,CAAC;AAEN;;;;;GAKG;AACU,QAAA,yBAAyB,GACpC,IAAA,kCAAiB,GAEd,CAAC;AAEN;;;;GAIG;AACU,QAAA,kBAAkB,GAC7B,IAAA,kCAAiB,GAA4C,CAAC;AAEhE;;;;GAIG;AACU,QAAA,qBAAqB,GAChC,IAAA,kCAAiB,GAEd,CAAC;AAEN;;;;;GAKG;AACU,QAAA,wBAAwB,GACnC,IAAA,kCAAiB,GAKd,CAAC;AAEN;;;;;GAKG;AACU,QAAA,wBAAwB,GACnC,IAAA,kCAAiB,GAEd,CAAC;AAEN;;;;;;;;GAQG;AACU,QAAA,oBAAoB,GAC/B,IAAA,kCAAiB,GAA4D,CAAC;AAEhF;;;;GAIG;AACU,QAAA,kBAAkB,GAC7B,IAAA,kCAAiB,GAKd,CAAC"}

package/dist/drafts.d.ts

@@ -4,22 +4,53 @@ import type { ResourceRef } from "./resources";
 import type { MutationOpts, OpResult } from "./results";
 import type { EditablePageMeta } from "./structure";
 import type { ConfigObject } from "./values";
+/**
+ * A block as the caller wants it written. The whole tree is declarative: what
+ * the draft describes is what the page file ends up holding.
+ */
 export interface BlockDraft {
+    /** Static key (top-level) or `.child()` id (nested). Must be an identifier. */
     name: string;
+    /** A catalog type; informational and checked against source when preserved. */
     type?: string;
+    /** Understood options only. Omit locked options; the server retains their source. */
     config?: ConfigObject;
+    /** Read-only UI hints. The server derives option locks from its own source. */
     lockedOptions?: Record<string, string>;
     slot?: string;
+    /** Child metadata emitted with `slot`, e.g. `{ colSpan: 2 }`. */
     meta?: ConfigObject;
+    /** Required for a controller-leading block type such as `TableView`. */
     controller?: ResourceRef;
+    /** Preserved parents may include their unchanged, recursively preserved children. */
     children?: BlockDraft[];
+    /**
+     * Write the block back exactly as it stands on disk, identified by its name
+     * among its siblings. This is how an opaque block — a `CustomComponent`, a
+     * computed expression, anything the builder can read but not rewrite —
+     * survives a whole-tree write. A `preserve` block whose name no longer
+     * matches anything fails validation. Partially editable blocks keep their
+     * source path, type, controller and child placement; they cannot be copied.
+     */
     preserve?: boolean;
 }
+/** A page as the caller wants it written. */
 export interface PageDraft {
+    /** Metadata to patch alongside the blocks; omit to leave it alone. */
     page?: Partial<EditablePageMeta>;
     blocks: BlockDraft[];
+    /**
+     * The queries the page should serve, written in the same transaction as the
+     * blocks — a block and the data it reads are one edit.
+     *
+     * Omit to leave the page's queries untouched. An empty array is not the same
+     * thing: it says the page should serve none, and removes the generated ones.
+     * A query a human has taken over is never rewritten or removed; it comes back
+     * as a warning instead.
+     */
     queries?: AddQueryInput[];
 }
+/** A component tree in the shape the DMS frontend consumes. */
 export type ComponentPreview = {
     componentName: string;
     options?: ConfigObject;
@@ -31,17 +62,47 @@ export type ComponentPreviewChild = {
     component: ComponentPreview;
     [key: string]: ConfigObject[string];
 };
+/** The preview of a page draft, keyed by top-level block name. */
 export interface PageLayoutPreview {
     components: Record<string, ComponentPreview>;
+    /**
+     * Blocks the preview could not build faithfully — an unresolved `$ref` or
+     * `$expr`, a factory that threw. Render the last known-good layout for those
+     * rather than trusting this one.
+     */
     degraded: BlockPath[];
 }
+/**
+ * Write a page's whole block tree in one transaction: one typecheck, one write,
+ * one `changes` list. The declarative counterpart of the per-block operations,
+ * meant for an editor holding a draft of the page rather than replaying edits.
+ *
+ * Blocks absent from the draft are removed; static members that are not blocks
+ * are left alone. Pass `expectedVersion` to make the write conditional.
+ */
 export declare const SetPageBlocks: (page: string, draft: PageDraft, opts?: MutationOpts | undefined) => Promise<OpResult<{
     version: string;
 }>>;
+/**
+ * Serialize a draft the way the runtime would, without writing anything. The
+ * factories are the real ones, so the result is what the page would render.
+ * Nothing is typechecked and nothing reaches disk.
+ */
 export declare const PreviewLayout: (page: string, draft: PageDraft) => Promise<OpResult<PageLayoutPreview>>;
+/**
+ * Run a query that has not been written, and answer what its route would.
+ *
+ * The other half of previewing a draft: `PreviewLayout` says what the page will
+ * look like, this says what its blocks will be showing. Read-only, and limited to
+ * a page of points — a preview that returned a million rows would be answering a
+ * different question.
+ */
 export declare const PreviewQuery: (request: QueryPreviewRequest) => Promise<OpResult<QueryPreview>>;
+/** What to run, and what the route would have been handed. */
 export interface QueryPreviewRequest {
     query: AddQueryInput;
+    /** Values the route would receive, by the name it exposes them under. */
     args?: ConfigObject;
+    /** The tenant whose rows to read, for a resource in a per-tenant schema. */
     tenant?: string;
 }

package/dist/drafts.js

@@ -2,7 +2,28 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PreviewQuery = exports.PreviewLayout = exports.SetPageBlocks = void 0;
 const interface_core_1 = require("@antelopejs/interface-core");
+/**
+ * Write a page's whole block tree in one transaction: one typecheck, one write,
+ * one `changes` list. The declarative counterpart of the per-block operations,
+ * meant for an editor holding a draft of the page rather than replaying edits.
+ *
+ * Blocks absent from the draft are removed; static members that are not blocks
+ * are left alone. Pass `expectedVersion` to make the write conditional.
+ */
 exports.SetPageBlocks = (0, interface_core_1.InterfaceFunction)();
+/**
+ * Serialize a draft the way the runtime would, without writing anything. The
+ * factories are the real ones, so the result is what the page would render.
+ * Nothing is typechecked and nothing reaches disk.
+ */
 exports.PreviewLayout = (0, interface_core_1.InterfaceFunction)();
+/**
+ * Run a query that has not been written, and answer what its route would.
+ *
+ * The other half of previewing a draft: `PreviewLayout` says what the page will
+ * look like, this says what its blocks will be showing. Read-only, and limited to
+ * a page of points — a preview that returned a million rows would be answering a
+ * different question.
+ */
 exports.PreviewQuery = (0, interface_core_1.InterfaceFunction)();
 //# sourceMappingURL=drafts.js.map

package/dist/drafts.js.map

@@ -1 +1 @@
-{"version":3,"file":"drafts.js","sourceRoot":"","sources":["../src/drafts.ts"],"names":[],"mappings":";;;AAAA,+DAA+D;AAyFlD,QAAA,aAAa,GACxB,IAAA,kCAAiB,GAMd,CAAC;AAOO,QAAA,aAAa,GACxB,IAAA,kCAAiB,GAEd,CAAC;AAUO,QAAA,YAAY,GACvB,IAAA,kCAAiB,GAEd,CAAC"}
+{"version":3,"file":"drafts.js","sourceRoot":"","sources":["../src/drafts.ts"],"names":[],"mappings":";;;AAAA,+DAA+D;AAiF/D;;;;;;;GAOG;AACU,QAAA,aAAa,GACxB,IAAA,kCAAiB,GAMd,CAAC;AAEN;;;;GAIG;AACU,QAAA,aAAa,GACxB,IAAA,kCAAiB,GAEd,CAAC;AAEN;;;;;;;GAOG;AACU,QAAA,YAAY,GACvB,IAAA,kCAAiB,GAEd,CAAC"}

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export * from "./addressing";
 export * from "./analysis";
 export * from "./catalog";
 export * from "./compose";
+export * from "./database";
 export * from "./drafts";
 export * from "./mapping";
 export * from "./operation-map";
@@ -12,4 +13,5 @@ export * from "./resources";
 export * from "./results";
 export * from "./structure";
 export * from "./table-view";
+export * from "./theme";
 export * from "./values";

package/dist/index.js

@@ -18,6 +18,7 @@ __exportStar(require("./addressing"), exports);
 __exportStar(require("./analysis"), exports);
 __exportStar(require("./catalog"), exports);
 __exportStar(require("./compose"), exports);
+__exportStar(require("./database"), exports);
 __exportStar(require("./drafts"), exports);
 __exportStar(require("./mapping"), exports);
 __exportStar(require("./operation-map"), exports);
@@ -28,5 +29,6 @@ __exportStar(require("./resources"), exports);
 __exportStar(require("./results"), exports);
 __exportStar(require("./structure"), exports);
 __exportStar(require("./table-view"), exports);
+__exportStar(require("./theme"), exports);
 __exportStar(require("./values"), exports);
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+CAA6B;AAC7B,6CAA2B;AAC3B,4CAA0B;AAC1B,4CAA0B;AAC1B,2CAAyB;AACzB,4CAA0B;AAC1B,kDAAgC;AAChC,+CAA6B;AAC7B,4CAA0B;AAC1B,4CAA0B;AAC1B,8CAA4B;AAC5B,4CAA0B;AAC1B,8CAA4B;AAC5B,+CAA6B;AAC7B,2CAAyB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+CAA6B;AAC7B,6CAA2B;AAC3B,4CAA0B;AAC1B,4CAA0B;AAC1B,6CAA2B;AAC3B,2CAAyB;AACzB,4CAA0B;AAC1B,kDAAgC;AAChC,+CAA6B;AAC7B,4CAA0B;AAC1B,4CAA0B;AAC1B,8CAA4B;AAC5B,4CAA0B;AAC1B,8CAA4B;AAC5B,+CAA6B;AAC7B,0CAAwB;AACxB,2CAAyB"}