@intentius/chant-lexicon-sql 0.0.0-stage → 0.112.1

package/dist/core/find-templates.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Finding a dialect's tags in a source file, for source-level lint rules and
+ * the editor (chant #3278). A rule reads a template's raw parts straight from
+ * the TypeScript AST and parses them the way the tag does, with every
+ * interpolation left a reference: lint cannot know the values.
+ *
+ * Every dialect exports tags with the same names (`table`, `view`), so a tag
+ * is a dialect's by the module it is imported from, never by its name.
+ */
+import * as ts from "typescript";
+import type { Token } from "./tokens.js";
+/** Which imports make a tag one dialect's. */
+export interface TemplateSource<Tag extends string = string> {
+    /** The dialect, as `sql.dialect` names it. */
+    dialect: string;
+    /** The module specifiers its tags are imported from. */
+    modules: readonly string[];
+    /** The tag names it exports. */
+    tags: readonly Tag[];
+}
+export interface FoundTemplate<Tag extends string = string> {
+    node: ts.TaggedTemplateExpression;
+    /** The dialect whose module the tag was imported from. */
+    dialect: string;
+    tag: Tag;
+    /** The template's raw parts, backslashes as written. */
+    parts: string[];
+    /** Source offset of each part's first character. */
+    starts: number[];
+    /** The source text of each interpolation's expression. */
+    expressions: ts.Expression[];
+}
+/** Every template in `source` whose tag is imported from one of `sources`' modules, in source order. */
+export declare function findSqlTemplates<Tag extends string>(source: ts.SourceFile, sources: readonly TemplateSource<Tag>[]): FoundTemplate<Tag>[];
+/** 1-based line and column of a template offset. */
+export declare function templatePosition(source: ts.SourceFile, found: FoundTemplate, part: number, offset: number): {
+    line: number;
+    column: number;
+};
+/** A token's position; an interpolation's is its expression's. */
+export declare function tokenPosition(source: ts.SourceFile, found: FoundTemplate, token: Token): {
+    line: number;
+    column: number;
+};
+/** The offset of an LSP position (0-based line and character) in `content`. */
+export declare function offsetAt(content: string, pos: {
+    line: number;
+    character: number;
+}): number;
+export interface Located<Tag extends string = string> {
+    source: ts.SourceFile;
+    found: FoundTemplate<Tag>;
+    /** The template part the cursor is in, or -1 when it is inside an interpolation's expression. */
+    part: number;
+    /** Offset in that part. */
+    offset: number;
+    /** The interpolation the cursor is in, when part is -1. */
+    expression: number;
+    /** Absolute source offset. */
+    at: number;
+}
+/** The template the source offset `at` is inside, and where in it. */
+export declare function locateIn<Tag extends string>(content: string, at: number, sources: readonly TemplateSource<Tag>[], fileName?: string): Located<Tag> | undefined;
+/** The identifier characters around an offset in a part. */
+export declare function wordAround(text: string, offset: number): {
+    start: number;
+    end: number;
+};
+//# sourceMappingURL=find-templates.d.ts.map

package/dist/core/find-templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-templates.d.ts","sourceRoot":"","sources":["../../src/core/find-templates.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAGtC,8CAA8C;AAC9C,MAAM,WAAW,cAAc,CAAC,GAAG,SAAS,MAAM,GAAG,MAAM;IACzD,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAC;IAChB,wDAAwD;IACxD,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,gCAAgC;IAChC,IAAI,EAAE,SAAS,GAAG,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,aAAa,CAAC,GAAG,SAAS,MAAM,GAAG,MAAM;IACxD,IAAI,EAAE,EAAE,CAAC,wBAAwB,CAAC;IAClC,0DAA0D;IAC1D,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,GAAG,CAAC;IACT,wDAAwD;IACxD,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,oDAAoD;IACpD,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,0DAA0D;IAC1D,WAAW,EAAE,EAAE,CAAC,UAAU,EAAE,CAAC;CAC9B;AAqBD,wGAAwG;AACxG,wBAAgB,gBAAgB,CAAC,GAAG,SAAS,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,EAAE,SAAS,cAAc,CAAC,GAAG,CAAC,EAAE,GAAG,aAAa,CAAC,GAAG,CAAC,EAAE,CAyBzI;AAED,oDAAoD;AACpD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,EAAE,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAI5I;AAED,kEAAkE;AAClE,wBAAgB,aAAa,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,KAAK,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CASzH;AAID,+EAA+E;AAC/E,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAQ1F;AAED,MAAM,WAAW,OAAO,CAAC,GAAG,SAAS,MAAM,GAAG,MAAM;IAClD,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC;IACtB,KAAK,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC;IAC1B,iGAAiG;IACjG,IAAI,EAAE,MAAM,CAAC;IACb,2BAA2B;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,2DAA2D;IAC3D,UAAU,EAAE,MAAM,CAAC;IACnB,8BAA8B;IAC9B,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,sEAAsE;AACtE,wBAAgB,QAAQ,CAAC,GAAG,SAAS,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,cAAc,CAAC,GAAG,CAAC,EAAE,EAAE,QAAQ,SAAY,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,SAAS,CAgBjK;AAID,4DAA4D;AAC5D,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAMvF"}

package/dist/core/handoff.d.ts

@@ -0,0 +1,36 @@
+/**
+ * How a plan hands a change it refuses to make in place to a migration Op,
+ * the same in every dialect.
+ *
+ * `chant sql plan`, `chant sql diff` and the applier refuse a change the
+ * dialect cannot make in place (a ClickHouse sorting-key change, which needs
+ * a rebuild). What they hand on is the Op to run instead, one per object: a
+ * declaration ready to put in an `*.op.ts` file, reviewed in the pull request
+ * like the schema change it carries out. Nothing is written for the user. The
+ * Op's own Plan phase classifies the change again against the server.
+ *
+ * Which Op, and the options a dialect suggests for it (ClickHouse's dual-write
+ * mode), are the dialect's.
+ */
+/** One Op to run instead of a refused change. A dialect adds its own suggested options. */
+export interface MigrationOpSuggestion {
+    /** The object the Op migrates, qualified as the dialect writes it. */
+    table: string;
+    /** The Op's suggested name. */
+    name: string;
+    env: string;
+    /** The declaration, ready to paste into an `*.op.ts` file. */
+    declaration: string;
+}
+/** An Op name for a migration of `table`: `<kind>-<table>`, lower case, runs of other characters as `-`. */
+export declare function migrationOpName(kind: string, table: string): string;
+/**
+ * The suggestions as report lines: what the Op is, the import it comes from,
+ * then one declaration per line.
+ */
+export declare function renderMigrationOps(ops: readonly MigrationOpSuggestion[], op: {
+    what: string;
+    exportName: string;
+    importPath: string;
+}): string[];
+//# sourceMappingURL=handoff.d.ts.map

package/dist/core/handoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handoff.d.ts","sourceRoot":"","sources":["../../src/core/handoff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,2FAA2F;AAC3F,MAAM,WAAW,qBAAqB;IACpC,sEAAsE;IACtE,KAAK,EAAE,MAAM,CAAC;IACd,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,8DAA8D;IAC9D,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,4GAA4G;AAC5G,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEnE;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,SAAS,qBAAqB,EAAE,EAAE,EAAE,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,EAAE,CAQhJ"}

package/dist/core/index.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The sql lexicon's shared core: what every dialect (`../clickhouse/`, and
+ * Postgres next, #3289) builds on, with no database's grammar in it (#3275
+ * question 7, #3047 question 1).
+ *
+ * Belongs here:
+ *
+ * - the entity base and Declarable plumbing, and column references
+ *   (`entity.ts`);
+ * - the lossless tokenizer, with each dialect's character-level rules as a
+ *   table (`tokens.ts`), and the parser base: a cursor over significant
+ *   tokens with expressions kept as token spans (`cursor.ts`);
+ * - the tagged-template plumbing: raw parts, what a plain interpolation
+ *   splices in, `SqlLiteral`, the tag's error (`template.ts`), and splicing,
+ *   span text, what each spliced value fed, and a view's column lineage
+ *   (`interpolation.ts`);
+ * - finding a dialect's templates in a source file by the module its tags
+ *   are imported from, for lint and the editor (`find-templates.ts`);
+ * - references between objects, column lineage, and the creation order
+ *   (`references.ts`);
+ * - identity and renames between two schemas, and the change-set model
+ *   (`diff.ts`);
+ * - the classifier framework: the rule shape, classes as data per dialect,
+ *   `classifyDisruption()` over a dialect's rules, the text report
+ *   (`classifier.ts`);
+ * - normalization helpers that are not a database's grammar, such as the
+ *   `-- previously:` hint (`normalize.ts`);
+ * - the ownership trailer on an object's comment (`ownership.ts`);
+ * - receipts kept on the server (`receipts.ts`);
+ * - the applier's tri-state outcome, its envelope projection and the build
+ *   output reader (`apply.ts`);
+ * - the hand-off from a refused change to a migration Op (`handoff.ts`);
+ * - a throwaway server in a container, and test helpers that are not one
+ *   database's (`container.ts`, `testing/`).
+ *
+ * Stays in a dialect: its lexical rules and statement grammar, its key words
+ * and identifier quoting, `literal()`'s escaping, its entity types and props,
+ * its generated types and overlays, its normalization rules, its rule ids
+ * and classes and the documentation they cite, the statements its applier
+ * sends and how it waits on the server, its client and binding, import and
+ * observation over its catalog, and its migration Op.
+ *
+ * Nothing here is exported from the package root or a dialect subpath on its
+ * own: each dialect re-exports what its public surface names.
+ */
+export * from "./entity.js";
+export * from "./tokens.js";
+export * from "./cursor.js";
+export * from "./template.js";
+export * from "./interpolation.js";
+export * from "./find-templates.js";
+export * from "./references.js";
+export * from "./diff.js";
+export * from "./classifier.js";
+export * from "./normalize.js";
+export * from "./ownership.js";
+export * from "./receipts.js";
+export * from "./apply.js";
+export * from "./handoff.js";
+export * from "./container.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,QAAQ,CAAC;AACvB,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC"}

