@algomotion/spec 0.0.0-stage → 1.0.0-alpha.1

package/dist/kinds/stack.d.ts

@@ -0,0 +1,70 @@
+/**
+ * The `stack` kind: last in, first out. Positions count from the bottom (0).
+ *
+ * Marks: `highlight` and `peek` last one step.
+ */
+import { z } from 'zod';
+import { type KindSpec } from './kind.ts';
+export declare const StackDecl: z.ZodObject<{
+    kind: z.ZodLiteral<"stack">;
+    label: z.ZodOptional<z.ZodString>;
+    place: z.ZodOptional<z.ZodEnum<{
+        main: "main";
+        side: "side";
+    }>>;
+    initial: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type StackDecl = z.infer<typeof StackDecl>;
+export declare const StackDeclInput: z.ZodObject<{
+    kind: z.ZodLiteral<"stack">;
+    label: z.ZodOptional<z.ZodString>;
+    place: z.ZodOptional<z.ZodEnum<{
+        main: "main";
+        side: "side";
+    }>>;
+    initial: z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>>, z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>>]>;
+}, z.core.$strict>;
+export type StackDeclInput = z.infer<typeof StackDeclInput>;
+export declare const StackAction: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"push">;
+    element: z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"pop">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"peek">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"highlight">;
+    indices: z.ZodArray<z.ZodInt>;
+}, z.core.$strict>], "type">;
+export type StackAction = z.infer<typeof StackAction>;
+export declare const StackActionInput: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"push">;
+    element: z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>]>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"pop">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"peek">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"highlight">;
+    indices: z.ZodArray<z.ZodInt>;
+}, z.core.$strict>], "type">;
+export type StackActionInput = z.infer<typeof StackActionInput>;
+export declare const stackSpec: KindSpec<{
+    decl: StackDecl;
+    declInput: StackDeclInput;
+    action: StackAction;
+    actionInput: StackActionInput;
+}>;
+//# sourceMappingURL=stack.d.ts.map

package/dist/kinds/stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack.d.ts","sourceRoot":"","sources":["../../src/kinds/stack.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAW,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAC;AAWnD,eAAO,MAAM,SAAS;;;;;;;;;;;kBAOsB,CAAC;AAC7C,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAElD,eAAO,MAAM,cAAc;;;;;;;;;;;kBAA+C,CAAC;AAC3E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAoB5D,eAAO,MAAM,WAAW;;;;;;;;;;;;;4BAAmB,CAAC;AAC5C,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AACtD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;4BAAwB,CAAC;AACtD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC;IAC/B,IAAI,EAAE,SAAS,CAAC;IAChB,SAAS,EAAE,cAAc,CAAC;IAC1B,MAAM,EAAE,WAAW,CAAC;IACpB,WAAW,EAAE,gBAAgB,CAAC;CAC/B,CAgBA,CAAC"}

package/dist/kinds/stack.js

