@veryfront/ext-content-mdx 0.1.1226 → 0.1.1228

package/esm/src/extensions/contract-registry-internal.js

@@ -0,0 +1,642 @@
+/**
+ * Internal contract-registry ownership and active-use lifecycle.
+ *
+ * Public registry operations intentionally remain synchronous and preserve
+ * their existing signatures. Loader-owned registrations additionally carry
+ * an opaque generation identity so teardown can stop admission, drain active
+ * users, and remove only the exact entries that generation published.
+ *
+ * @internal
+ */
+import { assertCanonicalNonEmptyString } from "./runtime-validation.js";
+import { AsyncLocalStorage } from "../platform/compat/async-context.js";
+const NativeAggregateError = AggregateError;
+const NativeError = Error;
+const NativeMap = Map;
+const NativePromise = Promise;
+const NativeSet = Set;
+const apply = Reflect.apply;
+const arrayIteratorSymbol = Symbol.iterator;
+const arrayIterator = Array.prototype[arrayIteratorSymbol];
+const createObject = Object.create;
+const defineProperty = Object.defineProperty;
+const freeze = Object.freeze;
+const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const setPrototypeOf = Object.setPrototypeOf;
+const mapClear = Map.prototype.clear;
+const mapDelete = Map.prototype.delete;
+const mapForEach = Map.prototype.forEach;
+const mapGet = Map.prototype.get;
+const mapSet = Map.prototype.set;
+const setAdd = Set.prototype.add;
+const setDelete = Set.prototype.delete;
+const setForEach = Set.prototype.forEach;
+const setHas = Set.prototype.has;
+const setSizeGetter = (() => {
+    const getter = getOwnPropertyDescriptor(Set.prototype, "size")?.get;
+    if (getter === undefined) {
+        throw new NativeError("Set.prototype.size getter is unavailable");
+    }
+    return getter;
+})();
+const registeredContracts = new NativeMap();
+const generationResolutionStorage = new AsyncLocalStorage();
+const asyncLocalStorageGetStore = AsyncLocalStorage.prototype.getStore;
+const asyncLocalStorageRun = AsyncLocalStorage.prototype.run;
+function createRegistryResetToken() {
+    return freeze(createObject(null));
+}
+function createNullPrototypeRecord(record) {
+    return apply(setPrototypeOf, Object, [record, null]);
+}
+function createDataDescriptor(value, configurable = false, writable = false) {
+    const descriptor = createObject(null);
+    descriptor.configurable = configurable;
+    descriptor.enumerable = false;
+    descriptor.value = value;
+    descriptor.writable = writable;
+    return descriptor;
+}
+function appendArrayValue(array, value) {
+    const descriptor = createObject(null);
+    descriptor.configurable = true;
+    descriptor.enumerable = true;
+    descriptor.value = value;
+    descriptor.writable = true;
+    defineProperty(array, array.length, descriptor);
+}
+function copyArrayForAggregateError(source) {
+    const copy = [];
+    for (let index = 0; index < source.length; index += 1) {
+        appendArrayValue(copy, source[index]);
+    }
+    defineProperty(copy, arrayIteratorSymbol, createDataDescriptor(arrayIterator));
+    return copy;
+}
+function clearMap(map) {
+    apply(mapClear, map, []);
+}
+function deleteMapValue(map, key) {
+    return apply(mapDelete, map, [key]);
+}
+function forEachMapValue(map, callback) {
+    apply(mapForEach, map, [callback]);
+}
+function getMapValue(map, key) {
+    return apply(mapGet, map, [key]);
+}
+function setMapValue(map, key, value) {
+    apply(mapSet, map, [key, value]);
+}
+function addSetValue(set, value) {
+    apply(setAdd, set, [value]);
+}
+function deleteSetValue(set, value) {
+    return apply(setDelete, set, [value]);
+}
+function forEachSetValue(set, callback) {
+    apply(setForEach, set, [callback]);
+}
+function hasSetValue(set, value) {
+    return apply(setHas, set, [value]);
+}
+function getSetSize(set) {
+    return apply(setSizeGetter, set, []);
+}
+function createPinnedPromise(executor) {
+    const promise = new NativePromise(executor);
+    defineProperty(promise, "constructor", createDataDescriptor(NativePromise));
+    return promise;
+}
+function createResolvedPromise() {
+    return createPinnedPromise((resolve) => resolve());
+}
+function getScopedResolutionState() {
+    const scope = apply(asyncLocalStorageGetStore, generationResolutionStorage, []);
+    if (scope === undefined)
+        return undefined;
+    if (!scope.active || scope.resetToken !== contractRegistryResetToken) {
+        // A low-level reset is an epoch boundary. While stale cleanup is still
+        // running, suppress both its candidate overlay and fallback into the new
+        // global registry so it cannot act on replacement resources. Inactive
+        // inherited scopes stay blocked so detached descendants cannot outlive
+        // their teardown authority and later observe a replacement.
+        return null;
+    }
+    return scope;
+}
+function extensionTeardownUnavailable(name) {
+    return new NativeError(`Extension contract "${name}" is unavailable during extension teardown`);
+}
+function assertNoLifecycleAdmissionDuringTeardown(name) {
+    if (getScopedResolutionState() !== undefined) {
+        throw extensionTeardownUnavailable(name);
+    }
+}
+function assertCurrentMutationScope(operation) {
+    const scope = getScopedResolutionState();
+    if (scope === null) {
+        throw new NativeError(`Cannot ${operation} extension contracts from an expired teardown scope`);
+    }
+    return scope;
+}
+function assertNoGenerationTransitionDuringTeardown(operation) {
+    if (getScopedResolutionState() !== undefined) {
+        throw new NativeError(`Cannot ${operation} an extension contract generation during extension teardown`);
+    }
+}
+/**
+ * Reject candidate preparation before extension-controlled materialization or
+ * transition hooks can run inside a current or inherited teardown scope.
+ */
+export function assertContractGenerationAdmissionAllowed() {
+    assertNoGenerationTransitionDuringTeardown("start");
+}
+let activeGeneration;
+let stagingGeneration;
+let failedGenerationUnavailable = false;
+let contractRegistryResetToken = createRegistryResetToken();
+function createEntry(implementation, generation) {
+    return freeze(createNullPrototypeRecord({
+        implementation,
+        generation,
+    }));
+}
+function assertStagingGeneration(generation) {
+    if (generation.status !== "staging" || stagingGeneration !== generation) {
+        throw new NativeError("Contract generation is not the active staging generation");
+    }
+}
+function unavailableDuringTransition(name) {
+    const entry = getMapValue(registeredContracts, name);
+    if (entry?.generation?.status === "retiring") {
+        return new NativeError(`Extension contract "${name}" is unavailable while its generation is retiring`);
+    }
+    if (stagingGeneration !== undefined) {
+        return new NativeError("Extension contracts are unavailable while a generation is staging");
+    }
+    if (failedGenerationUnavailable) {
+        return new NativeError("Extension contracts are unavailable because the previous generation failed");
+    }
+    return new NativeError(`Extension contract "${name}" is unavailable because its captured generation is no longer active`);
+}
+function notifyRetirement(generation, record) {
+    if (record.released ||
+        record.retirementNotified ||
+        record.retirementHandler === undefined ||
+        !generation.hasRetirementReason ||
+        !generation.retirementNotificationStarted) {
+        return;
+    }
+    record.retirementNotified = true;
+    generation.retirementNotificationDepth += 1;
+    try {
+        try {
+            runWithContractGenerationEpochSync(generation, () => {
+                apply(record.retirementHandler, undefined, [
+                    generation.retirementReason,
+                ]);
+            });
+        }
+        catch (error) {
+            appendArrayValue(generation.retirementHandlerFailures, error);
+        }
+    }
+    finally {
+        generation.retirementNotificationDepth -= 1;
+        finishLeaseDrain(generation);
+    }
+}
+function finishLeaseDrain(generation) {
+    if (getSetSize(generation.leases) !== 0 ||
+        generation.retirementNotificationDepth !== 0) {
+        return;
+    }
+    const settle = generation.settleLeaseDrain;
+    generation.settleLeaseDrain = undefined;
+    generation.rejectLeaseDrain = undefined;
+    if (settle !== undefined)
+        apply(settle, undefined, []);
+}
+function getQuarantinedLeaseFailure(generation) {
+    let failure;
+    forEachSetValue(generation.leases, (record) => {
+        if (failure === undefined && record.quarantined) {
+            failure = record.quarantineFailure;
+        }
+    });
+    return failure;
+}
+function rejectLeaseDrainForQuarantine(generation) {
+    const failure = getQuarantinedLeaseFailure(generation);
+    if (failure === undefined)
+        return false;
+    const reject = generation.rejectLeaseDrain;
+    if (reject === undefined)
+        return true;
+    generation.settleLeaseDrain = undefined;
+    generation.rejectLeaseDrain = undefined;
+    generation.retirementDrainQuarantined = true;
+    apply(reject, undefined, [failure]);
+    return true;
+}
+function throwRetirementHandlerFailures(generation) {
+    if (generation.retirementHandlerFailures.length === 0)
+        return;
+    if (generation.retirementHandlerFailures.length === 1) {
+        throw generation.retirementHandlerFailures[0];
+    }
+    throw new NativeAggregateError(copyArrayForAggregateError(generation.retirementHandlerFailures), "Extension contract generation retirement controls failed");
+}
+function unpublishExactGenerationEntries(generation) {
+    forEachMapValue(generation.entries, (entry, name) => {
+        if (getMapValue(registeredContracts, name) === entry) {
+            deleteMapValue(registeredContracts, name);
+        }
+    });
+}
+/** Read one raw public registration. */
+export function tryResolveRegisteredContract(name) {
+    const scopedResolution = getScopedResolutionState();
+    if (scopedResolution === null)
+        return undefined;
+    if (scopedResolution?.entryOverlay !== undefined) {
+        const overlay = scopedResolution.entryOverlay;
+        if (!hasSetValue(overlay.entryOverlayShadows, name)) {
+            const scopedEntry = getMapValue(overlay.entries, name);
+            if (scopedEntry !== undefined)
+                return scopedEntry.implementation;
+        }
+    }
+    return getMapValue(registeredContracts, name)?.implementation;
+}
+function assertRetiringGeneration(generation) {
+    if (generation.status !== "retiring") {
+        throw new NativeError("Contract generation resolution scope requires a retiring generation");
+    }
+}
+function createContractGenerationResolutionScope(generation, entryOverlay) {
+    return createNullPrototypeRecord({
+        entryOverlay,
+        resetToken: generation.resetToken,
+        active: true,
+    });
+}
+function runWithContractGenerationScope(generation, entryOverlay, operation) {
+    assertRetiringGeneration(generation);
+    const scope = createContractGenerationResolutionScope(generation, entryOverlay);
+    try {
+        return apply(asyncLocalStorageRun, generationResolutionStorage, [
+            scope,
+            async () => {
+                try {
+                    return await operation();
+                }
+                finally {
+                    scope.active = false;
+                }
+            },
+        ]);
+    }
+    catch (error) {
+        scope.active = false;
+        throw error;
+    }
+}
+function runWithContractGenerationEpochSync(generation, operation) {
+    assertRetiringGeneration(generation);
+    const scope = createContractGenerationResolutionScope(generation);
+    try {
+        return apply(asyncLocalStorageRun, generationResolutionStorage, [scope, operation]);
+    }
+    finally {
+        scope.active = false;
+    }
+}
+/**
+ * Bind raw contract resolution to a failed candidate during rollback.
+ *
+ * Failed candidates retain their unpublished staged dependencies. Reset and
+ * hook settlement still revoke inherited descendants.
+ */
+export function runWithContractGenerationResolution(generation, operation) {
+    return runWithContractGenerationScope(generation, generation, operation);
+}
+/**
+ * Bind teardown to one registry epoch without overriding current raw entries.
+ *
+ * Successful teardown keeps the registry's public overwrite semantics while
+ * stale or detached work remains unable to cross a reset boundary.
+ */
+export function runWithContractGenerationEpoch(generation, operation) {
+    return runWithContractGenerationScope(generation, undefined, operation);
+}
+/** Install one unmanaged public registration. */
+export function registerUnmanagedContract(name, implementation) {
+    const scope = assertCurrentMutationScope("register");
+    setMapValue(registeredContracts, name, createEntry(implementation));
+    if (scope?.entryOverlay !== undefined) {
+        addSetValue(scope.entryOverlay.entryOverlayShadows, name);
+    }
+}
+/** Remove the current public registration without lifecycle coordination. */
+export function unregisterContract(name) {
+    const scope = assertCurrentMutationScope("unregister");
+    deleteMapValue(registeredContracts, name);
+    if (scope?.entryOverlay !== undefined) {
+        addSetValue(scope.entryOverlay.entryOverlayShadows, name);
+    }
+}
+/**
+ * Force-clear the public registry and lifecycle state.
+ *
+ * This preserves the historical synchronous reset primitive used by tests and
+ * composition roots. Normal loader shutdown must use generation retirement.
+ */
+export function resetContractRegistry() {
+    assertCurrentMutationScope("reset");
+    clearMap(registeredContracts);
+    activeGeneration = undefined;
+    stagingGeneration = undefined;
+    failedGenerationUnavailable = false;
+    contractRegistryResetToken = createRegistryResetToken();
+}
+/** Start staging one candidate generation without publishing partial entries. */
+export function beginContractGeneration() {
+    assertContractGenerationAdmissionAllowed();
+    if (stagingGeneration !== undefined) {
+        throw new NativeError("Another extension contract generation is already staging");
+    }
+    const generation = createNullPrototypeRecord({
+        resetToken: contractRegistryResetToken,
+        status: "staging",
+        entries: new NativeMap(),
+        entryOverlayShadows: new NativeSet(),
+        leases: new NativeSet(),
+        retirementHandlerFailures: [],
+        retirementNotificationDepth: 0,
+        retirementReason: undefined,
+        hasRetirementReason: false,
+        retirementNotificationStarted: false,
+        settleLeaseDrain: undefined,
+        rejectLeaseDrain: undefined,
+        retirementDrainQuarantined: false,
+        retirementPromise: undefined,
+    });
+    stagingGeneration = generation;
+    return generation;
+}
+/** Stage or replace one loader-owned entry inside a candidate generation. */
+export function stageContract(generation, name, implementation) {
+    assertNoGenerationTransitionDuringTeardown("stage");
+    assertCanonicalNonEmptyString(name, "Contract name");
+    if (implementation === undefined) {
+        throw new TypeError(`Contract "${name}" implementation must not be undefined`);
+    }
+    assertStagingGeneration(generation);
+    setMapValue(generation.entries, name, createEntry(implementation, generation));
+}
+/** Resolve candidate-local dependencies without publishing the candidate. */
+export function tryResolveContractForGeneration(generation, name) {
+    assertCanonicalNonEmptyString(name, "Contract name");
+    if (generation.resetToken !== contractRegistryResetToken) {
+        throw new NativeError(`Extension contract "${name}" is unavailable after the registry was reset`);
+    }
+    const staged = getMapValue(generation.entries, name);
+    if (staged !== undefined)
+        return staged.implementation;
+    return tryResolveRegisteredContract(name);
+}
+/** Atomically publish every staged entry and open active-use admission. */
+export function commitContractGeneration(generation) {
+    assertNoGenerationTransitionDuringTeardown("commit");
+    assertStagingGeneration(generation);
+    if (activeGeneration?.status === "active") {
+        throw new NativeError("Cannot publish an extension contract generation before the active generation retires");
+    }
+    forEachMapValue(registeredContracts, (entry) => {
+        const owner = entry.generation;
+        if (owner !== undefined &&
+            owner !== generation &&
+            owner.status !== "retired" &&
+            owner.status !== "failed") {
+            throw new NativeError("Cannot publish an extension contract generation while a prior generation remains owned");
+        }
+    });
+    forEachMapValue(generation.entries, (entry, name) => {
+        setMapValue(registeredContracts, name, entry);
+    });
+    generation.status = "active";
+    activeGeneration = generation;
+    stagingGeneration = undefined;
+    failedGenerationUnavailable = false;
+}
+/**
+ * Capture a contract for lifecycle-aware use.
+ *
+ * Missing is distinct from an unavailable transition: callers may apply their
+ * documented fallback only for a stable, genuinely absent registration.
+ */
+export function trySnapshotContractForUse(name) {
+    assertCanonicalNonEmptyString(name, "Contract name");
+    assertNoLifecycleAdmissionDuringTeardown(name);
+    if (stagingGeneration !== undefined) {
+        throw unavailableDuringTransition(name);
+    }
+    const entry = getMapValue(registeredContracts, name);
+    if (entry !== undefined) {
+        const owner = entry.generation;
+        if (owner === undefined || owner.status === "active") {
+            return freeze({
+                implementation: entry.implementation,
+                reference: freeze({ name, entry }),
+            });
+        }
+        throw unavailableDuringTransition(name);
+    }
+    if (failedGenerationUnavailable) {
+        throw unavailableDuringTransition(name);
+    }
+    return undefined;
+}
+/**
+ * Capture only a loader-generation-owned contract for security-sensitive use.
+ *
+ * Ownerless registrations remain available to compatibility consumers through
+ * `trySnapshotContractForUse`, but cannot satisfy a contract whose safety
+ * depends on retirement fencing and active-use lease drainage.
+ */
+export function trySnapshotGenerationOwnedContractForUse(name) {
+    const snapshot = trySnapshotContractForUse(name);
+    if (snapshot === undefined || snapshot.reference.entry.generation === undefined) {
+        return undefined;
+    }
+    return snapshot;
+}
+/** Acquire active-use ownership immediately before invoking a contract. */
+export function acquireContractLease(reference) {
+    assertNoLifecycleAdmissionDuringTeardown(reference.name);
+    const entry = reference.entry;
+    const generation = entry.generation;
+    if (generation === undefined) {
+        return freeze({
+            setRetirementHandler() { },
+            quarantine() { },
+            release() { },
+        });
+    }
+    if (stagingGeneration !== undefined ||
+        generation.status !== "active" ||
+        getMapValue(registeredContracts, reference.name) !== entry) {
+        throw unavailableDuringTransition(reference.name);
+    }
+    const record = createNullPrototypeRecord({
+        released: false,
+        quarantined: false,
+        quarantineFailure: undefined,
+        retirementNotified: false,
+        retirementHandler: undefined,
+    });
+    addSetValue(generation.leases, record);
+    let retirementHandlerRegistered = false;
+    return freeze({
+        setRetirementHandler(handler) {
+            if (typeof handler !== "function") {
+                throw new TypeError("Contract lease retirement handler must be a function");
+            }
+            if (record.released) {
+                throw new NativeError("Cannot configure a released contract generation lease");
+            }
+            if (retirementHandlerRegistered) {
+                throw new NativeError("Contract generation lease already has a retirement handler");
+            }
+            retirementHandlerRegistered = true;
+            record.retirementHandler = handler;
+            notifyRetirement(generation, record);
+        },
+        quarantine() {
+            if (record.released || record.quarantined)
+                return;
+            const failure = new NativeError(`Extension contract generation is quarantined because "${reference.name}" has an unsettled use`);
+            record.quarantined = true;
+            record.quarantineFailure = failure;
+            if (generation.status === "active") {
+                sealContractGeneration(generation, failure);
+            }
+            rejectLeaseDrainForQuarantine(generation);
+        },
+        release() {
+            if (record.released)
+                return;
+            if (!deleteSetValue(generation.leases, record)) {
+                throw new NativeError("Contract generation lease record is missing");
+            }
+            record.released = true;
+            if (record.quarantined &&
+                generation.retirementDrainQuarantined &&
+                getQuarantinedLeaseFailure(generation) === undefined) {
+                generation.retirementPromise = undefined;
+                generation.retirementDrainQuarantined = false;
+            }
+            finishLeaseDrain(generation);
+        },
+    });
+}
+/**
+ * Close admission synchronously before contexts or other generation-owned
+ * resources begin revocation.
+ */
+export function sealContractGeneration(generation, reason = new NativeError("Extension contract generation was retired")) {
+    if (generation.status === "retired" || generation.status === "failed") {
+        return;
+    }
+    if (generation.status === "retiring") {
+        return;
+    }
+    generation.status = "retiring";
+    if (activeGeneration === generation)
+        activeGeneration = undefined;
+    generation.retirementReason = reason;
+    generation.hasRetirementReason = true;
+}
+/**
+ * Notify active uses synchronously, then await release or reject if an active
+ * lease has quarantined the generation. A drain may be retried after release.
+ */
+export function drainContractGeneration(generation) {
+    if (generation.status === "retired" || generation.status === "failed") {
+        return createResolvedPromise();
+    }
+    if (generation.status !== "retiring") {
+        throw new NativeError("Contract generation must be sealed before it can drain");
+    }
+    if (generation.retirementPromise !== undefined) {
+        return generation.retirementPromise;
+    }
+    const retirement = createPinnedPromise((resolve, reject) => {
+        generation.settleLeaseDrain = () => {
+            try {
+                throwRetirementHandlerFailures(generation);
+                resolve();
+            }
+            catch (error) {
+                reject(error);
+            }
+        };
+        generation.rejectLeaseDrain = reject;
+    });
+    generation.retirementPromise = retirement;
+    generation.retirementNotificationStarted = true;
+    forEachSetValue(generation.leases, (record) => {
+        notifyRetirement(generation, record);
+    });
+    if (!rejectLeaseDrainForQuarantine(generation)) {
+        finishLeaseDrain(generation);
+    }
+    return retirement;
+}
+/** Whether every admitted use has released before extension teardown begins. */
+export function isContractGenerationDrained(generation) {
+    return getSetSize(generation.leases) === 0;
+}
+/** Complete a successful teardown and remove only this generation's entries. */
+export function completeContractGenerationRetirement(generation) {
+    if (generation.status !== "retiring") {
+        throw new NativeError("Contract generation must retire before teardown can complete");
+    }
+    if (!isContractGenerationDrained(generation)) {
+        throw new NativeError("Contract generation still has active leases");
+    }
+    const ownsCurrentRegistry = generation.resetToken === contractRegistryResetToken;
+    if (ownsCurrentRegistry) {
+        unpublishExactGenerationEntries(generation);
+    }
+    generation.status = "retired";
+    if (ownsCurrentRegistry) {
+        if (activeGeneration === generation)
+            activeGeneration = undefined;
+        if (stagingGeneration === generation)
+            stagingGeneration = undefined;
+    }
+}
+/**
+ * Finish a failed candidate. Absence remains fail-closed until a later
+ * generation commits successfully or the low-level registry is reset.
+ */
+export function failContractGeneration(generation) {
+    if (!isContractGenerationDrained(generation)) {
+        throw new NativeError("Failed contract generation still has active leases");
+    }
+    const ownsCurrentRegistry = generation.resetToken === contractRegistryResetToken;
+    if (ownsCurrentRegistry) {
+        unpublishExactGenerationEntries(generation);
+    }
+    generation.status = "failed";
+    if (ownsCurrentRegistry) {
+        if (activeGeneration === generation)
+            activeGeneration = undefined;
+        if (stagingGeneration === generation)
+            stagingGeneration = undefined;
+        failedGenerationUnavailable = activeGeneration === undefined;
+    }
+}

package/esm/src/extensions/contracts.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Contract registry — runtime resolution of extension-provided implementations.
+ *
+ * @module extensions/contracts
+ */
+/** Resolve path segments to an absolute path. */
+export declare function resolve<T>(name: string): T;
+/** Try to resolve. */
+export declare function tryResolve<T>(name: string): T | undefined;
+/** Register. */
+export declare function register<T>(name: string, impl: T): void;
+/** Unregister. */
+export declare function unregister(name: string): void;
+/** Reset. */
+export declare function reset(): void;
+//# sourceMappingURL=contracts.d.ts.map

package/esm/src/extensions/contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../../src/src/extensions/contracts.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAYH,iDAAiD;AACjD,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,CAa1C;AAED,sBAAsB;AACtB,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAGzD;AAED,gBAAgB;AAChB,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAMvD;AAED,kBAAkB;AAClB,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAG7C;AAED,aAAa;AACb,wBAAgB,KAAK,IAAI,IAAI,CAE5B"}