aontu 0.52.1 → 0.54.0

package/dist/patch.js

@@ -0,0 +1,506 @@
+"use strict";
+/* Copyright (c) 2025 Richard Rodger, MIT License */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAssignment = parseAssignment;
+exports.overlayLine = overlayLine;
+exports.offsetAt = offsetAt;
+exports.spanAt = spanAt;
+exports.spanHolds = spanHolds;
+exports.verifiedSite = verifiedSite;
+exports.spanValue = spanValue;
+exports.patch = patch;
+// OVERLAY PATCH (G7 phase 5,
+// docs/capability-review/g7-machine-access.md): change a document by
+// APPENDING to an overlay, not by rewriting the file.
+//
+// This is the stage that needs no rewriter. An overlay entry is just
+// another conjunct, and unification is order-independent, so appending
+// `services: auth: owner: "identity-2"` to a second file and
+// evaluating both is exactly the same value as writing it into the
+// first — with no parsing of the target, no comment or layout damage,
+// and nothing to preserve. The spec pins that equivalence rather than
+// asserting it.
+//
+// What an overlay CANNOT do is change a PINNED value: the lattice
+// refuses 5 against 3, and the report says so with the pinning site,
+// which `why` then locates. That left the loop "set → conflict → why →
+// edit the pinning site" with its last step manual — and since the
+// commonest vet failure of all is "the data pins the wrong value",
+// `set` was unable to repair the very case it existed for.
+//
+// IN-PLACE REPLACE (`--in-place`) closes that. The G7 design deferred
+// it behind two prerequisites: an evaluated-path → contributing-span
+// map, and a comment-and-layout-preserving CST. The first now exists —
+// `why` is that map, and sites carry `len` and `src` since a site was
+// given an extent. The second turns out NOT to be needed for the case
+// that matters, and the reason is worth stating: a CST is what you need
+// to RE-SERIALISE a document, and a targeted span splice serialises
+// nothing. It replaces `len` code units at one offset and leaves every
+// other byte — every comment, every blank line, every alignment space —
+// exactly as the author left it, because it never looks at them.
+//
+// What makes the splice safe rather than merely plausible is that the
+// site carries `src`, the text it claims to cover. The span is VERIFIED
+// against it before a byte is written, so the corrupting arithmetic
+// this repository has already shipped once — `port: 0x1F` reporting
+// canon `"31"` at column 7, and `(col, canon.length)` writing
+// `port: 5x1F` — cannot be reached: `0x1F` is four code units and says
+// so, and if the text at the span is anything else the edit is refused
+// rather than guessed.
+//
+// Replace is never WORSE than append. Where the value is not a single
+// editable literal in this overlay — a spread template governing other
+// keys, a reference whose site is the `$` and not the target, two
+// statements pinning the same path, a literal in an included file — the
+// splice is refused and the assignment is APPENDED exactly as it would
+// have been without the flag, plus one `warning` finding naming the
+// case and the site it came from. Warnings never move a verdict, so
+// `--in-place` cannot turn a run that would have succeeded into one
+// that fails; it can only rewrite where rewriting is safe, and explain
+// itself where it is not.
+//
+// The verdict is G2's, unchanged: `vet(entry, overlay)` already asks
+// exactly the right question — does this document hold against that
+// truth, and if not, where — so `set` adds a writer, not a report.
+const vet_1 = require("./vet");
+const query_1 = require("./query");
+const aontu_1 = require("./aontu");
+// An assignment is `<path>=<value>`, split at the FIRST `=`: a path
+// segment is a name, and the value is arbitrary Aontu source, which
+// may itself contain `=` (`a: min(1)` does not, but a string can).
+function parseAssignment(text) {
+    const eq = text.indexOf('=');
+    if (eq < 1) {
+        return undefined;
+    }
+    const path = text.slice(0, eq).trim();
+    const value = text.slice(eq + 1).trim();
+    if ('' === value || 0 === (0, query_1.pathParts)(path).length) {
+        return undefined;
+    }
+    return { path, value };
+}
+// The path-flattened conjunct one assignment becomes:
+// `$.a.b = 1` is `"a": "b": 1`. Keys are QUOTED — a segment may be a
+// word the grammar spells otherwise (`if`), a number, or a name with
+// a space in it, and quoting one key is the same value as writing it
+// bare.
+function overlayLine(path, value) {
+    return (0, query_1.pathParts)(path).map((p) => JSON.stringify(p)).join(': ') +
+        ': ' + value;
+}
+// The character offset of a 1-based (row, col) in `src`, or -1 when the
+// text has no such position. Columns are UTF-16 code units, which is
+// what a site carries and what a JavaScript string index already is —
+// so this is the inverse of the site arithmetic, not a reinterpretation
+// of it (go/patch.go converts to a byte offset, because Go strings are
+// bytes; both address the same character).
+function offsetAt(src, row, col) {
+    if (row < 1 || col < 1) {
+        return -1;
+    }
+    let off = 0;
+    for (let r = 1; r < row; r++) {
+        const nl = src.indexOf('\n', off);
+        if (nl < 0) {
+            return -1;
+        }
+        off = nl + 1;
+    }
+    const at = off + (col - 1);
+    return at <= src.length ? at : -1;
+}
+// The text a site covers, or undefined when the site does not describe
+// a position in this text at all.
+function spanAt(src, site) {
+    const off = offsetAt(src, site.row, site.col);
+    return off < 0 ? undefined : src.slice(off, off + site.len);
+}
+// DOES THE TEXT AT THIS SITE SAY WHAT THE SITE CLAIMS IT SAYS?
+//
+// The last check before a splice, and the one that makes the write
+// PROVABLE rather than argued. Exported so it can be exercised with a
+// site the engine would never produce — an out-of-range position, a
+// span over different text — which is the only way to test a guard whose
+// whole purpose is to catch a state the rest of the code says cannot
+// happen. (go/patch.go has the twin, tested the same way.)
+function spanHolds(src, site, expect) {
+    // THE SITE'S OWN LENGTH IS PART OF ITS CLAIM, and is checked before
+    // the text is. A site whose `len` disagrees with the text it says it
+    // covers CONTRADICTS ITSELF, which is exactly the state this guard
+    // exists to catch — and a zero-length span would otherwise compare
+    // equal against nothing and then splice nothing, INSERTING the new
+    // value rather than replacing anything.
+    //
+    // Both ports compare in UTF-16 code units, which is what a site's
+    // `len` counts. That is free here and is not in Go, where a string is
+    // bytes (go/patch.go converts).
+    if ('' === expect || site.len !== expect.length) {
+        return false;
+    }
+    return spanAt(src, site) === expect;
+}
+// WHY IS THE VALUE AT THIS PATH WHAT IT IS, and is exactly one of the
+// answers a literal this overlay can edit in place?
+//
+// The four refusals below are not defensive padding; each is a real
+// document shape that the probe corpus produced, and each would corrupt
+// something different if the splice ran anyway:
+//
+//   - a SPREAD contribution's site is inside the template, which
+//     governs every other key too, so rewriting it there changes keys
+//     the author did not name;
+//   - a REFERENCE's site is the `$` that starts the path and has length
+//     1, so splicing over it writes the new value INTO the path
+//     expression (`$.base` becomes `5.base`) — and the value the author
+//     wants changed lives at the target anyway;
+//   - TWO literals at one path (a duplicate key, two files merged) give
+//     no single place to edit, and picking either silently is picking
+//     for the author;
+//   - a literal in an INCLUDED file is editable, but not by
+//     `--overlay <this file>`: the write would land in a document the
+//     caller did not name.
+//
+// A PREFERENCE is not refused here for the same reason it is not
+// replaced: appending already overrides a default correctly, so the
+// caller loses nothing by falling through to it.
+function editableLiteral(overlaySrc, path, overlayPath) {
+    // THE AUTHORITY IS THE OVERLAY TEXT ALONE, WITH INCLUDES DENIED.
+    //
+    // The splice happens in the text this function was handed, so what it
+    // has to establish is that the contribution is IN that text — and the
+    // site's `file` cannot establish it. Two ways it fails: a caller of
+    // the library API need not pass `overlayPath`, leaving nothing to
+    // compare against; and the Go port names the ENTRY document for an
+    // included value anyway (issue #66), so the comparison is the overlay
+    // against itself. Either way an included literal's (row, col, len,
+    // src) can COINCIDE with different text at the same coordinates here
+    // — an include holding `a: 42` at 1:4 and an overlay holding `x: 42`
+    // at 1:4 — and the span verification cannot tell them apart, because
+    // the text really does match. The splice then rewrites `x` while
+    // reporting a replacement of `$.a`, in both ports.
+    //
+    // Denying includes removes the ambiguity at its source rather than
+    // detecting it: what resolves is what this text says by itself. An
+    // overlay that loads other documents therefore cannot be edited in
+    // place at all — the conservative answer, and the assignment still
+    // appends. It costs nothing in the shape `set` is for, an overlay it
+    // owns and appends to, and it does not depend on file attribution, so
+    // both ports agree without waiting on #66.
+    const alone = (0, query_1.why)(overlaySrc, path, {
+        trust: { include: 'none' },
+        ...(null == overlayPath ? {} : { path: overlayPath }),
+    });
+    if (true !== alone.ok || null == alone.record) {
+        // Nothing here BY ITSELF. Two very different reasons, and they earn
+        // different answers: the path may simply not be in this overlay, in
+        // which case appending is the whole of the answer and nothing has
+        // gone wrong — or it may be here only because something was loaded,
+        // which is the case above and has to say so.
+        const withLoads = (0, query_1.why)(overlaySrc, path, null == overlayPath ? undefined : { path: overlayPath });
+        if (true !== withLoads.ok || null == withLoads.record) {
+            return { site: undefined, finding: undefined };
+        }
+        return {
+            site: undefined,
+            finding: notEditable('patch_not_editable', path, 'this path resolves only once the overlay loads another ' +
+                'document, so no literal here can be shown to be the one to ' +
+                'edit; run set with the document that writes it as the overlay', withLoads.record.conjuncts),
+        };
+    }
+    const record = alone.record;
+    // No `?? []`: WhyRecord.conjuncts is a non-optional array and the
+    // record's own presence was just established, so a fallback here
+    // would claim a possibility the type does not have — and the
+    // coverage gate says so, an arm nothing can take.
+    const conjuncts = record.conjuncts;
+    // A VALUE REACHED THROUGH A REFERENCE IS NOT THIS PATH'S TO EDIT.
+    // Provenance travels through clones now, so `n: $.base` against
+    // `base: 7` reports the literal `7` -- correctly, and at the site
+    // where it was written, which is `base`'s line and not `n`'s. A
+    // splice there would rewrite the REFERENT: every other reader of
+    // `$.base` changes with it, and the path the caller named does not
+    // move at all. The reference is what stands here, so the reference
+    // is what has to be edited, wherever it points.
+    const refs = conjuncts.filter((c) => 'ref' === c.role);
+    if (0 < refs.length) {
+        return {
+            site: undefined,
+            finding: notEditable('patch_not_editable', path, 'the value here is reached through a reference (ref), so the ' +
+                'literal below belongs to the path it points at; edit where it ' +
+                'comes from', refs),
+        };
+    }
+    const literals = conjuncts.filter((c) => 'literal' === c.role);
+    if (1 < literals.length) {
+        return {
+            site: undefined,
+            finding: notEditable('patch_ambiguous', path, 'two or more statements pin this path, so there is no single ' +
+                'place to edit; the sites below are all of them', literals),
+        };
+    }
+    // Only indirect contributions. A pref is the benign case — append
+    // overrides a default — so it earns no finding; the others do.
+    if (0 === literals.length) {
+        const indirect = conjuncts.filter((c) => 'pref' !== c.role);
+        if (0 === indirect.length) {
+            return { site: undefined, finding: undefined };
+        }
+        return {
+            site: undefined,
+            finding: notEditable('patch_not_editable', path, 'the value here is not written as a literal (' +
+                indirect.map((c) => c.role).join(', ') +
+                '), so there is no literal to rewrite; edit where it comes from', indirect),
+        };
+    }
+    return verifiedSite(overlaySrc, path, literals[0]);
+}
+// THE SPAN MUST CHECK OUT before anything splices. The refusal arm is
+// unreachable through `patch` since ADR-018: the pipe (`x: hello |>
+// upper`) was the one spelling that synthesised a contribution the
+// parser never sited, and denying includes means every WRITTEN
+// contribution's coordinates describe this text by construction. The
+// verification is kept rather than deleted — splicing without it would
+// corrupt the file (a contribution with no `src` would splice ZERO
+// characters, INSERTING the new value into the middle of a line) — and
+// this last step is its own exported seam so the refusal can be tested
+// directly, against conjuncts the engine would never produce, on the
+// same footing as `spanHolds` itself.
+function verifiedSite(overlaySrc, path, one) {
+    if (!spanHolds(overlaySrc, one.site, one.src)) {
+        const finding = notEditable('patch_span_mismatch', path, 'the overlay does not hold ' + JSON.stringify(one.src) + ' at ' +
+            one.site.row + ':' + one.site.col + ' (len ' + one.site.len +
+            '), so the span cannot be verified before writing', [one]);
+        // The one internal-class refusal: a recorded span failing to check
+        // out is the engine's fault, never the document's.
+        finding.class = 'internal';
+        return { site: undefined, finding };
+    }
+    // DOES THE SPAN MEAN THE WHOLE CONTRIBUTION?
+    //
+    // This is the check that `role === 'literal'` looks like it makes and
+    // does not. A site names the TOKEN it points at, so a COMPOUND value
+    // reports its OPENING token while its canon is the whole thing:
+    // `min(1)` is a literal-role contribution whose src is `min`, `1+2`
+    // reports `1`, `$.k+1` reports `$`, `{b:1}` reports `{` and `[1,2]`
+    // reports `[`. Splicing over any of those writes the new value INTO
+    // the expression — `a: 5(1)`, `a: 5+2`, `a: 5.k+1` — which is the
+    // same class of corruption as the canon-length arithmetic, reached by
+    // a different route.
+    //
+    // Rather than enumerate the shapes (a list is a thing to be
+    // incomplete about), ASK THE ENGINE: parse `src` on its own and
+    // require the value it means to be the value the contribution
+    // contributed. That is exactly the property a splice needs — this
+    // text, alone, is this value — and it is decided by the same unifier
+    // that produced the contribution, so it cannot drift from it.
+    //
+    // It also gets the interesting case right without special-casing it:
+    // `0x1F` canons to `31`, which is not its own spelling, but IS the
+    // contribution's canon, so a hex literal is editable while `min` is
+    // not.
+    const span = spanValue(one.src);
+    if (null == span || span.canon !== one.canon) {
+        return {
+            site: undefined,
+            finding: notEditable('patch_not_editable', path, 'the site names ' + JSON.stringify(one.src) + ', which is the ' +
+                'opening token of ' + one.canon + ' rather than the whole of ' +
+                'it; rewriting that span would edit the expression, not the ' +
+                'value', [one]),
+        };
+    }
+    // AN ABSTRACT CONTRIBUTION IS NOT A PIN. `a: integer` and
+    // `a: above(0)` state a constraint, and appending already narrows
+    // them — that is the one case the status report notes `set` could
+    // always repair. Replacing them would silently DISCARD a constraint
+    // the author wrote, to no benefit, so this falls through to append.
+    if (true !== span.concrete) {
+        return {
+            site: undefined,
+            finding: notEditable('patch_not_editable', path, one.canon + ' is a constraint here, not a pinned value; ' +
+                'appending narrows it without discarding what it says', [one]),
+        };
+    }
+    return {
+        site: {
+            col: one.site.col,
+            file: one.site.file,
+            from: one.src,
+            path,
+            row: one.site.row,
+            to: '',
+        },
+        finding: undefined,
+    };
+}
+// What does this source text mean ON ITS OWN, and is it a value rather
+// than a constraint? Undefined when it does not stand alone at all
+// (`$` from a path, an unbalanced `{`).
+//
+// The wrapper key is arbitrary and the document it makes is thrown
+// away; what is wanted is the unifier's own reading of the fragment.
+function spanValue(src) {
+    // NO COLLECTING CONTEXT: `unify` THROWS on a source it cannot read,
+    // so a ctx.err check here is a branch nothing can reach — the catch
+    // below is the only path a bad fragment takes. (A first draft had
+    // both, and the coverage gate called the pair what it was.) What the
+    // nil test still earns is the fragment that PARSES and means nothing:
+    // `$` is a path with no target, and answers a nil rather than
+    // throwing.
+    let canon;
+    try {
+        const root = new aontu_1.Aontu().unify('v: ' + src);
+        const node = root?.peg?.['v'];
+        if (null == node || true === node.isNil) {
+            return undefined;
+        }
+        canon = node.canon;
+    }
+    catch (e) {
+        return undefined;
+    }
+    // Generability is the concreteness test, and it is the engine's own:
+    // a kind, a constraint and an unresolved disjunction all refuse to
+    // generate, which is precisely the line this needs drawn.
+    try {
+        new aontu_1.Aontu().generate('v: ' + src);
+    }
+    catch (e) {
+        return { canon, concrete: false };
+    }
+    return { canon, concrete: true };
+}
+// A refusal to replace, as a WARNING: the assignment still appends, so
+// nothing about the run got worse and the verdict must not move
+// (ts/src/vet.ts, "warnings never touch the verdict"). What the finding
+// adds is the reason, which is the whole value of asking for --in-place
+// over plain set.
+function notEditable(code, path, why, from) {
+    return {
+        code,
+        // Always `reference`; the one internal-class refusal
+        // (patch_span_mismatch) overrides at its call site.
+        class: 'reference',
+        severity: 'warning',
+        path,
+        // No separate `note`: the renderer prints both, and a note that
+        // restates its own message is noise wearing a second label.
+        message: 'cannot rewrite ' + path + ' in place: ' + why,
+        sites: from.map((c) => ({
+            file: c.site.file,
+            row: c.site.row,
+            col: c.site.col,
+            len: c.site.len,
+            src: c.src,
+            role: 'data',
+            value: c.canon,
+        })),
+    };
+}
+// Append the assignments to the overlay and answer what the result
+// holds. The report's verdict is the vet verdict of the ENTRY against
+// the new overlay: `valid` when it holds and is concrete, `incomplete`
+// when nothing contradicts but the truth is not yet satisfied,
+// `invalid` when the overlay contradicts a pinned value, `error` when
+// the entry itself does not stand up.
+function patch(entrySrc, overlaySrc, assignments, opts) {
+    const options = opts ?? {};
+    const appended = [];
+    const replaced = [];
+    const notes = [];
+    // Each pending edit as (offset, length, text). Collected first and
+    // applied last, back to front: a splice shifts every offset after it,
+    // and recomputing them per edit is a way to be subtly wrong for free.
+    const edits = [];
+    for (const text of assignments) {
+        const a = parseAssignment(text);
+        if (null == a) {
+            return {
+                overlay: overlaySrc,
+                appended: [],
+                replaced: [],
+                verdict: 'error',
+                findings: [{
+                        code: 'patch_assignment',
+                        class: 'parse',
+                        severity: 'error',
+                        path: '$',
+                        message: `Not a <path>=<value> assignment: ${text}`,
+                        sites: [],
+                    }],
+            };
+        }
+        if (true === options.inPlace) {
+            const found = editableLiteral(overlaySrc, a.path, options.overlayPath);
+            if (null != found.finding) {
+                notes.push(found.finding);
+            }
+            if (null != found.site) {
+                // Two assignments naming the same path would splice the same
+                // span twice. The second is the one the author wrote last, so
+                // it wins — and the first is dropped rather than layered.
+                const at = offsetAt(overlaySrc, found.site.row, found.site.col);
+                const dup = edits.findIndex((e) => e.at === at);
+                const edit = { at, len: found.site.from.length, to: a.value };
+                if (dup < 0) {
+                    edits.push(edit);
+                    replaced.push({ ...found.site, to: a.value });
+                }
+                else {
+                    edits[dup] = edit;
+                    replaced[dup] = { ...found.site, to: a.value };
+                }
+                continue;
+            }
+        }
+        appended.push(overlayLine(a.path, a.value));
+    }
+    const overlay = joinOverlay(applyEdits(overlaySrc, edits), appended);
+    // The file names ride as URLs as well as base paths, so a finding
+    // names the entry and the overlay rather than vet's generic
+    // `schema`/`data` labels — with two documents that both belong to
+    // the caller, "which file" is the whole question.
+    const report = (0, vet_1.vet)(entrySrc, overlay, {
+        trust: options.trust,
+        schemaPath: options.entryPath,
+        dataPath: options.overlayPath,
+        schemaUrl: options.entryPath,
+        dataUrl: options.overlayPath,
+    });
+    return {
+        overlay,
+        appended,
+        replaced,
+        verdict: report.verdict,
+        // The refusals come FIRST: they explain why the run took the shape
+        // it did, and a reader who stops after the first finding should
+        // read that rather than a conflict it predicted.
+        findings: notes.concat(report.findings),
+    };
+}
+// Apply the collected splices back to front, so an earlier edit's
+// offset is never invalidated by a later one having already run.
+function applyEdits(src, edits) {
+    if (0 === edits.length) {
+        return src;
+    }
+    let out = src;
+    for (const e of [...edits].sort((x, y) => y.at - x.at)) {
+        out = out.slice(0, e.at) + e.to + out.slice(e.at + e.len);
+    }
+    return out;
+}
+// One line per assignment, after whatever the overlay already said. A
+// trailing newline is kept when the file had one and added when it
+// did not: a file that does not end in a newline is still a file, and
+// appending to it must not join two entries into one line.
+function joinOverlay(overlaySrc, appended) {
+    if (0 === appended.length) {
+        return overlaySrc;
+    }
+    const head = '' === overlaySrc || overlaySrc.endsWith('\n')
+        ? overlaySrc
+        : overlaySrc + '\n';
+    return head + appended.join('\n') + '\n';
+}
+//# sourceMappingURL=patch.js.map