@@ -0,0 +1,50 @@
+/**
+ * The `stack` kind: last in, first out. Positions count from the bottom (0).
+ *
+ * Marks: `highlight` and `peek` last one step.
+ */
+import { z } from 'zod';
+import { Element, ElementInput, LIMITS, Place } from "../common.js";
+import { typesOf } from "./kind.js";
+import { elementFieldIds, elementIds, Elements, ElementsInput, Indices, normalizeElementField, normalizeElements, } from "./linear.js";
+export const StackDecl = z
+    .strictObject({
+    kind: z.literal('stack'),
+    label: z.string().max(LIMITS.textLength).optional(),
+    place: Place.optional(),
+    initial: Elements.describe('Elements from bottom to top.'),
+})
+    .describe('A stack (last in, first out).');
+export const StackDeclInput = StackDecl.extend({ initial: ElementsInput });
+const actions = (element) => z.discriminatedUnion('type', [
+    z
+        .strictObject({ type: z.literal('push'), element })
+        .describe('Push `element` on top.'),
+    z
+        .strictObject({ type: z.literal('pop') })
+        .describe('Remove the top element.'),
+    z
+        .strictObject({ type: z.literal('peek') })
+        .describe('Highlight the top element (this step only).'),
+    z
+        .strictObject({ type: z.literal('highlight'), indices: Indices })
+        .describe('Highlight positions counted from the bottom (this step only).'),
+]);
+export const StackAction = actions(Element);
+export const StackActionInput = actions(ElementInput);
+export const stackSpec = {
+    kind: 'stack',
+    decl: StackDecl,
+    declInput: StackDeclInput,
+    action: StackAction,
+    actionInput: StackActionInput,
+    actionTypes: typesOf(StackAction),
+    normalizeDecl: (input) => ({
+        ...input,
+        initial: normalizeElements(input.initial),
+    }),
+    declIds: (decl) => elementIds(decl.initial),
+    normalizeAction: (action, ctx) => normalizeElementField(action, ctx),
+    introducedIds: (action) => action.type === 'push' ? elementFieldIds(action) : [],
+};
+//# sourceMappingURL=stack.js.map

package/dist/kinds/stack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack.js","sourceRoot":"","sources":["../../src/kinds/stack.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACpE,OAAO,EAAE,OAAO,EAAiB,MAAM,WAAW,CAAC;AACnD,OAAO,EACL,eAAe,EACf,UAAU,EACV,QAAQ,EACR,aAAa,EACb,OAAO,EACP,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,aAAa,CAAC;AAErB,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC;KACvB,YAAY,CAAC;IACZ,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC;IACxB,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,QAAQ,EAAE;IACnD,KAAK,EAAE,KAAK,CAAC,QAAQ,EAAE;IACvB,OAAO,EAAE,QAAQ,CAAC,QAAQ,CAAC,8BAA8B,CAAC;CAC3D,CAAC;KACD,QAAQ,CAAC,+BAA+B,CAAC,CAAC;AAG7C,MAAM,CAAC,MAAM,cAAc,GAAG,SAAS,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC,CAAC;AAG3E,MAAM,OAAO,GAAG,CAAsB,OAAU,EAAE,EAAE,CAClD,CAAC,CAAC,kBAAkB,CAAC,MAAM,EAAE;IAC3B,CAAC;SACE,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;SAClD,QAAQ,CAAC,wBAAwB,CAAC;IACrC,CAAC;SACE,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;SACxC,QAAQ,CAAC,yBAAyB,CAAC;IACtC,CAAC;SACE,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;SACzC,QAAQ,CAAC,6CAA6C,CAAC;IAC1D,CAAC;SACE,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;SAChE,QAAQ,CACP,+DAA+D,CAChE;CACJ,CAAC,CAAC;AAEL,MAAM,CAAC,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAE5C,MAAM,CAAC,MAAM,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AAGtD,MAAM,CAAC,MAAM,SAAS,GAKjB;IACH,IAAI,EAAE,OAAO;IACb,IAAI,EAAE,SAAS;IACf,SAAS,EAAE,cAAc;IACzB,MAAM,EAAE,WAAW;IACnB,WAAW,EAAE,gBAAgB;IAC7B,WAAW,EAAE,OAAO,CAAC,WAAW,CAAC;IACjC,aAAa,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACzB,GAAG,KAAK;QACR,OAAO,EAAE,iBAAiB,CAAC,KAAK,CAAC,OAAO,CAAC;KAC1C,CAAC;IACF,OAAO,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC;IAC3C,eAAe,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,CAC/B,qBAAqB,CAAC,MAAM,EAAE,GAAG,CAAgB;IACnD,aAAa,EAAE,CAAC,MAAM,EAAE,EAAE,CACxB,MAAM,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE;CACxD,CAAC"}