package/dist/core/interpolation.d.ts

@@ -0,0 +1,88 @@
+/**
+ * What a tag does with its interpolations, in every dialect (chant #3196,
+ * #3212): splice plain values into the token list as SQL text while
+ * references stay `ref` tokens, render a span with its references written as
+ * names, record which props each spliced value fed, locate a parse error on
+ * its template line, and read column lineage off a view's select list.
+ *
+ * The dialect supplies its tokenizer rules, which values are its objects and
+ * column references, how a reference renders, and how a select-list name
+ * reads ({@link TemplateDialect}).
+ */
+import type { AttrRef } from "@intentius/chant/attrref";
+import { SqlSyntaxError, type LexicalRules, type Token } from "./tokens.js";
+import type { Span } from "./cursor.js";
+import type { LineageEdge } from "./references.js";
+import type { SqlObject } from "./entity.js";
+import { SqlTemplateError } from "./template.js";
+/** What a dialect supplies to the shared template machinery. */
+export interface TemplateDialect {
+    lexical: LexicalRules;
+    /** An entity of this dialect: an interpolation that references an object. */
+    isObject(value: unknown): value is SqlObject;
+    /** A column reference to one of this dialect's objects. */
+    isColumnRef(value: unknown): value is AttrRef;
+    /**
+     * How a referenced object or column renders in the SQL. `index` is the
+     * interpolation's index in the template, for a dialect whose rendering
+     * depends on where the reference sits (Postgres writes a sequence inside
+     * `nextval(...)` as a `regclass` literal).
+     */
+    renderReference(value: unknown, index?: number): string;
+    /** A name token's value in a select list (identifier quotes off, and folded where the dialect folds). */
+    identValue(text: string): string;
+    /** The output name of the `n`th (1-based) select-list item that has none. */
+    unnamedOutput(n: number): string;
+    /**
+     * What lineage reads off a select list beyond ClickHouse's rules, each off
+     * unless set (#3278). `aliasWithoutAs`: `expr name` names its output
+     * `name`; `keyword` says which bare words are key words, so `CASE ... END`
+     * or `a COLLATE "C"` is not read as an alias. `distinctOn`: a
+     * `DISTINCT ON (...)` after `SELECT` is not an item. `qualifiedRefs`:
+     * `alias.${t.columns.c}` names its output after the column. `outputOf`:
+     * the output name of an item with no alias, when the dialect derives one
+     * from the expression (Postgres names `count(x)` "count"); undefined falls
+     * back to {@link unnamedOutput}.
+     */
+    lineage?: {
+        aliasWithoutAs?: boolean;
+        keyword?(t: Token): "reserved" | "keyword" | undefined;
+        distinctOn?: boolean;
+        qualifiedRefs?: boolean;
+        outputOf?(items: readonly Token[], valueOf: (t: Token) => unknown): string | undefined;
+    };
+}
+/** A template being built: its tokens, the interpolated values, and what each spliced value fed. */
+export interface TemplateCtx {
+    d: TemplateDialect;
+    tokens: Token[];
+    values: readonly unknown[];
+    /**
+     * Per interpolation, the props paths its spliced text landed in (#3212).
+     * Only spliced text counts: an interpolated entity or column is a reference
+     * to a sibling, not a value the author typed into this field.
+     */
+    fed: Array<Set<string>>;
+}
+/** Record that the spliced text inside `span` fed `path`. */
+export declare function feed(ctx: TemplateCtx, span: Span | undefined, path: string): void;
+/**
+ * Splice every interpolation that is not a reference into the token list as
+ * SQL text. References stay `ref` tokens for the parser and the entity to see.
+ */
+export declare function splice(d: TemplateDialect, tag: string, parts: readonly string[], values: readonly unknown[]): Token[];
+/** A span's text, interpolations rendered, trimmed. With `path`, the span's spliced text is recorded as feeding it. */
+export declare function spanText(ctx: TemplateCtx, span: Span | undefined, path?: string): string | undefined;
+/** A parse error as the tag reports it: on the template line, or in the interpolated text it came from. */
+export declare function templateSyntaxError(tag: string, parts: readonly string[], err: SqlSyntaxError): SqlTemplateError;
+/**
+ * Column-level lineage of a view's SELECT: one edge per item of the top-level
+ * select list. FROM, WHERE and GROUP BY stay text; the objects they
+ * interpolate land in `reads`. A column written by name inside the SQL is not
+ * lineage: only references are (#3047, "no parsing of SQL for names").
+ */
+export declare function lineage<O extends SqlObject>(ctx: TemplateCtx, select: Span): {
+    edges: LineageEdge[];
+    reads: O[];
+};
+//# sourceMappingURL=interpolation.d.ts.map