package/dist/patch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"patch.js","sourceRoot":"","sources":["../src/patch.ts"],"names":[],"mappings":";AAAA,oDAAoD;;;;;;;;;;AAEpD,6BAA6B;AAC7B,qEAAqE;AACrE,sDAAsD;AACtD,EAAE;AACF,qEAAqE;AACrE,uEAAuE;AACvE,6DAA6D;AAC7D,mEAAmE;AACnE,sEAAsE;AACtE,sEAAsE;AACtE,gBAAgB;AAChB,EAAE;AACF,kEAAkE;AAClE,qEAAqE;AACrE,uEAAuE;AACvE,mEAAmE;AACnE,mEAAmE;AACnE,2DAA2D;AAC3D,EAAE;AACF,sEAAsE;AACtE,qEAAqE;AACrE,uEAAuE;AACvE,sEAAsE;AACtE,sEAAsE;AACtE,wEAAwE;AACxE,oEAAoE;AACpE,uEAAuE;AACvE,wEAAwE;AACxE,iEAAiE;AACjE,EAAE;AACF,sEAAsE;AACtE,wEAAwE;AACxE,oEAAoE;AACpE,oEAAoE;AACpE,8DAA8D;AAC9D,uEAAuE;AACvE,uEAAuE;AACvE,uBAAuB;AACvB,EAAE;AACF,sEAAsE;AACtE,uEAAuE;AACvE,kEAAkE;AAClE,wEAAwE;AACxE,uEAAuE;AACvE,oEAAoE;AACpE,oEAAoE;AACpE,oEAAoE;AACpE,uEAAuE;AACvE,0BAA0B;AAC1B,EAAE;AACF,qEAAqE;AACrE,oEAAoE;AACpE,mEAAmE;AAEnE,+BAA2B;AAG3B,mCAAwC;AAExC,mCAA+B;AAkD/B,oEAAoE;AACpE,oEAAoE;AACpE,mEAAmE;AACnE,yBACE,IAAY;IACZ,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;IAC5B,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC;QACX,OAAO,SAAS,CAAA;IAClB,CAAC;IACD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAA;IACrC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,CAAA;IACvC,IAAI,EAAE,KAAK,KAAK,IAAI,CAAC,KAAK,IAAA,iBAAS,EAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC;QACjD,OAAO,SAAS,CAAA;IAClB,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,CAAA;AACxB,CAAC;AAGD,sDAAsD;AACtD,qEAAqE;AACrE,qEAAqE;AACrE,qEAAqE;AACrE,QAAQ;AACR,qBAA4B,IAAY,EAAE,KAAa;IACrD,OAAO,IAAA,iBAAS,EAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;QAC7D,IAAI,GAAG,KAAK,CAAA;AAChB,CAAC;AAGD,wEAAwE;AACxE,qEAAqE;AACrE,sEAAsE;AACtE,wEAAwE;AACxE,uEAAuE;AACvE,2CAA2C;AAC3C,kBAAyB,GAAW,EAAE,GAAW,EAAE,GAAW;IAC5D,IAAI,GAAG,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,EAAE,CAAC;QACvB,OAAO,CAAC,CAAC,CAAA;IACX,CAAC;IACD,IAAI,GAAG,GAAG,CAAC,CAAA;IACX,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;QAC7B,MAAM,EAAE,GAAG,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;QACjC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC;YACX,OAAO,CAAC,CAAC,CAAA;QACX,CAAC;QACD,GAAG,GAAG,EAAE,GAAG,CAAC,CAAA;IACd,CAAC;IACD,MAAM,EAAE,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,CAAA;IAC1B,OAAO,EAAE,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;AACnC,CAAC;AAGD,uEAAuE;AACvE,kCAAkC;AAClC,gBACE,GAAW,EAAE,IAA+C;IAE5D,MAAM,GAAG,GAAG,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,CAAA;IAC7C,OAAO,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAA;AAC7D,CAAC;AAGD,+DAA+D;AAC/D,EAAE;AACF,mEAAmE;AACnE,sEAAsE;AACtE,oEAAoE;AACpE,yEAAyE;AACzE,qEAAqE;AACrE,2DAA2D;AAC3D,mBACE,GAAW,EAAE,IAA+C,EAAE,MAAc;IAE5E,oEAAoE;IACpE,qEAAqE;IACrE,mEAAmE;IACnE,mEAAmE;IACnE,mEAAmE;IACnE,wCAAwC;IACxC,EAAE;IACF,kEAAkE;IAClE,sEAAsE;IACtE,gCAAgC;IAChC,IAAI,EAAE,KAAK,MAAM,IAAI,IAAI,CAAC,GAAG,KAAK,MAAM,CAAC,MAAM,EAAE,CAAC;QAChD,OAAO,KAAK,CAAA;IACd,CAAC;IACD,OAAO,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,KAAK,MAAM,CAAA;AACrC,CAAC;AAGD,sEAAsE;AACtE,oDAAoD;AACpD,EAAE;AACF,oEAAoE;AACpE,wEAAwE;AACxE,gDAAgD;AAChD,EAAE;AACF,iEAAiE;AACjE,sEAAsE;AACtE,+BAA+B;AAC/B,wEAAwE;AACxE,gEAAgE;AAChE,wEAAwE;AACxE,gDAAgD;AAChD,wEAAwE;AACxE,sEAAsE;AACtE,sBAAsB;AACtB,4DAA4D;AAC5D,sEAAsE;AACtE,2BAA2B;AAC3B,EAAE;AACF,iEAAiE;AACjE,oEAAoE;AACpE,iDAAiD;AACjD,SAAS,eAAe,CACtB,UAAkB,EAClB,IAAY,EACZ,WAA+B;IAE/B,iEAAiE;IACjE,EAAE;IACF,sEAAsE;IACtE,sEAAsE;IACtE,oEAAoE;IACpE,kEAAkE;IAClE,mEAAmE;IACnE,sEAAsE;IACtE,mEAAmE;IACnE,qEAAqE;IACrE,qEAAqE;IACrE,qEAAqE;IACrE,iEAAiE;IACjE,mDAAmD;IACnD,EAAE;IACF,mEAAmE;IACnE,mEAAmE;IACnE,mEAAmE;IACnE,mEAAmE;IACnE,qEAAqE;IACrE,sEAAsE;IACtE,2CAA2C;IAC3C,MAAM,KAAK,GAAG,IAAA,WAAG,EAAC,UAAU,EAAE,IAAI,EAAE;QAClC,KAAK,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE;QAC1B,GAAG,CAAC,IAAI,IAAI,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC;KACtD,CAAC,CAAA;IAEF,IAAI,IAAI,KAAK,KAAK,CAAC,EAAE,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;QAC9C,oEAAoE;QACpE,oEAAoE;QACpE,kEAAkE;QAClE,oEAAoE;QACpE,6CAA6C;QAC7C,MAAM,SAAS,GAAG,IAAA,WAAG,EAAC,UAAU,EAAE,IAAI,EACpC,IAAI,IAAI,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAA;QAC1D,IAAI,IAAI,KAAK,SAAS,CAAC,EAAE,IAAI,IAAI,IAAI,SAAS,CAAC,MAAM,EAAE,CAAC;YACtD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,CAAA;QAChD,CAAC;QACD,OAAO;YACL,IAAI,EAAE,SAAS;YACf,OAAO,EAAE,WAAW,CAAC,oBAAoB,EAAE,IAAI,EAC7C,yDAAyD;gBACzD,6DAA6D;gBAC7D,+DAA+D,EAC/D,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC;SAC9B,CAAA;IACH,CAAC;IAED,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAA;IAE3B,kEAAkE;IAClE,iEAAiE;IACjE,6DAA6D;IAC7D,kDAAkD;IAClD,MAAM,SAAS,GAAkB,MAAM,CAAC,SAAS,CAAA;IAEjD,kEAAkE;IAClE,gEAAgE;IAChE,kEAAkE;IAClE,gEAAgE;IAChE,iEAAiE;IACjE,mEAAmE;IACnE,mEAAmE;IACnE,gDAAgD;IAChD,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,KAAK,CAAC,CAAC,IAAI,CAAC,CAAA;IACtD,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,OAAO;YACL,IAAI,EAAE,SAAS;YACf,OAAO,EAAE,WAAW,CAAC,oBAAoB,EAAE,IAAI,EAC7C,8DAA8D;gBAC9D,gEAAgE;gBAChE,YAAY,EACZ,IAAI,CAAC;SACR,CAAA;IACH,CAAC;IAED,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,SAAS,KAAK,CAAC,CAAC,IAAI,CAAC,CAAA;IAE9D,IAAI,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC;QACxB,OAAO;YACL,IAAI,EAAE,SAAS;YACf,OAAO,EAAE,WAAW,CAAC,iBAAiB,EAAE,IAAI,EAC1C,8DAA8D;gBAC9D,gDAAgD,EAChD,QAAQ,CAAC;SACZ,CAAA;IACH,CAAC;IAED,kEAAkE;IAClE,+DAA+D;IAC/D,IAAI,CAAC,KAAK,QAAQ,CAAC,MAAM,EAAE,CAAC;QAC1B,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,KAAK,CAAC,CAAC,IAAI,CAAC,CAAA;QAC3D,IAAI,CAAC,KAAK,QAAQ,CAAC,MAAM,EAAE,CAAC;YAC1B,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,CAAA;QAChD,CAAC;QACD,OAAO;YACL,IAAI,EAAE,SAAS;YACf,OAAO,EAAE,WAAW,CAAC,oBAAoB,EAAE,IAAI,EAC7C,8CAA8C;gBAC9C,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;gBACtC,gEAAgE,EAChE,QAAQ,CAAC;SACZ,CAAA;IACH,CAAC;IAED,OAAO,YAAY,CAAC,UAAU,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAA;AACpD,CAAC;AAGD,sEAAsE;AACtE,oEAAoE;AACpE,mEAAmE;AACnE,+DAA+D;AAC/D,qEAAqE;AACrE,uEAAuE;AACvE,mEAAmE;AACnE,uEAAuE;AACvE,uEAAuE;AACvE,qEAAqE;AACrE,sCAAsC;AACtC,sBACE,UAAkB,EAClB,IAAY,EACZ,GAAgB;IAEhB,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;QAC9C,MAAM,OAAO,GAAG,WAAW,CAAC,qBAAqB,EAAE,IAAI,EACrD,4BAA4B,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,MAAM;YAC/D,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,QAAQ,GAAG,GAAG,CAAC,IAAI,CAAC,GAAG;YAC3D,kDAAkD,EAClD,CAAC,GAAG,CAAC,CAAC,CAAA;QACR,mEAAmE;QACnE,mDAAmD;QACnD,OAAO,CAAC,KAAK,GAAG,UAAU,CAAA;QAC1B,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAA;IACrC,CAAC;IAED,6CAA6C;IAC7C,EAAE;IACF,sEAAsE;IACtE,qEAAqE;IACrE,gEAAgE;IAChE,oEAAoE;IACpE,oEAAoE;IACpE,oEAAoE;IACpE,kEAAkE;IAClE,sEAAsE;IACtE,qBAAqB;IACrB,EAAE;IACF,4DAA4D;IAC5D,gEAAgE;IAChE,8DAA8D;IAC9D,kEAAkE;IAClE,qEAAqE;IACrE,8DAA8D;IAC9D,EAAE;IACF,qEAAqE;IACrE,mEAAmE;IACnE,oEAAoE;IACpE,OAAO;IACP,MAAM,IAAI,GAAG,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;IAC/B,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,CAAC,KAAK,KAAK,GAAG,CAAC,KAAK,EAAE,CAAC;QAC7C,OAAO;YACL,IAAI,EAAE,SAAS;YACf,OAAO,EAAE,WAAW,CAAC,oBAAoB,EAAE,IAAI,EAC7C,iBAAiB,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,iBAAiB;gBAC/D,mBAAmB,GAAG,GAAG,CAAC,KAAK,GAAG,4BAA4B;gBAC9D,6DAA6D;gBAC7D,OAAO,EACP,CAAC,GAAG,CAAC,CAAC;SACT,CAAA;IACH,CAAC;IAED,0DAA0D;IAC1D,kEAAkE;IAClE,kEAAkE;IAClE,oEAAoE;IACpE,oEAAoE;IACpE,IAAI,IAAI,KAAK,IAAI,CAAC,QAAQ,EAAE,CAAC;QAC3B,OAAO;YACL,IAAI,EAAE,SAAS;YACf,OAAO,EAAE,WAAW,CAAC,oBAAoB,EAAE,IAAI,EAC7C,GAAG,CAAC,KAAK,GAAG,6CAA6C;gBACzD,sDAAsD,EACtD,CAAC,GAAG,CAAC,CAAC;SACT,CAAA;IACH,CAAC;IAED,OAAO;QACL,IAAI,EAAE;YACJ,GAAG,EAAE,GAAG,CAAC,IAAI,CAAC,GAAG;YACjB,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,IAAI;YACnB,IAAI,EAAE,GAAG,CAAC,GAAG;YACb,IAAI;YACJ,GAAG,EAAE,GAAG,CAAC,IAAI,CAAC,GAAG;YACjB,EAAE,EAAE,EAAE;SACP;QACD,OAAO,EAAE,SAAS;KACnB,CAAA;AACH,CAAC;AAGD,uEAAuE;AACvE,mEAAmE;AACnE,wCAAwC;AACxC,EAAE;AACF,mEAAmE;AACnE,qEAAqE;AACrE,mBACE,GAAW;IACX,oEAAoE;IACpE,oEAAoE;IACpE,kEAAkE;IAClE,qEAAqE;IACrE,sEAAsE;IACtE,8DAA8D;IAC9D,YAAY;IACZ,IAAI,KAAa,CAAA;IACjB,IAAI,CAAC;QACH,MAAM,IAAI,GAAQ,IAAI,aAAK,EAAE,CAAC,KAAK,CAAC,KAAK,GAAG,GAAG,CAAC,CAAA;QAChD,MAAM,IAAI,GAAQ,IAAI,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAA;QAClC,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,IAAI,CAAC,KAAK,EAAE,CAAC;YACxC,OAAO,SAAS,CAAA;QAClB,CAAC;QACD,KAAK,GAAG,IAAI,CAAC,KAAK,CAAA;IACpB,CAAC;IACD,OAAO,CAAC,EAAE,CAAC;QACT,OAAO,SAAS,CAAA;IAClB,CAAC;IAED,qEAAqE;IACrE,mEAAmE;IACnE,0DAA0D;IAC1D,IAAI,CAAC;QACH,IAAI,aAAK,EAAE,CAAC,QAAQ,CAAC,KAAK,GAAG,GAAG,CAAC,CAAA;IACnC,CAAC;IACD,OAAO,CAAC,EAAE,CAAC;QACT,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAA;IACnC,CAAC;IACD,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAA;AAClC,CAAC;AAGD,uEAAuE;AACvE,gEAAgE;AAChE,wEAAwE;AACxE,wEAAwE;AACxE,kBAAkB;AAClB,SAAS,WAAW,CAClB,IAAY,EAAE,IAAY,EAAE,GAAW,EAAE,IAAmB;IAE5D,OAAO;QACL,IAAI;QACJ,qDAAqD;QACrD,oDAAoD;QACpD,KAAK,EAAE,WAAW;QAClB,QAAQ,EAAE,SAAS;QACnB,IAAI;QACJ,gEAAgE;QAChE,4DAA4D;QAC5D,OAAO,EAAE,iBAAiB,GAAG,IAAI,GAAG,aAAa,GAAG,GAAG;QACvD,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACtB,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI;YACjB,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG;YACf,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG;YACf,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG;YACf,GAAG,EAAE,CAAC,CAAC,GAAG;YACV,IAAI,EAAE,MAAM;YACZ,KAAK,EAAE,CAAC,CAAC,KAAK;SACf,CAAC,CAAQ;KACX,CAAA;AACH,CAAC;AAGD,mEAAmE;AACnE,sEAAsE;AACtE,uEAAuE;AACvE,+DAA+D;AAC/D,sEAAsE;AACtE,sCAAsC;AACtC,eACE,QAAgB,EAChB,UAAkB,EAClB,WAAqB,EACrB,IAAmB;IAEnB,MAAM,OAAO,GAAG,IAAI,IAAI,EAAE,CAAA;IAE1B,MAAM,QAAQ,GAAa,EAAE,CAAA;IAC7B,MAAM,QAAQ,GAAuB,EAAE,CAAA;IACvC,MAAM,KAAK,GAAiB,EAAE,CAAA;IAC9B,mEAAmE;IACnE,sEAAsE;IACtE,sEAAsE;IACtE,MAAM,KAAK,GAA8C,EAAE,CAAA;IAE3D,KAAK,MAAM,IAAI,IAAI,WAAW,EAAE,CAAC;QAC/B,MAAM,CAAC,GAAG,eAAe,CAAC,IAAI,CAAC,CAAA;QAC/B,IAAI,IAAI,IAAI,CAAC,EAAE,CAAC;YACd,OAAO;gBACL,OAAO,EAAE,UAAU;gBACnB,QAAQ,EAAE,EAAE;gBACZ,QAAQ,EAAE,EAAE;gBACZ,OAAO,EAAE,OAAO;gBAChB,QAAQ,EAAE,CAAC;wBACT,IAAI,EAAE,kBAAkB;wBACxB,KAAK,EAAE,OAAO;wBACd,QAAQ,EAAE,OAAO;wBACjB,IAAI,EAAE,GAAG;wBACT,OAAO,EAAE,oCAAoC,IAAI,EAAE;wBACnD,KAAK,EAAE,EAAE;qBACV,CAAC;aACH,CAAA;QACH,CAAC;QAED,IAAI,IAAI,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC;YAC7B,MAAM,KAAK,GAAG,eAAe,CAAC,UAAU,EAAE,CAAC,CAAC,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,CAAA;YACtE,IAAI,IAAI,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;gBAC1B,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;YAC3B,CAAC;YACD,IAAI,IAAI,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;gBACvB,6DAA6D;gBAC7D,8DAA8D;gBAC9D,0DAA0D;gBAC1D,MAAM,EAAE,GAAG,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;gBAC/D,MAAM,GAAG,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAA;gBAC/C,MAAM,IAAI,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,CAAA;gBAC7D,IAAI,GAAG,GAAG,CAAC,EAAE,CAAC;oBACZ,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;oBAChB,QAAQ,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAA;gBAC/C,CAAC;qBACI,CAAC;oBACJ,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,CAAA;oBACjB,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,CAAA;gBAChD,CAAC;gBACD,SAAQ;YACV,CAAC;QACH,CAAC;QAED,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAA;IAC7C,CAAC;IAED,MAAM,OAAO,GAAG,WAAW,CAAC,UAAU,CAAC,UAAU,EAAE,KAAK,CAAC,EAAE,QAAQ,CAAC,CAAA;IAEpE,kEAAkE;IAClE,4DAA4D;IAC5D,kEAAkE;IAClE,kDAAkD;IAClD,MAAM,MAAM,GAAc,IAAA,SAAG,EAAC,QAAQ,EAAE,OAAO,EAAE;QAC/C,KAAK,EAAE,OAAO,CAAC,KAAK;QACpB,UAAU,EAAE,OAAO,CAAC,SAAS;QAC7B,QAAQ,EAAE,OAAO,CAAC,WAAW;QAC7B,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,OAAO,EAAE,OAAO,CAAC,WAAW;KACtB,CAAC,CAAA;IAET,OAAO;QACL,OAAO;QACP,QAAQ;QACR,QAAQ;QACR,OAAO,EAAE,MAAM,CAAC,OAAO;QACvB,mEAAmE;QACnE,gEAAgE;QAChE,iDAAiD;QACjD,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC;KACxC,CAAA;AACH,CAAC;AAGD,kEAAkE;AAClE,iEAAiE;AACjE,SAAS,UAAU,CACjB,GAAW,EAAE,KAAgD;IAE7D,IAAI,CAAC,KAAK,KAAK,CAAC,MAAM,EAAE,CAAC;QACvB,OAAO,GAAG,CAAA;IACZ,CAAC;IACD,IAAI,GAAG,GAAG,GAAG,CAAA;IACb,KAAK,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;QACvD,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,CAAA;IAC3D,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC;AAGD,sEAAsE;AACtE,mEAAmE;AACnE,sEAAsE;AACtE,2DAA2D;AAC3D,SAAS,WAAW,CAAC,UAAkB,EAAE,QAAkB;IACzD,IAAI,CAAC,KAAK,QAAQ,CAAC,MAAM,EAAE,CAAC;QAC1B,OAAO,UAAU,CAAA;IACnB,CAAC;IACD,MAAM,IAAI,GAAG,EAAE,KAAK,UAAU,IAAI,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC;QACzD,CAAC,CAAC,UAAU;QACZ,CAAC,CAAC,UAAU,GAAG,IAAI,CAAA;IACrB,OAAO,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;AAC1C,CAAC"}