package/dist/kinds/table.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The `table` kind: a grid of cells, for dynamic programming (LCS, edit
+ * distance, knapsack, Floyd–Warshall) and adjacency matrices.
+ *
+ * Cells are addressed as `[row, column]`. A null cell is drawn empty.
+ *
+ * Marks: `highlight` and `depend` last one step; `settle` persists until
+ * `resetMarks`.
+ */
+import { z } from 'zod';
+import { type KindSpec } from './kind.ts';
+export declare const Cell: z.ZodTuple<[z.ZodInt, z.ZodInt], null>;
+export type Cell = z.infer<typeof Cell>;
+export declare const TableDecl: z.ZodObject<{
+    kind: z.ZodLiteral<"table">;
+    label: z.ZodOptional<z.ZodString>;
+    place: z.ZodOptional<z.ZodEnum<{
+        main: "main";
+        side: "side";
+    }>>;
+    cells: z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>>>;
+    rowLabels: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>>>;
+    columnLabels: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>>>;
+}, z.core.$strict>;
+export type TableDecl = z.infer<typeof TableDecl>;
+export declare const TableDeclInput: z.ZodObject<{
+    kind: z.ZodLiteral<"table">;
+    label: z.ZodOptional<z.ZodString>;
+    place: z.ZodOptional<z.ZodEnum<{
+        main: "main";
+        side: "side";
+    }>>;
+    rows: z.ZodOptional<z.ZodInt>;
+    columns: z.ZodOptional<z.ZodInt>;
+    initial: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>>>>;
+    rowLabels: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>>>;
+    columnLabels: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>>>;
+    cells: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>>>>;
+}, z.core.$strict>;
+export type TableDeclInput = z.infer<typeof TableDeclInput>;
+export declare const TableAction: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"set">;
+    cell: z.ZodTuple<[z.ZodInt, z.ZodInt], null>;
+    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"highlight">;
+    cells: z.ZodArray<z.ZodTuple<[z.ZodInt, z.ZodInt], null>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"depend">;
+    cell: z.ZodTuple<[z.ZodInt, z.ZodInt], null>;
+    on: z.ZodArray<z.ZodTuple<[z.ZodInt, z.ZodInt], null>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"settle">;
+    cells: z.ZodArray<z.ZodTuple<[z.ZodInt, z.ZodInt], null>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"resetMarks">;
+}, z.core.$strict>], "type">;
+export type TableAction = z.infer<typeof TableAction>;
+export declare const tableSpec: KindSpec<{
+    decl: TableDecl;
+    declInput: TableDeclInput;
+    action: TableAction;
+    actionInput: TableAction;
+}>;
+//# sourceMappingURL=table.d.ts.map

package/dist/kinds/table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../src/kinds/table.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAA2B,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAC;AAMnE,eAAO,MAAM,IAAI,wCAEmC,CAAC;AACrD,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAWxC,eAAO,MAAM,SAAS;;;;;;;;;;kBASC,CAAC;AACxB,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAElD,eAAO,MAAM,cAAc;;;;;;;;;;;;;kBA4BxB,CAAC;AACJ,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAqC5D,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;4BAoBtB,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEtD,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC;IAC/B,IAAI,EAAE,SAAS,CAAC;IAChB,SAAS,EAAE,cAAc,CAAC;IAC1B,MAAM,EAAE,WAAW,CAAC;IACpB,WAAW,EAAE,WAAW,CAAC;CAC1B,CAYA,CAAC"}

package/dist/kinds/table.js

