@agentshouse/mdruntime 0.1.0-c2c52158b7381 → 0.1.0-c2e8a6f99866d

package/dist/replica.js

@@ -1,10 +1,9 @@
 import { equalValue, parse } from '@agentshouse/mdmodel';
 import { immutable, landing } from './change.js';
-import { changedCleanly, collecting, unreadable, validateCollection, } from './collection.js';
-import { acceptedBinaries, overlayChanged, overlaying, sameText, } from './overlay.js';
+import { collectionOf } from './collection.js';
+import { acceptedBinaries, overlaying } from './overlay.js';
 import { effectiveIn, rewriting } from './save.js';
-import { drafted, entriesIn, patched, settling, sharing } from './shared.js';
-import { ROW_WEIGHT, stepped } from './turn.js';
+import { ROW_WEIGHT } from './turn.js';
 export function compositionOf(record) {
     return {
         model: record.model,
@@ -13,230 +12,187 @@ export function compositionOf(record) {
             : { roots: record.typedSelection.roots, model: record.selectionModel },
     };
 }
-function* holding(record) {
-    const documents = yield* sharing(record.documents);
-    const binaries = yield* sharing(record.binaries);
-    const revisions = yield* sharing(record.revisions);
-    const fileIds = yield* sharing(record.fileIds);
-    const changes = yield* sharing(record.changes);
-    const written = yield* sharing(record.written);
-    return documents === record.documents &&
-        binaries === record.binaries &&
-        revisions === record.revisions &&
-        fileIds === record.fileIds &&
-        changes === record.changes &&
-        written === record.written
-        ? record
-        : { ...record, documents, binaries, revisions, fileIds, changes, written };
-}
-export function confirmedOf(record, previous) {
-    return stepped(confirming(record, previous));
-}
-function* confirming(record, previous) {
-    const kept = yield* holding(record);
-    return {
-        record: kept,
-        collection: yield* collecting(kept.documents, compositionOf(kept), previous?.collection),
-    };
-}
 export function sameMembership(record, other) {
     return (JSON.stringify(record.typedSelection?.roots ?? null) ===
         JSON.stringify(other.typedSelection?.roots ?? null));
 }
-function* cleanly(record, previous) {
-    if (previous === undefined)
-        return false;
-    const before = previous.record;
-    return yield* changedCleanly({ text: record.documents, binaries: record.binaries }, { text: before.documents, binaries: before.binaries, composition: compositionOf(before) }, compositionOf(record));
+export function storedRecord(record) {
+    const { key: _key, ...stored } = record;
+    return JSON.stringify(stored);
 }
-function* staging(staged, previous) {
-    const record = yield* holding(staged);
-    const textChanged = previous === undefined || !(yield* sameText(record, previous.record));
-    const modeled = record.model.status !== 'unavailable' || record.selectionModel.status !== 'unavailable';
-    if (modeled &&
-        (textChanged ||
-            record.model !== previous?.record.model ||
-            record.selectionModel !== previous?.record.selectionModel) &&
-        !(yield* cleanly(record, previous))) {
-        const verdict = yield* validateCollection(record.documents, Object.keys(record.binaries), compositionOf(record));
-        if (verdict.verdict === 'refuse' && verdict.rule !== 'model-unavailable') {
-            return { kind: 'refused', refusal: verdict };
-        }
-        if (verdict.verdict === 'refuse') {
-            const refused = yield* unreadable(record.documents, previous?.record.documents);
-            if (refused !== null)
-                return refused;
-        }
-    }
-    else if (textChanged) {
-        const refused = yield* unreadable(record.documents, previous?.record.documents);
-        if (refused !== null)
-            return refused;
+const PROBES = new Set([
+    'then',
+    'toJSON',
+    'constructor',
+    'valueOf',
+    'toString',
+]);
+class UnreadPath extends Error {
+    constructor(path) {
+        super(`the replica slice holds no row for ${path}`);
     }
-    return { kind: 'staged', confirmed: yield* confirming(record, previous) };
-}
-export function readStaged(staged, previous) {
-    return stepped(staging(staged, previous));
-}
-function* reclassifying(record, previous) {
-    const verdict = yield* validateCollection(record.documents, Object.keys(record.binaries), compositionOf(record));
-    if (verdict.verdict !== 'refuse')
-        return { kind: 'staged', confirmed: yield* confirming(record, previous) };
-    return verdict.rule === 'model-unavailable'
-        ? { kind: 'deferred' }
-        : { kind: 'refused', refusal: verdict };
-}
-export function readReclassified(record, previous) {
-    return stepped(reclassifying(record, previous));
 }
-function* returnedBinaries(held, submitted, accepted) {
-    const binaries = drafted(held);
-    for (const change of submitted.changes) {
-        if (change.kind === 'arrival' && 'binary' in change) {
-            if (accepted.revisions[change.path] !== undefined)
-                binaries[change.path] = { state: 'accepted', ...change.binary };
-            continue;
+function strict(values, held) {
+    const guard = (property) => {
+        if (typeof property === 'string' && !held.has(property) && !PROBES.has(property)) {
+            throw new UnreadPath(property);
         }
-        if (change.kind !== 'move')
-            continue;
-        const moved = binaries[change.path];
-        if (moved === undefined || accepted.revisions[change.to] === undefined)
-            continue;
-        binaries[change.to] = moved;
-        delete binaries[change.path];
-    }
-    for (const [path, binary] of acceptedBinaries(accepted.binaryFiles ?? {})) {
-        binaries[path] = binary;
-        yield ROW_WEIGHT;
-    }
-    for (const path of accepted.removals) {
-        delete binaries[path];
-        yield ROW_WEIGHT;
-    }
-    return yield* settling(binaries);
+    };
+    return new Proxy(values, {
+        get(target, property, receiver) {
+            guard(property);
+            return Reflect.get(target, property, receiver);
+        },
+        has(target, property) {
+            guard(property);
+            return Reflect.has(target, property);
+        },
+        getOwnPropertyDescriptor(target, property) {
+            guard(property);
+            return Reflect.getOwnPropertyDescriptor(target, property);
+        },
+    });
 }
-function* returning(confirmed, submitted, accepted, roomVersion, writtenAt) {
-    const held = confirmed.record;
-    const documents = drafted(held.documents);
-    const revisions = drafted(held.revisions);
-    const fileIds = drafted(held.fileIds);
-    const changes = drafted(held.changes);
-    const written = drafted(held.written);
-    for (const [path, content] of entriesIn(accepted.documents)) {
-        documents[path] = content;
-        delete fileIds[path];
-        written[path] = writtenAt;
-        yield ROW_WEIGHT + content.length;
-    }
-    for (const [path, revision] of entriesIn(accepted.revisions)) {
-        revisions[path] = revision;
-        delete fileIds[path];
-        if (held.revisions[path] !== revision)
-            delete changes[path];
+export function* slicing(entries, paths) {
+    const held = new Set(paths);
+    for (const entry of entries)
+        held.add(entry.path);
+    const documents = {};
+    const binaries = {};
+    const revisions = {};
+    const fileIds = {};
+    const changes = {};
+    const written = {};
+    for (const entry of entries) {
+        if (entry.binary !== null)
+            binaries[entry.path] = entry.binary;
+        else if (entry.content !== null)
+            documents[entry.path] = entry.content;
+        if (entry.revision !== null)
+            revisions[entry.path] = entry.revision;
+        if (entry.fileId !== null)
+            fileIds[entry.path] = entry.fileId;
+        if (entry.change !== null)
+            changes[entry.path] = entry.change;
+        if (entry.written !== null)
+            written[entry.path] = entry.written;
         yield ROW_WEIGHT;
     }
-    for (const [path, fileId] of entriesIn(accepted.fileIds ?? {})) {
-        fileIds[path] = fileId;
-        yield ROW_WEIGHT;
-    }
-    for (const [path, change] of entriesIn(accepted.changes)) {
-        changes[path] = change;
-        yield ROW_WEIGHT;
-    }
-    for (const path of accepted.removals) {
-        delete documents[path];
-        delete revisions[path];
-        delete fileIds[path];
-        delete changes[path];
-        delete written[path];
+    return {
+        documents: strict(documents, held),
+        binaries: strict(binaries, held),
+        revisions: strict(revisions, held),
+        fileIds: strict(fileIds, held),
+        changes: strict(changes, held),
+        written: strict(written, held),
+        held,
+    };
+}
+export function entryAt(layer, path) {
+    const content = layer.documents[path];
+    const binary = layer.binaries[path];
+    if (content === undefined && binary === undefined)
+        return null;
+    return {
+        path,
+        content: content ?? null,
+        binary: binary ?? null,
+        revision: layer.revisions[path] ?? null,
+        fileId: layer.fileIds[path] ?? null,
+        change: layer.changes[path] ?? null,
+        written: layer.written?.[path] ?? null,
+    };
+}
+export function* slicingWith(slice, set, removed) {
+    const entries = new Map();
+    for (const path of slice.held) {
+        const entry = entryAt(slice, path);
+        if (entry !== null)
+            entries.set(path, { ...entry, type: null });
         yield ROW_WEIGHT;
     }
-    return yield* staging({
-        ...held,
-        roomVersion,
-        documents: yield* settling(documents),
-        revisions: yield* settling(revisions),
-        fileIds: yield* settling(fileIds),
-        changes: yield* settling(changes),
-        written: yield* settling(written),
-        binaries: yield* returnedBinaries(held.binaries, submitted, accepted),
-    }, confirmed);
+    for (const path of removed)
+        entries.delete(path);
+    for (const entry of set)
+        entries.set(entry.path, { ...entry, type: null });
+    return yield* slicing([...entries.values()], [...slice.held, ...set.map(({ path }) => path), ...removed]);
 }
-export function applyReturned(confirmed, submitted, accepted, roomVersion, writtenAt) {
-    return stepped(returning(confirmed, submitted, accepted, roomVersion, writtenAt));
+function changePaths(change) {
+    return change.kind === 'move' ? [change.path, change.to] : [change.path];
 }
-function* predicting(confirmed, batches, previous) {
-    const composition = compositionOf(confirmed.record);
-    const locator = confirmed.record.locator;
-    let layer = confirmed.record;
-    const replay = [];
-    const prior = new Map(previous?.replay.map((step) => [step.id, step]) ?? []);
-    for (const batch of batches) {
-        const before = layer;
-        const old = prior.get(batch.id);
-        const hasMove = rewriting(batch, locator);
-        const reuseRewrite = old?.collection !== undefined &&
-            (yield* sameText(before, old.before)) &&
-            old.collection.composition.model === composition.model &&
-            old.collection.composition.selection?.model === composition.selection?.model &&
-            JSON.stringify(old.collection.composition.selection?.roots) ===
-                JSON.stringify(composition.selection?.roots);
-        const collection = hasMove
-            ? reuseRewrite
-                ? old.collection
-                : yield* collecting(before.documents, composition, old?.collection ?? confirmed.collection)
-            : undefined;
-        const effective = collection === undefined
-            ? batch
-            : reuseRewrite
-                ? old.effective
-                : yield* effectiveIn(batch, locator, { ...before, collection });
-        layer =
-            old === undefined
-                ? yield* overlaying(before, [effective])
-                : yield* overlayChanged(before, effective, old.before, old.effective, old.after);
-        replay.push({
-            id: batch.id,
-            before,
-            after: layer,
-            effective,
-            ...(collection === undefined ? {} : { collection }),
-        });
+export function touchedBy(queue) {
+    const paths = new Set();
+    for (const batch of queue) {
+        for (const change of batch.changes)
+            for (const path of changePaths(change))
+                paths.add(path);
+        for (const precondition of batch.preconditions)
+            paths.add(precondition.path);
+        for (const move of batch.between?.moves ?? [])
+            paths.add(move.path);
     }
-    return { layer, replay };
+    return paths;
 }
-export function* replicating(confirmed, queue, previous) {
-    const batches = Object.freeze(queue.map(immutable));
-    if (batches.length === 0) {
-        return {
-            confirmed,
-            queue: batches,
-            visible: {
-                documents: confirmed.record.documents,
-                binaries: confirmed.record.binaries,
-                revisions: confirmed.record.revisions,
-                fileIds: confirmed.record.fileIds,
-                changes: confirmed.record.changes,
-                collection: confirmed.collection,
-            },
-            replay: [],
-        };
+export function movedBy(queue, locator) {
+    const paths = new Set();
+    for (const batch of queue) {
+        if (!rewriting(batch, locator))
+            continue;
+        for (const change of batch.changes)
+            if (change.kind === 'move')
+                paths.add(change.path);
+        if (batch.between?.source.room === locator) {
+            for (const move of batch.between.moves)
+                paths.add(move.path);
+        }
+    }
+    return paths;
+}
+export function* replaying(confirmed, queue, locator, composition) {
+    let layer = confirmed;
+    const touched = new Set();
+    for (const batch of queue) {
+        const effective = rewriting(batch, locator)
+            ? yield* effectiveIn(batch, locator, {
+                ...layer,
+                collection: collectionOf(layer.documents, composition),
+            })
+            : batch;
+        for (const change of effective.changes)
+            for (const path of changePaths(change))
+                touched.add(path);
+        layer = yield* overlaying(layer, [effective]);
+        yield ROW_WEIGHT;
     }
-    const { layer, replay } = yield* predicting(confirmed, batches, previous);
     return {
-        confirmed,
-        queue: batches,
-        replay,
-        visible: {
-            ...layer,
-            collection: yield* collecting(layer.documents, compositionOf(confirmed.record), previous?.visible.collection ?? confirmed.collection),
-        },
+        visible: { ...layer, collection: collectionOf(layer.documents, composition) },
+        touched,
     };
 }
+export function* overlayOf(visible, touched) {
+    const rows = [];
+    for (const path of touched) {
+        yield ROW_WEIGHT;
+        const entry = entryAt(visible, path);
+        rows.push(entry === null
+            ? {
+                path,
+                present: false,
+                content: null,
+                binary: null,
+                revision: null,
+                fileId: null,
+                change: null,
+                written: null,
+            }
+            : { ...entry, written: null, present: true });
+    }
+    return rows;
+}
 function present(layer, path) {
     return layer.documents[path] !== undefined || layer.binaries[path] !== undefined;
 }
-function holds(layer, preconditions) {
+export function holds(layer, preconditions) {
     const parsed = new Map();
     const documentAt = (path) => {
         if (!parsed.has(path)) {
@@ -306,10 +262,14 @@ function effects(change) {
     return [{ kind: 'absent', path }];
 }
 export function landed(batch, confirmed, current = {}) {
-    const layer = {
-        ...confirmed.record,
-        documents: patched(confirmed.record.documents, Object.entries(current)),
-    };
+    const documents = new Proxy(confirmed.documents, {
+        get(target, property, receiver) {
+            if (typeof property === 'string' && Object.hasOwn(current, property))
+                return current[property];
+            return Reflect.get(target, property, receiver);
+        },
+    });
+    const layer = { ...confirmed, documents };
     return batch.changes.every((change, index) => {
         if (change.kind === 'replace' || (change.kind === 'create' && 'content' in change)) {
             const at = landing(batch.changes, index, change.path);
@@ -341,11 +301,10 @@ function founded(batch, layer) {
     });
     return changed ? immutable({ ...batch, preconditions }) : batch;
 }
-export function* standing(confirmed, queue, withdrawable, local) {
+export function* standing(confirmed, queue, withdrawable, local, locator, composition) {
     if (!queue.some(withdrawable))
         return { withdrawn: [], kept: queue };
-    const composition = compositionOf(confirmed.record);
-    let layer = confirmed.record;
+    let layer = confirmed;
     const withdrawn = [];
     const kept = [];
     for (const batch of queue) {
@@ -353,10 +312,10 @@ export function* standing(confirmed, queue, withdrawable, local) {
             withdrawn.push(batch);
             continue;
         }
-        const effective = rewriting(batch, confirmed.record.locator)
-            ? yield* effectiveIn(batch, confirmed.record.locator, {
+        const effective = rewriting(batch, locator)
+            ? yield* effectiveIn(batch, locator, {
                 ...layer,
-                collection: yield* collecting(layer.documents, composition),
+                collection: collectionOf(layer.documents, composition),
             })
             : batch;
         let unapplied = false;
@@ -372,3 +331,103 @@ export function* standing(confirmed, queue, withdrawable, local) {
     }
     return { withdrawn, kept };
 }
+export function returnedPaths(submitted, accepted) {
+    const paths = new Set([
+        ...Object.keys(accepted.documents),
+        ...Object.keys(accepted.revisions),
+        ...Object.keys(accepted.fileIds ?? {}),
+        ...Object.keys(accepted.changes),
+        ...Object.keys(accepted.binaryFiles ?? {}),
+        ...accepted.removals,
+    ]);
+    for (const change of submitted.changes) {
+        if (change.kind === 'move') {
+            paths.add(change.path);
+            paths.add(change.to);
+        }
+        if (change.kind === 'arrival')
+            paths.add(change.path);
+    }
+    return paths;
+}
+export function* returning(confirmed, submitted, accepted, writtenAt) {
+    const documents = new Map();
+    const binaries = new Map();
+    const revisions = new Map();
+    const fileIds = new Map();
+    const changes = new Map();
+    const written = new Map();
+    const read = (changed, held, path) => (changed.has(path) ? changed.get(path) : held[path]);
+    for (const [path, content] of Object.entries(accepted.documents)) {
+        yield ROW_WEIGHT;
+        documents.set(path, content);
+        fileIds.set(path, undefined);
+        written.set(path, writtenAt);
+    }
+    for (const [path, revision] of Object.entries(accepted.revisions)) {
+        yield ROW_WEIGHT;
+        revisions.set(path, revision);
+        fileIds.set(path, undefined);
+        if (confirmed.revisions[path] !== revision)
+            changes.set(path, undefined);
+    }
+    for (const [path, fileId] of Object.entries(accepted.fileIds ?? {}))
+        fileIds.set(path, fileId);
+    for (const [path, change] of Object.entries(accepted.changes))
+        changes.set(path, change);
+    for (const path of accepted.removals) {
+        documents.set(path, undefined);
+        revisions.set(path, undefined);
+        fileIds.set(path, undefined);
+        changes.set(path, undefined);
+        written.set(path, undefined);
+    }
+    for (const change of submitted.changes) {
+        if (change.kind === 'arrival' && 'binary' in change) {
+            if (accepted.revisions[change.path] !== undefined) {
+                binaries.set(change.path, { state: 'accepted', ...change.binary });
+            }
+            continue;
+        }
+        if (change.kind !== 'move')
+            continue;
+        const moved = read(binaries, confirmed.binaries, change.path);
+        if (moved === undefined || accepted.revisions[change.to] === undefined)
+            continue;
+        binaries.set(change.to, moved);
+        binaries.set(change.path, undefined);
+    }
+    for (const [path, binary] of acceptedBinaries(accepted.binaryFiles ?? {}))
+        binaries.set(path, binary);
+    for (const path of accepted.removals)
+        binaries.set(path, undefined);
+    const paths = new Set([
+        ...documents.keys(),
+        ...binaries.keys(),
+        ...revisions.keys(),
+        ...fileIds.keys(),
+        ...changes.keys(),
+        ...written.keys(),
+    ]);
+    const set = [];
+    const removed = [];
+    for (const path of paths) {
+        yield ROW_WEIGHT;
+        const content = read(documents, confirmed.documents, path);
+        const binary = read(binaries, confirmed.binaries, path);
+        if (content === undefined && binary === undefined) {
+            removed.push(path);
+            continue;
+        }
+        set.push({
+            path,
+            content: binary === undefined ? (content ?? null) : null,
+            binary: binary ?? null,
+            revision: read(revisions, confirmed.revisions, path) ?? null,
+            fileId: read(fileIds, confirmed.fileIds, path) ?? null,
+            change: read(changes, confirmed.changes, path) ?? null,
+            written: read(written, confirmed.written, path) ?? null,
+        });
+    }
+    return { set, removed };
+}

package/dist/rows.d.ts

@@ -1,39 +1,37 @@
-import { type Frontmatter } from '@agentshouse/mdmodel';
-import type { HeadChange } from './adapter.js';
-import type { BinaryFileRecord } from './binary.js';
 import { type Composition } from './collection.js';
-type Fields = Readonly<Record<string, unknown>>;
-export type DocumentRow = {
-    key: string;
-    kind: 'document';
-    room: string;
-    path: string;
-    type: string | null;
-    fields: Fields;
-    values: Fields;
-    reached: Readonly<Record<string, readonly unknown[]>>;
-    directories: readonly string[];
-    folder: string;
-    text: string | null;
-    change: HeadChange | null;
-    fileId: string | null;
-    binary: BinaryFileRecord | null;
+export type ValueKind = 'string' | 'number' | 'boolean' | 'null' | 'array' | 'object' | 'undefined';
+type HeldValue = {
+    readonly form: string;
+    readonly held: number;
+    readonly item: number;
+    readonly kind: ValueKind;
+    readonly value: string | number | null;
+    readonly size: number | null;
+    readonly single: boolean;
 };
-export type ReferenceRow = {
-    key: string;
-    kind: 'reference';
-    room: string;
-    source: string;
-    target: string;
-    field: string;
-    forms: readonly string[];
-    path: string;
-    type: string;
+type LinkKind = 'field' | 'section' | 'body';
+type HeldLink = {
+    readonly kind: LinkKind;
+    readonly form: string;
+    readonly target: string;
+    readonly field: string;
+};
+export type Derived = {
+    readonly type: string | null;
+    readonly declared: string | null;
+    readonly queried: boolean;
+    readonly folder: string;
+    readonly fields: string | null;
+    readonly values: readonly HeldValue[];
+    readonly links: readonly HeldLink[];
 };
-export type Row = DocumentRow | ReferenceRow;
 export declare function documentKey(room: string, path: string): string;
 export declare function roomOfKey(key: string): string;
+export declare function pathOfKey(key: string): string;
 export declare function markdownPath(path: string): boolean;
-export declare function rowsOf(room: string, path: string, document: Frontmatter | null, composition: Composition, change: HeadChange | null, fileId: string | null, binary: BinaryFileRecord | null): readonly Row[];
+export declare function settingsTextPath(path: string): boolean;
+export declare function folderOf(path: string): string;
+export declare function kindOf(value: unknown): ValueKind;
+export declare function derived(path: string, content: string | null, composition: Composition): Derived;
 export {};
 //# sourceMappingURL=rows.d.ts.map

package/dist/rows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rows.d.ts","sourceRoot":"","sources":["../src/rows.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,WAAW,EACjB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAa,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAG9D,KAAK,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAEhD,MAAM,MAAM,WAAW,GAAG;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC,CAAC,CAAC;IACtD,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC;IAC1B,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,GAAG,GAAG,WAAW,GAAG,YAAY,CAAC;AAM7C,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE7C;AAuFD,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElD;AAED,wBAAgB,MAAM,CACpB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,WAAW,GAAG,IAAI,EAC5B,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,UAAU,GAAG,IAAI,EACzB,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,MAAM,EAAE,gBAAgB,GAAG,IAAI,GAC9B,SAAS,GAAG,EAAE,CAmEhB"}
+{"version":3,"file":"rows.d.ts","sourceRoot":"","sources":["../src/rows.ts"],"names":[],"mappings":"AAWA,OAAO,EAAa,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAG9D,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,WAAW,CAAC;AAEpG,KAAK,SAAS,GAAG;IACf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,KAAK,QAAQ,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAE7C,KAAK,QAAQ,GAAG;IACd,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAC;CACrC,CAAC;AAMF,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7C;AAqBD,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,CAMhD;AA2ID,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,EAAE,WAAW,EAAE,WAAW,GAAG,OAAO,CAmB/F"}