package/dist/core/interpolation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpolation.d.ts","sourceRoot":"","sources":["../../src/core/interpolation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AACxD,OAAO,EAAY,cAAc,EAAsC,KAAK,YAAY,EAAE,KAAK,KAAK,EAAE,MAAM,UAAU,CAAC;AACvH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AACrC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAiC,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE7E,gEAAgE;AAChE,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,YAAY,CAAC;IACtB,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAAC;IAC7C,2DAA2D;IAC3D,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAAC;IAC9C;;;;;OAKG;IACH,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACxD,yGAAyG;IACzG,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IACjC,6EAA6E;IAC7E,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACjC;;;;;;;;;;OAUG;IACH,OAAO,CAAC,EAAE;QACR,cAAc,CAAC,EAAE,OAAO,CAAC;QACzB,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,CAAC;QACvD,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB,QAAQ,CAAC,CAAC,KAAK,EAAE,SAAS,KAAK,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,KAAK,KAAK,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;KACxF,CAAC;CACH;AAED,oGAAoG;AACpG,MAAM,WAAW,WAAW;IAC1B,CAAC,EAAE,eAAe,CAAC;IACnB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC;IAC3B;;;;OAIG;IACH,GAAG,EAAE,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;CACzB;AAED,6DAA6D;AAC7D,wBAAgB,IAAI,CAAC,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,IAAI,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAMjF;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,eAAe,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,EAAE,SAAS,OAAO,EAAE,GAAG,KAAK,EAAE,CAkCrH;AAED,uHAAuH;AACvH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,IAAI,GAAG,SAAS,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAIpG;AAED,2GAA2G;AAC3G,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,GAAG,EAAE,cAAc,GAAG,gBAAgB,CAMhH;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,SAAS,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,IAAI,GAAG;IAAE,KAAK,EAAE,WAAW,EAAE,CAAC;IAAC,KAAK,EAAE,CAAC,EAAE,CAAA;CAAE,CAkFjH"}