@@ -0,0 +1,116 @@
+/**
+ * The `table` kind: a grid of cells, for dynamic programming (LCS, edit
+ * distance, knapsack, Floyd–Warshall) and adjacency matrices.
+ *
+ * Cells are addressed as `[row, column]`. A null cell is drawn empty.
+ *
+ * Marks: `highlight` and `depend` last one step; `settle` persists until
+ * `resetMarks`.
+ */
+import { z } from 'zod';
+import { Index, LIMITS, Place, Scalar } from "../common.js";
+import { typesOf } from "./kind.js";
+const Labels = z
+    .array(Scalar)
+    .max(Math.max(LIMITS.tableRows, LIMITS.tableColumns));
+export const Cell = z
+    .tuple([Index, Index])
+    .describe('A cell as [row, column], both from 0.');
+const Cells = z
+    .array(Cell)
+    .min(1)
+    .max(LIMITS.tableRows * LIMITS.tableColumns);
+const Grid = z
+    .array(z.array(Scalar).max(LIMITS.tableColumns))
+    .max(LIMITS.tableRows);
+export const TableDecl = z
+    .strictObject({
+    kind: z.literal('table'),
+    label: z.string().max(LIMITS.textLength).optional(),
+    place: Place.optional(),
+    cells: Grid.describe('Rows of cells; null cells are empty.'),
+    rowLabels: Labels.optional(),
+    columnLabels: Labels.optional(),
+})
+    .describe('A table.');
+export const TableDeclInput = z
+    .strictObject({
+    kind: z.literal('table'),
+    label: z.string().max(LIMITS.textLength).optional(),
+    place: Place.optional(),
+    rows: z.int().min(0).max(LIMITS.tableRows).optional(),
+    columns: z.int().min(0).max(LIMITS.tableColumns).optional(),
+    initial: Grid.optional().describe('Initial rows of cells; shorter rows are padded with empty cells.'),
+    rowLabels: Labels.optional().describe('Shown left of the rows, e.g. the characters of a string; row numbers by default.'),
+    columnLabels: Labels.optional().describe('Shown above the columns; column numbers by default.'),
+    cells: Grid.optional().describe('The canonical form of `initial`: every row, all of one length. Accepted so that parsed documents can be read again.'),
+})
+    .refine((d) => d.cells === undefined || d.initial === undefined, {
+    message: 'Give either `initial` or `cells`, not both',
+    path: ['cells'],
+})
+    // The same rule for JSON Schema validators, which cannot run the refinement.
+    .meta({ not: { required: ['initial', 'cells'] } })
+    .describe('Give `rows` and `columns` for an empty table, `initial` for one with values, or both to pad `initial`.');
+function normalizeTableDecl(input) {
+    const { rows, columns, cells: given, ...others } = input;
+    const { initial = given ?? [], ...rest } = others;
+    const height = Math.max(rows ?? 0, initial.length);
+    const width = Math.max(columns ?? 0, ...initial.map((row) => row.length));
+    const cells = Array.from({ length: height }, (_, r) => Array.from({ length: width }, (_, c) => initial[r]?.[c] ?? null));
+    return { ...rest, cells };
+}
+function validateTableDecl(decl) {
+    const issues = [];
+    const height = decl.cells.length;
+    const width = decl.cells[0]?.length ?? 0;
+    decl.cells.forEach((row, r) => {
+        if (row.length !== width)
+            issues.push({
+                path: ['cells', r],
+                message: `Row ${r} has ${row.length} cells, but row 0 has ${width}`,
+            });
+    });
+    if (decl.rowLabels !== undefined && decl.rowLabels.length !== height)
+        issues.push({
+            path: ['rowLabels'],
+            message: `There are ${decl.rowLabels.length} row labels for ${height} rows`,
+        });
+    if (decl.columnLabels !== undefined && decl.columnLabels.length !== width)
+        issues.push({
+            path: ['columnLabels'],
+            message: `There are ${decl.columnLabels.length} column labels for ${width} columns`,
+        });
+    return issues;
+}
+export const TableAction = z.discriminatedUnion('type', [
+    z
+        .strictObject({ type: z.literal('set'), cell: Cell, value: Scalar })
+        .describe('Write a cell; null empties it.'),
+    z
+        .strictObject({ type: z.literal('highlight'), cells: Cells })
+        .describe('Highlight cells (this step only).'),
+    z
+        .strictObject({ type: z.literal('depend'), cell: Cell, on: Cells })
+        .describe('Show that `cell` is computed from the cells `on` (this step only): every cell in `on` is marked, and each that touches `cell` gets an arrow to it.'),
+    z
+        .strictObject({ type: z.literal('settle'), cells: Cells })
+        .describe('Mark cells as part of the answer, e.g. a traced-back path (persists).'),
+    z
+        .strictObject({ type: z.literal('resetMarks') })
+        .describe('Clear every mark.'),
+]);
+export const tableSpec = {
+    kind: 'table',
+    decl: TableDecl,
+    declInput: TableDeclInput,
+    action: TableAction,
+    actionInput: TableAction,
+    actionTypes: typesOf(TableAction),
+    normalizeDecl: normalizeTableDecl,
+    declIds: () => [],
+    validateDecl: validateTableDecl,
+    normalizeAction: (action) => action,
+    introducedIds: () => [],
+};
+//# sourceMappingURL=table.js.map

