@agoric/governance 0.10.4-dev-5dc325b.0 → 0.10.4-getting-started-dev-d127d1d.0

package/src/contractHelper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contractHelper.d.ts","sourceRoot":"","sources":["contractHelper.js"],"names":[],"mappings":"AAcA,kDAAmD;AAsB5C,wCAHI,IAAI,gBAAgB,EAAE,CAAC,GAAG,EAAE,CAAC,gBAC7B,OAAO,wCAAwC,EAAE,iBAAiB,CAAC,OAAO,CAAC,iBAerF;AAyLD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,yKALW,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wHAtImB,OAAO;;yCAuCC,OAAO,WAAW,OAAO,EAAE,KAAK,OAAO;;;6CAAvC,OAAO,WAAW,OAAO,EAAE,KAAK,OAAO;;;6CAAvC,OAAO,WAAW,OAAO,EAAE,KAAK,OAAO;;;qJAgC/C,OAAO;;;;;;;;;;;;;YAkBvC,iCAAiC;mCAAhB,YAAY;;;;;;;;;;;;;;;YAA7B,iCAAiC;mCAAhB,YAAY;;;;;;;;;EAuEpC"}

package/src/contractHelper.js

@@ -32,7 +32,7 @@ const publicMixinAPI = harden({
 
 /**
  * @param {ZCF<GovernanceTerms<{}> & {}>} zcf
- * @param {import('./contractGovernance/typedParamManager').TypedParamManager<any>} paramManager
+ * @param {import('./contractGovernance/typedParamManager').TypedParamManager<unknown>} paramManager
  */
 export const validateElectorate = (zcf, paramManager) => {
   const { governedParams } = zcf.getTerms();
@@ -53,7 +53,7 @@ harden(validateElectorate);
 /**
  * Utility function for `makeParamGovernance`.
  *
- * @template {import('./contractGovernance/typedParamManager.js').ParamTypesMap} T
+ * @template T
  * @param {ZCF<GovernanceTerms<{}> & {}>} zcf
  * @param {import('./contractGovernance/typedParamManager').TypedParamManager<T>} paramManager
  */
@@ -155,7 +155,7 @@ const facetHelpers = (zcf, paramManager) => {
    * @param {{ [methodName: string]: (context?: unknown, ...rest: unknown[]) => unknown}} limitedCreatorFacet
    */
   const makeVirtualGovernorFacet = limitedCreatorFacet => {
-    /** @type {import('@agoric/swingset-liveslots').FunctionsPlusContext<unknown, GovernedCreatorFacet<limitedCreatorFacet>>} */
+    /** @type {import('@agoric/vat-data/src/types.js').FunctionsPlusContext<unknown, GovernedCreatorFacet<limitedCreatorFacet>>} */
     const governorFacet = harden({
       getParamMgrRetriever: () =>
         Far('paramRetriever', { get: () => paramManager }),

package/src/electorateTools.d.ts

@@ -0,0 +1,46 @@
+export type QuestionRecord = {
+    voteCap: ERef<VoteCounterCreatorFacet>;
+    publicFacet: VoteCounterPublicFacet;
+    deadline: import('@agoric/time/src/types').Timestamp;
+};
+export type StartCounter = (zcf: ZCF, questionSpec: QuestionSpec, quorumThreshold: unknown, voteCounter: ERef<Installation>, questionStore: MapStore<Handle<'Question'>, QuestionRecord>, questionPublisher: Publisher<unknown>, outcomePublisher: Publisher<OutcomeRecord>) => AddQuestionReturn;
+/**
+ * @typedef {object} QuestionRecord
+ * @property {ERef<VoteCounterCreatorFacet>} voteCap
+ * @property {VoteCounterPublicFacet} publicFacet
+ * @property {import('@agoric/time/src/types').Timestamp} deadline
+ */
+/**
+ * @callback StartCounter
+ * @param {ZCF} zcf
+ * @param {QuestionSpec} questionSpec
+ * @param {unknown} quorumThreshold
+ * @param {ERef<Installation>} voteCounter
+ * @param {MapStore<Handle<'Question'>, QuestionRecord>} questionStore
+ * @param {Publisher<unknown>} questionPublisher
+ * @param {Publisher<OutcomeRecord>} outcomePublisher
+ * @returns {AddQuestionReturn}
+ */
+/**
+ * Start up a new Counter for a question
+ *
+ * @type {StartCounter}
+ */
+export const startCounter: StartCounter;
+/** @param {MapStore<Handle<'Question'>, QuestionRecord>} questionStore */
+export function getOpenQuestions(questionStore: MapStore<Handle<'Question'>, QuestionRecord>): Promise<any>;
+/**
+ * @param {ERef<Handle<'Question'>>} questionHandleP
+ * @param {MapStore<Handle<'Question'>, QuestionRecord>} questionStore
+ */
+export function getQuestion(questionHandleP: ERef<Handle<'Question'>>, questionStore: MapStore<Handle<'Question'>, QuestionRecord>): Promise<Question>;
+/**
+ * @param {ZCF} zcf
+ * @param {AddQuestion} addQuestion
+ */
+export function getPoserInvitation(zcf: ZCF, addQuestion: AddQuestion): Promise<Invitation<{
+    addQuestion: AddQuestion;
+} & import("@endo/eventual-send").RemotableBrand<{}, {
+    addQuestion: AddQuestion;
+}>, never>>;
+//# sourceMappingURL=electorateTools.d.ts.map

package/src/electorateTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"electorateTools.d.ts","sourceRoot":"","sources":["electorateTools.js"],"names":[],"mappings":";aAKc,KAAK,uBAAuB,CAAC;iBAC7B,sBAAsB;cACtB,OAAO,wBAAwB,EAAE,SAAS;;iCAK7C,GAAG,gBACH,YAAY,mBACZ,OAAO,eACP,KAAK,YAAY,CAAC,iBAClB,SAAS,OAAO,UAAU,CAAC,EAAE,cAAc,CAAC,qBAC5C,UAAU,OAAO,CAAC,oBAClB,UAAU,aAAa,CAAC,KACtB,iBAAiB;AAhB9B;;;;;GAKG;AAEH;;;;;;;;;;GAUG;AAEH;;;;GAIG;AACH,2BAFU,YAAY,CAsCpB;AAEF,0EAA0E;AAC1E,gDADY,SAAS,OAAO,UAAU,CAAC,EAAE,cAAc,CAAC,gBAYvD;AAED;;;GAGG;AACH,6CAHW,KAAK,OAAO,UAAU,CAAC,CAAC,iBACxB,SAAS,OAAO,UAAU,CAAC,EAAE,cAAc,CAAC,qBAKpD;AAEH;;;GAGG;AACH,wCAHW,GAAG,eACH,WAAW;;;;YAKrB"}

package/src/electorateTools.js

@@ -1,4 +1,3 @@
-import { EmptyProposalShape } from '@agoric/zoe/src/typeGuards.js';
 import { E } from '@endo/eventual-send';
 import { deeplyFulfilled, Far } from '@endo/marshal';
 
@@ -10,16 +9,21 @@ import { deeplyFulfilled, Far } from '@endo/marshal';
  */
 
 /**
- * Start up a new Counter for a question
- *
+ * @callback StartCounter
  * @param {ZCF} zcf
  * @param {QuestionSpec} questionSpec
  * @param {unknown} quorumThreshold
  * @param {ERef<Installation>} voteCounter
  * @param {MapStore<Handle<'Question'>, QuestionRecord>} questionStore
- * @param {Publisher<unknown>} questionsPublisher
+ * @param {Publisher<unknown>} questionPublisher
  * @param {Publisher<OutcomeRecord>} outcomePublisher
- * @returns {Promise<AddQuestionReturn>}
+ * @returns {AddQuestionReturn}
+ */
+
+/**
+ * Start up a new Counter for a question
+ *
+ * @type {StartCounter}
  */
 const startCounter = async (
   zcf,
@@ -87,16 +91,8 @@ const getQuestion = (questionHandleP, questionStore) =>
  * @param {AddQuestion} addQuestion
  */
 const getPoserInvitation = (zcf, addQuestion) => {
-  const questionPoserHandler = seat => {
-    seat.exit();
-    return Far(`questionPoser`, { addQuestion });
-  };
-  return zcf.makeInvitation(
-    questionPoserHandler,
-    `questionPoser`,
-    undefined,
-    EmptyProposalShape,
-  );
+  const questionPoserHandler = () => Far(`questionPoser`, { addQuestion });
+  return zcf.makeInvitation(questionPoserHandler, `questionPoser`);
 };
 
 harden(startCounter);

package/src/index.d.ts

@@ -0,0 +1,9 @@
+export { ParamTypes } from "./constants.js";
+export { ChoiceMethod, ElectionType, QuorumRule, coerceQuestionSpec, positionIncluded, buildQuestion } from "./question.js";
+export { validateQuestionDetails, validateQuestionFromCounter } from "./contractGovernor.js";
+export { handleParamGovernance, publicMixinAPI } from "./contractHelper.js";
+export { assertBallotConcernsParam, makeParamChangePositions, setupParamGovernance, CONTRACT_ELECTORATE } from "./contractGovernance/governParam.js";
+export { assertElectorateMatches, makeParamManagerBuilder } from "./contractGovernance/paramManager.js";
+export { makeParamManager, makeParamManagerSync } from "./contractGovernance/typedParamManager.js";
+export { assertContractGovernance, assertContractElectorate } from "./validators.js";
+//# sourceMappingURL=index.d.ts.map

package/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":""}

package/src/index.js

@@ -1,8 +1,9 @@
-/// <reference path="../../network/exported.js" />
-/// <reference path="../../ERTP/exported.js" />
-/// <reference path="../../zoe/exported.js" />
+// Ambient types. https://github.com/Agoric/agoric-sdk/issues/6512
+import '@agoric/swingset-vat/src/vats/network/types.js';
+import '@agoric/ertp/exported.js';
+import '@agoric/zoe/exported.js';
 
-/// <reference path="./types-ambient.js" />
+import './types-ambient.js';
 
 export {
   ChoiceMethod,

package/src/multiCandidateVoteCounter.d.ts

@@ -0,0 +1,16 @@
+/** @type {BuildMultiVoteCounter} */
+export const makeMultiCandidateVoteCounter: BuildMultiVoteCounter;
+/**
+ * @param {ZCF<{questionSpec: QuestionSpec, quorumThreshold: bigint }>} zcf
+ * @param {{outcomePublisher: Publisher<MultiOutcomeRecord>}} outcomePublisher
+ */
+export function start(zcf: ZCF<{
+    questionSpec: QuestionSpec;
+    quorumThreshold: bigint;
+}>, { outcomePublisher }: {
+    outcomePublisher: Publisher<MultiOutcomeRecord>;
+}): {
+    publicFacet: MultiVoteCounterPublicFacet;
+    creatorFacet: VoteCounterCreatorFacet;
+};
+//# sourceMappingURL=multiCandidateVoteCounter.d.ts.map

package/src/multiCandidateVoteCounter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiCandidateVoteCounter.d.ts","sourceRoot":"","sources":["multiCandidateVoteCounter.js"],"names":[],"mappings":"AAgCA,oCAAoC;AACpC,4CADW,qBAAqB,CAwL9B;AAEF;;;GAGG;AACH;kBAH8B,YAAY;qBAAmB,MAAM;0BACxD;IAAC,gBAAgB,EAAE,UAAU,kBAAkB,CAAC,CAAA;CAAC;;;EAgB3D"}

package/src/multiCandidateVoteCounter.js

@@ -1,4 +1,3 @@
-/* eslint @typescript-eslint/no-floating-promises: "warn" */
 import { keyEQ, makeExo, makeScalarMapStore } from '@agoric/store';
 import { E } from '@endo/eventual-send';
 import { makePromiseKit } from '@endo/promise-kit';
@@ -170,10 +169,10 @@ const makeMultiCandidateVoteCounter = (
         chosenPositions.length <= maxChoices ||
           Fail`The number of choices exceeds the max choices.`;
 
-        for (const position of chosenPositions) {
+        chosenPositions.forEach(position => {
           positionIncluded(positions, position) ||
             Fail`The specified choice is not a legal position: ${position}.`;
-        }
+        });
 
         const completedBallot = harden({ chosen: chosenPositions, shares });
 

package/src/noActionElectorate.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This Electorate visibly has no members, takes no votes, and approves no
+ * changes.
+ *
+ *  @type {ContractStartFn<ElectoratePublic, ElectorateCreatorFacet>}
+ */
+export const start: ContractStartFn<ElectoratePublic, ElectorateCreatorFacet>;
+//# sourceMappingURL=noActionElectorate.d.ts.map

package/src/noActionElectorate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noActionElectorate.d.ts","sourceRoot":"","sources":["noActionElectorate.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,oBAFW,gBAAgB,gBAAgB,EAAE,sBAAsB,CAAC,CA+ClE"}

package/src/noActionElectorate.js

@@ -1,7 +1,6 @@
 import { makePublishKit } from '@agoric/notifier';
 import { makePromiseKit } from '@endo/promise-kit';
 import { makeExo } from '@agoric/store';
-import { EmptyProposalShape } from '@agoric/zoe/src/typeGuards.js';
 
 import { ElectoratePublicI, ElectorateCreatorI } from './typeGuards.js';
 
@@ -38,12 +37,8 @@ const start = zcf => {
 
   const creatorFacet = makeExo('creatorFacet', ElectorateCreatorI, {
     getPoserInvitation() {
-      return zcf.makeInvitation(
-        () => {},
-        `noActionElectorate doesn't allow posing questions`,
-        undefined,
-        EmptyProposalShape,
-      );
+      return zcf.makeInvitation(() => {},
+      `noActionElectorate doesn't allow posing questions`);
     },
     addQuestion(_instance, _question) {
       throw Error(`noActionElectorate doesn't add questions.`);

package/src/question.d.ts

@@ -0,0 +1,27 @@
+/** @type {BuildQuestion} */
+export const buildQuestion: BuildQuestion;
+export namespace ChoiceMethod {
+    const UNRANKED: "unranked";
+    const ORDER: "order";
+    const PLURALITY: "plurality";
+}
+export namespace ElectionType {
+    const PARAM_CHANGE: "param_change";
+    const ELECTION: "election";
+    const SURVEY: "survey";
+    const API_INVOCATION: "api_invocation";
+    const OFFER_FILTER: "offer_filter";
+}
+/**
+ * @param {QuestionSpec} allegedQuestionSpec
+ * @returns {QuestionSpec}
+ */
+export function coerceQuestionSpec({ method, issue, positions, electionType, maxChoices, maxWinners, closingRule, quorumRule, tieOutcome, }: QuestionSpec): QuestionSpec;
+/** @type {PositionIncluded} */
+export const positionIncluded: PositionIncluded;
+export namespace QuorumRule {
+    const MAJORITY: "majority";
+    const NO_QUORUM: "no_quorum";
+    const ALL: "all";
+}
+//# sourceMappingURL=question.d.ts.map

package/src/question.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"question.d.ts","sourceRoot":"","sources":["question.js"],"names":[],"mappings":"AAgFA,4BAA4B;AAC5B,4BADW,aAAa,CAiBtB;;;;;;;;;;;;;AAvDF;;;GAGG;AACH,6IAHW,YAAY,GACV,YAAY,CAkCxB;AAvCD,+BAA+B;AAC/B,+BADW,gBAAgB,CACiD"}

package/src/quorumCounter.d.ts

@@ -0,0 +1,6 @@
+export function makeQuorumCounter(quorumThreshold: any): {
+    check: (stats: any) => boolean;
+} & import("@endo/eventual-send").RemotableBrand<{}, {
+    check: (stats: any) => boolean;
+}>;
+//# sourceMappingURL=quorumCounter.d.ts.map

package/src/quorumCounter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quorumCounter.d.ts","sourceRoot":"","sources":["quorumCounter.js"],"names":[],"mappings":"AAIO;;;;GAUN"}

package/src/typeGuards.d.ts

@@ -0,0 +1,173 @@
+export const ChoiceMethodShape: import("@endo/patterns").Matcher;
+export const QuorumRuleShape: import("@endo/patterns").Matcher;
+export const ElectionTypeShape: import("@endo/patterns").Matcher;
+export namespace ClosingRuleShape {
+    export const timer: any;
+    export { TimestampShape as deadline };
+}
+export namespace YesOfferFilterPositionShape {
+    const strings: import("@endo/patterns").Matcher;
+}
+export namespace NoOfferFilterPositionShape {
+    const dontUpdate: import("@endo/patterns").Matcher;
+}
+export const OfferFilterPositionsShape: ({
+    strings: import("@endo/patterns").Matcher;
+} | {
+    dontUpdate: import("@endo/patterns").Matcher;
+})[];
+export namespace OfferFilterIssueShape {
+    const strings_1: import("@endo/patterns").Matcher;
+    export { strings_1 as strings };
+}
+export namespace OfferFilterQuestionSpecShape {
+    export { ChoiceMethodShape as method };
+    export { OfferFilterIssueShape as issue };
+    export { OfferFilterPositionsShape as positions };
+    export const electionType: string;
+    export const maxChoices: number;
+    export const maxWinners: number;
+    export { ClosingRuleShape as closingRule };
+    export { QuorumRuleShape as quorumRule };
+    export { NoOfferFilterPositionShape as tieOutcome };
+}
+export namespace OfferFilterQuestionDetailsShape {
+    export const questionHandle: import("@endo/patterns").Matcher;
+    export { InstanceHandleShape as counterInstance };
+}
+export const ParamChangesSpecShape: import("@endo/patterns").Matcher;
+export const YesParamChangesPositionShape: import("@endo/patterns").Matcher;
+export namespace NoParamChangesPositionShape {
+    const noChange: import("@endo/patterns").Matcher;
+}
+export const ParamChangesPositionsShape: (import("@endo/patterns").Matcher | {
+    noChange: import("@endo/patterns").Matcher;
+})[];
+export namespace ParamPathShape {
+    const key: import("@endo/patterns").Matcher;
+}
+export namespace ParamChangesIssueShape {
+    export namespace spec {
+        export { ParamPathShape as paramPath };
+        export { ParamChangesSpecShape as changes };
+    }
+    export { InstanceHandleShape as contract };
+}
+export namespace ParamChangesQuestionSpecShape {
+    export const method: string;
+    export { ParamChangesIssueShape as issue };
+    export { ParamChangesPositionsShape as positions };
+    const electionType_1: string;
+    export { electionType_1 as electionType };
+    const maxChoices_1: number;
+    export { maxChoices_1 as maxChoices };
+    const maxWinners_1: number;
+    export { maxWinners_1 as maxWinners };
+    export { ClosingRuleShape as closingRule };
+    export const quorumRule: string;
+    export { NoParamChangesPositionShape as tieOutcome };
+}
+export namespace ParamChangesQuestionDetailsShape {
+    const questionHandle_1: import("@endo/patterns").Matcher;
+    export { questionHandle_1 as questionHandle };
+    export { InstanceHandleShape as counterInstance };
+}
+export namespace YesApiInvocationPositionShape {
+    const apiMethodName: import("@endo/patterns").Matcher;
+    const methodArgs: import("@endo/patterns").Matcher;
+}
+export namespace NoApiInvocationPositionShape {
+    const dontInvoke: import("@endo/patterns").Matcher;
+}
+export const ApiInvocationPositionsShape: ({
+    apiMethodName: import("@endo/patterns").Matcher;
+    methodArgs: import("@endo/patterns").Matcher;
+} | {
+    dontInvoke: import("@endo/patterns").Matcher;
+})[];
+export namespace ApiInvocationQuestionSpecShape {
+    const method_1: string;
+    export { method_1 as method };
+    export { ApiInvocationSpecShape as issue };
+    export { ApiInvocationPositionsShape as positions };
+    const electionType_2: string;
+    export { electionType_2 as electionType };
+    const maxChoices_2: number;
+    export { maxChoices_2 as maxChoices };
+    const maxWinners_2: number;
+    export { maxWinners_2 as maxWinners };
+    export { ClosingRuleShape as closingRule };
+    export { QuorumRuleShape as quorumRule };
+    export { NoApiInvocationPositionShape as tieOutcome };
+}
+export namespace ApiInvocationQuestionDetailsShape {
+    const questionHandle_2: import("@endo/patterns").Matcher;
+    export { questionHandle_2 as questionHandle };
+    export { InstanceHandleShape as counterInstance };
+}
+export namespace YesSimplePositionShape {
+    const text: import("@endo/patterns").Matcher;
+}
+export namespace NoSimplePositionShape {
+    const text_1: import("@endo/patterns").Matcher;
+    export { text_1 as text };
+}
+export const SimplePositionsShape: {
+    text: import("@endo/patterns").Matcher;
+}[];
+export namespace SimpleIssueShape {
+    const text_2: import("@endo/patterns").Matcher;
+    export { text_2 as text };
+}
+export namespace SimpleQuestionSpecShape {
+    export { ChoiceMethodShape as method };
+    export { SimpleIssueShape as issue };
+    export const positions: import("@endo/patterns").Matcher;
+    const electionType_3: import("@endo/patterns").Matcher;
+    export { electionType_3 as electionType };
+    const maxChoices_3: import("@endo/patterns").Matcher;
+    export { maxChoices_3 as maxChoices };
+    const maxWinners_3: import("@endo/patterns").Matcher;
+    export { maxWinners_3 as maxWinners };
+    export { ClosingRuleShape as closingRule };
+    export { QuorumRuleShape as quorumRule };
+    export { NoSimplePositionShape as tieOutcome };
+}
+export namespace SimpleQuestionDetailsShape {
+    const questionHandle_3: import("@endo/patterns").Matcher;
+    export { questionHandle_3 as questionHandle };
+    export { InstanceHandleShape as counterInstance };
+}
+export const QuestionSpecShape: import("@endo/patterns").Matcher;
+export const PositionShape: import("@endo/patterns").Matcher;
+export const QuestionHandleShape: import("@endo/patterns").Matcher;
+export const InvitationShape: import("@endo/patterns").Matcher;
+export const QuestionDetailsShape: import("@endo/patterns").Matcher;
+export const ElectoratePublicI: import("@endo/patterns").InterfaceGuard;
+export const ElectorateCreatorI: import("@endo/patterns").InterfaceGuard;
+export namespace QuestionStatsShape {
+    const spoiled: import("@endo/patterns").Matcher;
+    const votes: import("@endo/patterns").Matcher;
+    const results: import("@endo/patterns").Matcher;
+}
+export const QuestionI: import("@endo/patterns").InterfaceGuard;
+export const BinaryVoteCounterPublicI: import("@endo/patterns").InterfaceGuard;
+export const VoterHandle: import("@endo/patterns").Matcher;
+export const BinaryVoteCounterAdminI: import("@endo/patterns").InterfaceGuard;
+export const BinaryVoteCounterCloseI: import("@endo/patterns").InterfaceGuard;
+export const VoteCounterPublicI: import("@endo/patterns").InterfaceGuard;
+export const VoteCounterAdminI: import("@endo/patterns").InterfaceGuard;
+export const VoteCounterCloseI: import("@endo/patterns").InterfaceGuard;
+export namespace GovernorFacetShape {
+    const getParamMgrRetriever: any;
+    const getInvitation: any;
+    const getLimitedCreatorFacet: any;
+    const getGovernedApis: any;
+    const getGovernedApiNames: any;
+    const setOfferFilter: any;
+}
+import { TimestampShape } from "@agoric/time/src/typeGuards";
+import { InstanceHandleShape } from "@agoric/zoe/src/typeGuards.js";
+declare namespace ApiInvocationSpecShape { }
+export {};
+//# sourceMappingURL=typeGuards.d.ts.map

package/src/typeGuards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["typeGuards.js"],"names":[],"mappings":"AASA,iEAAwE;AACxE,+DAAoE;AACpE,iEAME;;;;;;;;;;;AAcF;;;;KAGG;;;;;;;;;;;;;;;;;;;;AAsBH,qEAAqE;AACrE,4EAAkE;;;;AAIlE;;KAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCH;;;;;KAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBH;;IAGG;;;;;;;;;;;;;;;;;;;;;;;;AAmBH,iEAKE;AAEF,6DASE;AAEF,mEAA+D;AAG/D,+DAAyD;AAKzD,oEAKE;AAEF,wEAMG;AAGH,yEAQG;;;;;;AAQH,gEAGG;AAGH,+EAUE;AAEF,2DAAyC;AACzC,8EAOE;AAEF,8EAKE;AAEF,yEAOG;AAEH,wEAIG;AAEH,wEAEG"}