package/dist/core/normalize.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Normalization helpers that hold in every dialect. A dialect's normalization
+ * undoes what its own server rewrites (quoting, type aliases, default
+ * levels), by rule over its own parse; these are the pieces that are not any
+ * one database's grammar.
+ */
+/**
+ * The name in a `-- previously: <name>` comment, when the text holds one: the
+ * rename hint, before a `CREATE` for an object or on a column's line for a
+ * column. The name may be quoted with backquotes or double quotes.
+ */
+export declare function previouslyIn(comments: readonly string[]): string | undefined;
+/**
+ * Split canonical text (tokens joined by single spaces) on its top-level
+ * commas, outside parentheses and brackets.
+ */
+export declare function splitTopLevel(text: string): string[];
+//# sourceMappingURL=normalize.d.ts.map

package/dist/core/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../src/core/normalize.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAM5E;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAcpD"}

package/dist/core/ownership.d.ts

@@ -0,0 +1,60 @@
+/**
+ * chant's ownership marker as a trailer on an object's own comment, in every
+ * dialect that can comment on its objects (#3208).
+ *
+ * The marker never replaces the user's comment, which is a declared property.
+ * It is appended as a bracketed trailer,
+ *
+ *     Raw events [chant managed-by=chant stack=shop env=prod]
+ *
+ * and taken off again wherever chant reads a definition, so planning, the deep
+ * diff and import compare and write the declared comment alone. Someone who
+ * edits the comment by hand and drops the trailer makes the object read as
+ * foreign, which is the safe direction: it is never pruned, and the next apply
+ * of its declaration stamps it again.
+ *
+ * Values are percent-encoded outside `[A-Za-z0-9._-]`, so the trailer never
+ * holds a quote, a backslash, a space or a bracket of its own.
+ *
+ * Where the comment lives in a statement, and so how a trailer comes off a
+ * printed `CREATE`, is the dialect's grammar and stays with the dialect.
+ */
+import { type ChannelKeys, type OwnershipMarker } from "@intentius/chant/ownership";
+/** The keys inside the trailer. */
+export declare const COMMENT_OWNERSHIP_KEYS: ChannelKeys;
+/**
+ * The trailer key on the objects that hold effect receipts. Like a
+ * migration's working objects, they are chant's own bookkeeping and never
+ * part of a declared schema.
+ */
+export declare const RECEIPTS_TRAILER_KEY = "receipts";
+/** One `key=value` pair of a trailer, as a regular expression source. */
+export declare const TRAILER_PAIR = "[A-Za-z0-9._-]+=[A-Za-z0-9._%-]*";
+/** What a trailer says: the managed-by value and, when stamped, the stack and env. */
+export interface CommentMarker {
+    managedBy: string;
+    stack?: string;
+    env?: string;
+}
+/**
+ * The trailer for a marker: `[chant managed-by=chant stack=<stack> env=<env>]`.
+ * `extra` appends more pairs after the marker's own; a migration Op uses them
+ * to say which migration an object it made belongs to.
+ * Keys are `[A-Za-z0-9._-]+`; values are encoded like the rest.
+ */
+export declare function markerTrailer(marker: OwnershipMarker | undefined, extra?: Readonly<Record<string, string>>): string;
+/** A comment's text with the trailer taken off. */
+export declare function stripMarker(comment: string): string;
+/** The comment to set: the declared comment, then the trailer (with `extra` pairs, see {@link markerTrailer}). */
+export declare function stampedComment(declared: string | undefined, marker: OwnershipMarker | undefined, extra?: Readonly<Record<string, string>>): string;
+/** Every pair in a comment's trailer, decoded, or undefined when it has no trailer. */
+export declare function readTrailerPairs(comment: string | undefined): Map<string, string> | undefined;
+/** Whether a comment carries chant's managed-by marker and any of `keys` in its trailer. */
+export declare function hasChantTrailerKey(comment: string | undefined, keys: readonly string[]): boolean;
+/** The marker a comment carries, or undefined when it carries none. */
+export declare function readMarker(comment: string | undefined): CommentMarker | undefined;
+/** Whether a comment carries chant's managed-by marker. */
+export declare function isChantManaged(comment: string | undefined): boolean;
+/** Whether the comment's marker is exactly this project's: managed by chant, same stack, same env. */
+export declare function carriesMarker(comment: string | undefined, marker: OwnershipMarker | undefined): boolean;
+//# sourceMappingURL=ownership.d.ts.map