package/dist/kinds/table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.js","sourceRoot":"","sources":["../../src/kinds/table.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,EAAE,OAAO,EAAiC,MAAM,WAAW,CAAC;AAEnE,MAAM,MAAM,GAAG,CAAC;KACb,KAAK,CAAC,MAAM,CAAC;KACb,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC;AAExD,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC;KAClB,KAAK,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;KACrB,QAAQ,CAAC,uCAAuC,CAAC,CAAC;AAGrD,MAAM,KAAK,GAAG,CAAC;KACZ,KAAK,CAAC,IAAI,CAAC;KACX,GAAG,CAAC,CAAC,CAAC;KACN,GAAG,CAAC,MAAM,CAAC,SAAS,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;AAE/C,MAAM,IAAI,GAAG,CAAC;KACX,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;KAC/C,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;AAEzB,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC;KACvB,YAAY,CAAC;IACZ,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC;IACxB,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,QAAQ,EAAE;IACnD,KAAK,EAAE,KAAK,CAAC,QAAQ,EAAE;IACvB,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,sCAAsC,CAAC;IAC5D,SAAS,EAAE,MAAM,CAAC,QAAQ,EAAE;IAC5B,YAAY,EAAE,MAAM,CAAC,QAAQ,EAAE;CAChC,CAAC;KACD,QAAQ,CAAC,UAAU,CAAC,CAAC;AAGxB,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC;KAC5B,YAAY,CAAC;IACZ,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC;IACxB,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,QAAQ,EAAE;IACnD,KAAK,EAAE,KAAK,CAAC,QAAQ,EAAE;IACvB,IAAI,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,QAAQ,EAAE;IACrD,OAAO,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,QAAQ,EAAE;IAC3D,OAAO,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAC/B,kEAAkE,CACnE;IACD,SAAS,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC,QAAQ,CACnC,kFAAkF,CACnF;IACD,YAAY,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC,QAAQ,CACtC,qDAAqD,CACtD;IACD,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAC7B,qHAAqH,CACtH;CACF,CAAC;KACD,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,SAAS,IAAI,CAAC,CAAC,OAAO,KAAK,SAAS,EAAE;IAC/D,OAAO,EAAE,4CAA4C;IACrD,IAAI,EAAE,CAAC,OAAO,CAAC;CAChB,CAAC;IACF,6EAA6E;KAC5E,IAAI,CAAC,EAAE,GAAG,EAAE,EAAE,QAAQ,EAAE,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC;KACjD,QAAQ,CACP,wGAAwG,CACzG,CAAC;AAGJ,SAAS,kBAAkB,CAAC,KAAqB;IAC/C,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,MAAM,EAAE,GAAG,KAAK,CAAC;IACzD,MAAM,EAAE,OAAO,GAAG,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,EAAE,GAAG,MAAM,CAAC;IAClD,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IACnD,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,IAAI,CAAC,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IAC1E,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CACpD,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CACjE,CAAC;IACF,OAAO,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,CAAC;AAC5B,CAAC;AAED,SAAS,iBAAiB,CAAC,IAAe;IACxC,MAAM,MAAM,GAAgB,EAAE,CAAC;IAC/B,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;IACjC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,IAAI,CAAC,CAAC;IACzC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE;QAC5B,IAAI,GAAG,CAAC,MAAM,KAAK,KAAK;YACtB,MAAM,CAAC,IAAI,CAAC;gBACV,IAAI,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC;gBAClB,OAAO,EAAE,OAAO,CAAC,QAAQ,GAAG,CAAC,MAAM,yBAAyB,KAAK,EAAE;aACpE,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IACH,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,MAAM;QAClE,MAAM,CAAC,IAAI,CAAC;YACV,IAAI,EAAE,CAAC,WAAW,CAAC;YACnB,OAAO,EAAE,aAAa,IAAI,CAAC,SAAS,CAAC,MAAM,mBAAmB,MAAM,OAAO;SAC5E,CAAC,CAAC;IACL,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,IAAI,IAAI,CAAC,YAAY,CAAC,MAAM,KAAK,KAAK;QACvE,MAAM,CAAC,IAAI,CAAC;YACV,IAAI,EAAE,CAAC,cAAc,CAAC;YACtB,OAAO,EAAE,aAAa,IAAI,CAAC,YAAY,CAAC,MAAM,sBAAsB,KAAK,UAAU;SACpF,CAAC,CAAC;IACL,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC,kBAAkB,CAAC,MAAM,EAAE;IACtD,CAAC;SACE,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;SACnE,QAAQ,CAAC,gCAAgC,CAAC;IAC7C,CAAC;SACE,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;SAC5D,QAAQ,CAAC,mCAAmC,CAAC;IAChD,CAAC;SACE,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC;SAClE,QAAQ,CACP,oJAAoJ,CACrJ;IACH,CAAC;SACE,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;SACzD,QAAQ,CACP,uEAAuE,CACxE;IACH,CAAC;SACE,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC;SAC/C,QAAQ,CAAC,mBAAmB,CAAC;CACjC,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,SAAS,GAKjB;IACH,IAAI,EAAE,OAAO;IACb,IAAI,EAAE,SAAS;IACf,SAAS,EAAE,cAAc;IACzB,MAAM,EAAE,WAAW;IACnB,WAAW,EAAE,WAAW;IACxB,WAAW,EAAE,OAAO,CAAC,WAAW,CAAC;IACjC,aAAa,EAAE,kBAAkB;IACjC,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE;IACjB,YAAY,EAAE,iBAAiB;IAC/B,eAAe,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM;IACnC,aAAa,EAAE,GAAG,EAAE,CAAC,EAAE;CACxB,CAAC"}