package/dist/provenance.d.ts

@@ -0,0 +1,41 @@
+export type WhyRole = 'literal' | 'spread' | 'ref' | 'pref';
+export type WhySite = {
+    col: number;
+    file: string;
+    len: number;
+    row: number;
+};
+export type WhyConjunct = {
+    canon: string;
+    role: WhyRole;
+    site: WhySite;
+    src: string;
+    rank?: number;
+};
+export type WhyRecord = {
+    conjuncts: WhyConjunct[];
+    path: string;
+    value: string;
+};
+export declare const FROM_SPREAD = "_fromSpread";
+export declare const WRITTEN = "_written";
+export declare const INNER_OF = "_innerOf";
+export declare function markSpread(v: any, seen?: Set<any>): void;
+type Contribution = WhyConjunct & {
+    id: number;
+};
+type PathRecord = {
+    conjuncts: Contribution[];
+    made: Set<number>;
+    seen: Set<number>;
+};
+export declare class Provenance {
+    paths: Map<string, PathRecord>;
+    containers: Map<number, any>;
+    writtenFrom(v: any): void;
+    record(path: string[], a: any, b: any, out: any): void;
+    private contribute;
+    stands(path: string[], v: any): void;
+    at(path: string[]): WhyConjunct[];
+}
+export {};