package/dist/core/ownership.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ownership.d.ts","sourceRoot":"","sources":["../../src/core/ownership.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAA8B,KAAK,WAAW,EAAE,KAAK,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAEhH,mCAAmC;AACnC,eAAO,MAAM,sBAAsB,EAAE,WAIpC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,aAAa,CAAC;AAG/C,yEAAyE;AACzE,eAAO,MAAM,YAAY,qCAA6B,CAAC;AAavD,sFAAsF;AACtF,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,eAAe,GAAG,SAAS,EAAE,KAAK,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM,GAAG,MAAM,CAUvH;AAED,mDAAmD;AACnD,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,kHAAkH;AAClH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,SAAS,EAAE,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,MAAM,CAGlJ;AAED,uFAAuF;AACvF,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAY7F;AAED,4FAA4F;AAC5F,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAGhG;AAED,uEAAuE;AACvE,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa,GAAG,SAAS,CASjF;AAED,2DAA2D;AAC3D,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAEnE;AAED,sGAAsG;AACtG,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,SAAS,GAAG,OAAO,CAIvG"}

package/dist/core/receipts.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Effect receipts kept on the database server itself, in every dialect
+ * (concepts/effect-receipts.mdx).
+ *
+ * A receipt is the proof that one effect ran, kept where the effect happened.
+ * A migration Op's backfill copies data on the server, so its receipts are
+ * rows on the same server, bound to the object they witness, and read and
+ * written over the connection the copy already uses. They die with the data
+ * when the Op's onFailure drops it, which a receipt kept in git would not.
+ *
+ * A dialect's store implements this interface over its own client and keeps
+ * the receipts in a table whose comment carries the ownership trailer with
+ * the `receipts` key (`./ownership.ts`), so schema reads leave it out. It is
+ * not registered as the global `receiptRead` / `receiptWrite` activities,
+ * which would take over every other lexicon's `effect()` steps in the run.
+ */
+import type { ReceiptStore } from "@intentius/chant/op/receipt-store";
+/** The receipt's address: `<stack>/<env>/<effect>`, the same fields an ownership marker carries. */
+export declare function receiptAddress(identity: {
+    stack?: string;
+    env?: string;
+}, effect: string): string;
+/** A receipt store on a database server. */
+export interface SqlReceiptStore extends ReceiptStore {
+    /** Every receipt whose address starts with `prefix`, latest value each: one query for a whole backfill. */
+    readAll(prefix: string): Promise<Map<string, string>>;
+}
+//# sourceMappingURL=receipts.d.ts.map