package/dist/kinds/tree.d.ts

@@ -0,0 +1,272 @@
+/**
+ * The `tree` kind: rooted trees and forests. Nodes have ordered child
+ * slots; a slot may be empty (null), which binary trees use to tell a lone
+ * right child from a left one.
+ *
+ * Covers binary search trees (with rotations and red–black colours),
+ * n-ary trees, tries, recursion trees and union–find forests.
+ *
+ * Marks: `highlight` and `compare` last one step; `visit`, `settle`,
+ * `group`, `pointer`, `annotate`, `markEdge` and `labelEdge` persist.
+ *
+ * Protocol 0.5 (ADR 0034) adds root slots, pointers at empty child slots
+ * (NIL), named notes, edge marks and labels, and root lists.
+ */
+import { z } from 'zod';
+import { type DeclIssue, type KindSpec } from './kind.ts';
+export declare const TreeNode: z.ZodObject<{
+    id: z.ZodString;
+    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+    children: z.ZodOptional<z.ZodArray<z.ZodNullable<z.ZodString>>>;
+    color: z.ZodOptional<z.ZodEnum<{
+        red: "red";
+        black: "black";
+    }>>;
+}, z.core.$strict>;
+export type TreeNode = z.infer<typeof TreeNode>;
+/** Canonical declaration. */
+export declare const TreeDecl: z.ZodObject<{
+    kind: z.ZodLiteral<"tree">;
+    label: z.ZodOptional<z.ZodString>;
+    place: z.ZodOptional<z.ZodEnum<{
+        main: "main";
+        side: "side";
+    }>>;
+    binary: z.ZodBoolean;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+        children: z.ZodOptional<z.ZodArray<z.ZodNullable<z.ZodString>>>;
+        color: z.ZodOptional<z.ZodEnum<{
+            red: "red";
+            black: "black";
+        }>>;
+    }, z.core.$strict>>;
+    roots: z.ZodArray<z.ZodString>;
+    rootList: z.ZodOptional<z.ZodEnum<{
+        list: "list";
+        circular: "circular";
+    }>>;
+}, z.core.$strict>;
+export type TreeDecl = z.infer<typeof TreeDecl>;
+export declare const TreeDeclInput: z.ZodObject<{
+    kind: z.ZodLiteral<"tree">;
+    label: z.ZodOptional<z.ZodString>;
+    place: z.ZodOptional<z.ZodEnum<{
+        main: "main";
+        side: "side";
+    }>>;
+    binary: z.ZodOptional<z.ZodBoolean>;
+    nodes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+        children: z.ZodOptional<z.ZodArray<z.ZodNullable<z.ZodString>>>;
+        color: z.ZodOptional<z.ZodEnum<{
+            red: "red";
+            black: "black";
+        }>>;
+    }, z.core.$strict>>>;
+    roots: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    rootList: z.ZodOptional<z.ZodEnum<{
+        list: "list";
+        circular: "circular";
+    }>>;
+    levelOrder: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>>>;
+}, z.core.$strict>;
+export type TreeDeclInput = z.infer<typeof TreeDeclInput>;
+/** Rules a schema cannot express: references exist, one parent each, no cycles. */
+export declare function validateTreeDecl(decl: TreeDecl): DeclIssue[];
+/** A named note's field, such as `size`, `max`, `deg` or `mark`. */
+export declare const NoteField: z.ZodString;
+export declare const TreeAction: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    slot: z.ZodOptional<z.ZodInt>;
+    type: z.ZodLiteral<"addNode">;
+    node: z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+        color: z.ZodOptional<z.ZodEnum<{
+            red: "red";
+            black: "black";
+        }>>;
+    }, z.core.$strict>;
+    parent: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"removeNode">;
+    node: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    slot: z.ZodOptional<z.ZodInt>;
+    type: z.ZodLiteral<"setChild">;
+    parent: z.ZodString;
+    child: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"detach">;
+    node: z.ZodString;
+    slot: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"rotate">;
+    node: z.ZodString;
+    direction: z.ZodEnum<{
+        left: "left";
+        right: "right";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"setValue">;
+    node: z.ZodString;
+    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"swapValues">;
+    a: z.ZodString;
+    b: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"setColor">;
+    node: z.ZodString;
+    color: z.ZodNullable<z.ZodEnum<{
+        red: "red";
+        black: "black";
+    }>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"highlight">;
+    nodes: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"compare">;
+    a: z.ZodString;
+    b: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"visit">;
+    node: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"settle">;
+    node: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"group">;
+    node: z.ZodString;
+    group: z.ZodNullable<z.ZodLiteral<0 | 1 | 4 | 2 | 3 | 5>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"pointer">;
+    name: z.ZodString;
+    node: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        parent: z.ZodString;
+        slot: z.ZodInt;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"annotate">;
+    node: z.ZodString;
+    text: z.ZodNullable<z.ZodString>;
+    field: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"markEdge">;
+    node: z.ZodString;
+    mark: z.ZodNullable<z.ZodEnum<{
+        selected: "selected";
+        rejected: "rejected";
+    }>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"labelEdge">;
+    node: z.ZodString;
+    label: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+}, z.core.$strict>], "type">;
+export type TreeAction = z.infer<typeof TreeAction>;
+export declare const TreeActionInput: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    slot: z.ZodOptional<z.ZodUnion<readonly [z.ZodInt, z.ZodEnum<{
+        left: "left";
+        right: "right";
+    }>]>>;
+    type: z.ZodLiteral<"addNode">;
+    node: z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+        color: z.ZodOptional<z.ZodEnum<{
+            red: "red";
+            black: "black";
+        }>>;
+    }, z.core.$strict>, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>]>;
+    parent: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"removeNode">;
+    node: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    slot: z.ZodOptional<z.ZodUnion<readonly [z.ZodInt, z.ZodEnum<{
+        left: "left";
+        right: "right";
+    }>]>>;
+    type: z.ZodLiteral<"setChild">;
+    parent: z.ZodString;
+    child: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"detach">;
+    node: z.ZodString;
+    slot: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"rotate">;
+    node: z.ZodString;
+    direction: z.ZodEnum<{
+        left: "left";
+        right: "right";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"setValue">;
+    node: z.ZodString;
+    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"swapValues">;
+    a: z.ZodString;
+    b: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"setColor">;
+    node: z.ZodString;
+    color: z.ZodNullable<z.ZodEnum<{
+        red: "red";
+        black: "black";
+    }>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"highlight">;
+    nodes: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"compare">;
+    a: z.ZodString;
+    b: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"visit">;
+    node: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"settle">;
+    node: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"group">;
+    node: z.ZodString;
+    group: z.ZodNullable<z.ZodLiteral<0 | 1 | 4 | 2 | 3 | 5>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"pointer">;
+    name: z.ZodString;
+    node: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        parent: z.ZodString;
+        slot: z.ZodUnion<readonly [z.ZodInt, z.ZodEnum<{
+            left: "left";
+            right: "right";
+        }>]>;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"annotate">;
+    node: z.ZodString;
+    text: z.ZodNullable<z.ZodString>;
+    field: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"markEdge">;
+    node: z.ZodString;
+    mark: z.ZodNullable<z.ZodEnum<{
+        selected: "selected";
+        rejected: "rejected";
+    }>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"labelEdge">;
+    node: z.ZodString;
+    label: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+}, z.core.$strict>], "type">;
+export type TreeActionInput = z.infer<typeof TreeActionInput>;
+export declare const treeSpec: KindSpec<{
+    decl: TreeDecl;
+    declInput: TreeDeclInput;
+    action: TreeAction;
+    actionInput: TreeActionInput;
+}>;
+//# sourceMappingURL=tree.d.ts.map

package/dist/kinds/tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.d.ts","sourceRoot":"","sources":["../../src/kinds/tree.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,OAAO,EAAW,KAAK,SAAS,EAAc,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAC;AAI/E,eAAO,MAAM,QAAQ;;;;;;;;kBAaM,CAAC;AAC5B,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAUhD,6BAA6B;AAC7B,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;kBAckB,CAAC;AACxC,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAEhD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;kBAyCtB,CAAC;AACL,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAuE1D,mFAAmF;AACnF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,EAAE,CAgE5D;AAiBD,oEAAoE;AACpE,eAAO,MAAM,SAAS,aASnB,CAAC;AA2IJ,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAyB,CAAC;AACjD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AACpD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAmC,CAAC;AAChE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAI9D,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC;IAC9B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,aAAa,CAAC;IACzB,MAAM,EAAE,UAAU,CAAC;IACnB,WAAW,EAAE,eAAe,CAAC;CAC9B,CA0CA,CAAC"}