package/dist/core/receipts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"receipts.d.ts","sourceRoot":"","sources":["../../src/core/receipts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAEtE,oGAAoG;AACpG,wBAAgB,cAAc,CAAC,QAAQ,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEjG;AAED,4CAA4C;AAC5C,MAAM,WAAW,eAAgB,SAAQ,YAAY;IACnD,2GAA2G;IAC3G,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACvD"}

package/dist/core/references.d.ts

@@ -0,0 +1,37 @@
+/**
+ * References between schema objects, in every dialect: column lineage, the
+ * name a reference is written under in a build's output, and the order
+ * objects are created in.
+ */
+import type { Declarable } from "@intentius/chant";
+import type { AttrRef } from "@intentius/chant/attrref";
+/** One output column of a view and the columns it is computed from. */
+export interface LineageEdge {
+    output: string;
+    /** The select-list expression, rendered. */
+    expr: string;
+    /** The column references inside it. */
+    from: AttrRef[];
+}
+/** What the dependency order needs of an object: the references its DDL makes. */
+export interface Referencing {
+    readonly dependsOn: readonly unknown[];
+}
+/**
+ * A reference as a build's output writes it: an entity's export name, or
+ * `export.column` for a column. Undefined when the target is not exported.
+ */
+export declare function referenceName(value: unknown, names: Map<Declarable, string>): string | undefined;
+/** Lineage edges with their column references written as `export.column`. */
+export declare function lineageJson(edges: readonly LineageEdge[], names: Map<Declarable, string>): Array<{
+    output: string;
+    expr: string;
+    from: Array<string | null>;
+}>;
+/**
+ * Export names in creation order: an object after everything it references.
+ * Ties break by export name, so the order is the same however the files were
+ * discovered. A reference cycle is an error naming the cycle.
+ */
+export declare function applyOrder(objects: Map<string, Referencing>, names: Map<Declarable, string>): string[];
+//# sourceMappingURL=references.d.ts.map

package/dist/core/references.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"references.d.ts","sourceRoot":"","sources":["../../src/core/references.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAGxD,uEAAuE;AACvE,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,IAAI,EAAE,OAAO,EAAE,CAAC;CACjB;AAED,kFAAkF;AAClF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,SAAS,EAAE,SAAS,OAAO,EAAE,CAAC;CACxC;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,CAAC,UAAU,EAAE,MAAM,CAAC,GAAG,MAAM,GAAG,SAAS,CAOhG;AAED,6EAA6E;AAC7E,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,EAAE,KAAK,EAAE,GAAG,CAAC,UAAU,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;CAAE,CAAC,CAM9J;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EAAE,KAAK,EAAE,GAAG,CAAC,UAAU,EAAE,MAAM,CAAC,GAAG,MAAM,EAAE,CAsBtG"}

package/dist/core/template.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The tagged-template plumbing every dialect's tags share: reading a
+ * template's raw parts, what a non-reference interpolation splices in, and
+ * the error a tag throws with the template line it happened on.
+ *
+ * Tokenizing and parsing the spliced statement is the dialect's own.
+ */
+/** A spliced value meant as a string literal. A dialect's `literal()` makes one with its own quoting. */
+export declare class SqlLiteral {
+    readonly sql: string;
+    constructor(sql: string);
+}
+/** An error from a tag: the statement kind, the template line, and what went wrong. */
+export declare class SqlTemplateError extends Error {
+    readonly part: number;
+    readonly offset: number;
+    constructor(tag: string, message: string, part: number, offset: number);
+}
+/**
+ * A template's parts as the SQL reads them: the raw text, so a backslash in a
+ * regex or an escape stays as written, with the two escapes a template
+ * literal forces undone. `` \` `` is a backquote and `\${` is `${`; neither
+ * can be written in a template any other way.
+ */
+export declare function templateParts(strings: TemplateStringsArray | readonly string[]): string[];
+export declare function unescapeTemplateDelimiters(part: string): string;
+/** Where interpolation `index` sits in the template, for a message: the line of the template it is on. */
+export declare function interpolationLine(parts: readonly string[], index: number): number;
+/** A value's kind, for a message. */
+export declare function describeValue(value: unknown): string;
+/**
+ * The SQL text a non-reference value splices in, or an error message: a
+ * string is SQL text, a number, bigint or boolean its literal, `null` is
+ * `NULL`, a {@link SqlLiteral} its quoted form. Anything else has no SQL form.
+ */
+export declare function spliceText(value: unknown): string | {
+    error: string;
+};
+/** `o` without its `undefined` and `false` fields, so props hold only what the DDL says. */
+export declare const stripUnset: <T extends object>(o: T) => T;
+//# sourceMappingURL=template.d.ts.map

package/dist/core/template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../src/core/template.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,yGAAyG;AACzG,qBAAa,UAAU;IACT,QAAQ,CAAC,GAAG,EAAE,MAAM;gBAAX,GAAG,EAAE,MAAM;CAGjC;AAED,uFAAuF;AACvF,qBAAa,gBAAiB,SAAQ,KAAK;IAIvC,QAAQ,CAAC,IAAI,EAAE,MAAM;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM;gBAHvB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACN,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM;CAK1B;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAGzF;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED,0GAA0G;AAC1G,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEjF;AAED,qCAAqC;AACrC,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAKpD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAiBrE;AAED,4FAA4F;AAC5F,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,MAAM,EAAE,GAAG,CAAC,KAAG,CAC0C,CAAC"}

package/dist/core/testing/http-stub.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A stand-in HTTP server for tests, in every dialect: listens on a random
+ * loopback port and answers each request's body with what `answer` returns.
+ * A dialect's fake server (the ClickHouse HTTP interface answering its
+ * catalog reads) is built on it. Not a SQL engine.
+ */
+import { type IncomingMessage } from "node:http";
+export interface StubAnswer {
+    status: number;
+    text: string;
+}
+export interface HttpStub {
+    url: string;
+    close(): Promise<void>;
+}
+export declare function startHttpStub(answer: (body: string, req: IncomingMessage) => StubAnswer): Promise<HttpStub>;
+//# sourceMappingURL=http-stub.d.ts.map

package/dist/core/testing/http-stub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-stub.d.ts","sourceRoot":"","sources":["../../../src/core/testing/http-stub.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAgB,KAAK,eAAe,EAAe,MAAM,WAAW,CAAC;AAE5E,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,wBAAsB,aAAa,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,KAAK,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAajH"}

package/dist/core/tokens.d.ts

@@ -0,0 +1,102 @@
+/**
+ * A lossless tokenizer over a tagged template's parts (chant #3196).
+ *
+ * The template is never joined into one string with placeholders. Each literal
+ * part is tokenized on its own and an interpolation is a `ref` token between
+ * two parts, so a token's offset is an offset into the part the author wrote:
+ * what a lint rule and the editor point at.
+ *
+ * Lossless: concatenating every token's `text`, with each `ref` written back as
+ * `${...}`, gives the raw template text back byte for byte. Whitespace and
+ * comments are tokens (`ws`, `comment`), not discarded.
+ *
+ * Shared by every dialect. What differs at the character level (which quotes
+ * make an identifier, whether a backslash escapes, the punctuation and
+ * operator characters) is a dialect's {@link LexicalRules}; ClickHouse's are
+ * `../clickhouse/tokens.ts`, Postgres's `../postgres/tokens.ts`. The rules
+ * Postgres adds (#3278: dollar quotes, `E'...'` strings, nested comments,
+ * `$1` parameters, its number syntax) are optional fields, off unless a
+ * dialect sets them, so ClickHouse tokenizes exactly as before.
+ */
+export type TokenKind = "ws" | "comment"
+/** A bare identifier or keyword. */
+ | "ident"
+/** A `backquoted` or "double-quoted" identifier. */
+ | "qident" | "string" | "number"
+/** `( ) , ; . =` */
+ | "punct"
+/** Any other run of operator characters. */
+ | "op"
+/** An interpolation. */
+ | "ref"
+/** A positional parameter, `$1` (Postgres). */
+ | "param";
+export interface Token {
+    kind: TokenKind;
+    text: string;
+    /** The template part the token sits in. For a `ref`, the index of the interpolated value. */
+    part: number;
+    /** Offsets into that part. A `ref` has start = end = 0. */
+    start: number;
+    end: number;
+    /**
+     * Set on a token that came from a string the author interpolated, which is
+     * spliced into the statement as SQL text: the index of that interpolation.
+     * Its offsets are into the spliced string.
+     */
+    splice?: number;
+}
+/** A syntax error, located in the template: the part and the offset in it. */
+export declare class SqlSyntaxError extends Error {
+    readonly part: number;
+    readonly offset: number;
+    /** The token the error is at, when there is one. A spliced token's position is the interpolation's. */
+    readonly token?: Token | undefined;
+    constructor(message: string, part: number, offset: number, 
+    /** The token the error is at, when there is one. A spliced token's position is the interpolation's. */
+    token?: Token | undefined);
+}
+/** What a dialect's tokenizer differs in, at the character level. */
+export interface LexicalRules {
+    /** The characters that open a quoted identifier, each closed by itself. */
+    identQuotes: string;
+    /** Whether a backslash escapes the next character inside any quote. */
+    backslashEscapes: boolean;
+    /** The single-character punctuation tokens. */
+    punct: string;
+    /** The characters an operator run is made of. */
+    opChars: RegExp;
+    /**
+     * Prefixed string constants (Postgres): `E'...'`, where a backslash escapes,
+     * `B'...'` and `X'...'` bit strings, `N'...'`, and `U&'...'` / `U&"..."`
+     * with Unicode escapes. Each is one token, its prefix included.
+     */
+    prefixedStrings?: boolean;
+    /** `$$...$$` and `$tag$...$tag$` strings, and `$1` parameters (Postgres). */
+    dollarQuotes?: boolean;
+    /** Block comments nest: a comment opened inside a block comment needs its own close (Postgres). */
+    nestedComments?: boolean;
+    /**
+     * How a number reads. `digit-names` (the default): a number may run into
+     * letters, so `00662_events` is one token, which the ClickHouse parser
+     * accepts as a name. `sql`: `42`, `3.5`, `.5`, `1e-3`, `0x1F`, `0o17`,
+     * `0b101` and `1_000_000`, and a number never runs into a name (Postgres).
+     */
+    numbers?: "digit-names" | "sql";
+    /** Identifiers may hold letters outside ASCII, as Postgres's do. */
+    unicodeIdentifiers?: boolean;
+    /**
+     * A multi-character operator cannot end in `+` or `-` unless it also holds
+     * one of `~ ! @ # % ^ & | \` ?` (Postgres, "Lexical Structure"), so
+     * `=-30` is `=` then `-30`.
+     */
+    operatorsEndWithoutSign?: boolean;
+}
+/** Tokenize one string. `part` is the part index recorded on each token and on an error. */
+export declare function tokenizeText(src: string, part: number, rules: LexicalRules): Token[];
+/** Tokenize a template's parts, with a `ref` token for each interpolation between them. */
+export declare function tokenize(parts: readonly string[], rules: LexicalRules): Token[];
+export declare const isTrivia: (t: Token) => boolean;
+/** Every token's text back in order, each `ref` written by `ref`. */
+export declare function untokenize(tokens: readonly Token[], ref: (index: number) => string): string;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/core/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../src/core/tokens.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,MAAM,SAAS,GACjB,IAAI,GACJ,SAAS;AACX,oCAAoC;GAClC,OAAO;AACT,oDAAoD;GAClD,QAAQ,GACR,QAAQ,GACR,QAAQ;AACV,oBAAoB;GAClB,OAAO;AACT,4CAA4C;GAC1C,IAAI;AACN,wBAAwB;GACtB,KAAK;AACP,+CAA+C;GAC7C,OAAO,CAAC;AAEZ,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,6FAA6F;IAC7F,IAAI,EAAE,MAAM,CAAC;IACb,2DAA2D;IAC3D,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,8EAA8E;AAC9E,qBAAa,cAAe,SAAQ,KAAK;IAGrC,QAAQ,CAAC,IAAI,EAAE,MAAM;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,uGAAuG;IACvG,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK;gBAJtB,OAAO,EAAE,MAAM,EACN,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM;IACvB,uGAAuG;IAC9F,KAAK,CAAC,EAAE,KAAK,YAAA;CAKzB;AAED,qEAAqE;AACrE,MAAM,WAAW,YAAY;IAC3B,2EAA2E;IAC3E,WAAW,EAAE,MAAM,CAAC;IACpB,uEAAuE;IACvE,gBAAgB,EAAE,OAAO,CAAC;IAC1B,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,6EAA6E;IAC7E,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,mGAAmG;IACnG,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,aAAa,GAAG,KAAK,CAAC;IAChC,oEAAoE;IACpE,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;;;OAIG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC;AAOD,4FAA4F;AAC5F,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,KAAK,EAAE,CA0HpF;AAED,2FAA2F;AAC3F,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,YAAY,GAAG,KAAK,EAAE,CAO/E;AAED,eAAO,MAAM,QAAQ,GAAI,GAAG,KAAK,KAAG,OAAkD,CAAC;AAEvF,qEAAqE;AACrE,wBAAgB,UAAU,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,EAAE,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM,CAE3F"}