@prosopo/procaptcha 0.2.13 → 0.2.14

package/dist/cjs/modules/Manager.cjs

@@ -1,34 +1,43 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const errors = require("../api/errors.cjs");
-const api = require("@polkadot/api");
+const Api = require("@polkadot/api/promise/Api");
 const types = require("@prosopo/types");
-const rxjs = require("rxjs");
+const api = require("@prosopo/api");
+const keyring = require("@polkadot/keyring");
 const contract = require("@prosopo/contract");
 const common = require("@prosopo/common");
-const api$1 = require("@prosopo/api");
-require("../contracts/captcha/dist/index.cjs");
+const ws = require("@polkadot/rpc-provider/ws");
+const contractInfo = require("@prosopo/captcha-contract/contract-info");
 const util = require("@prosopo/util");
-const utilCrypto = require("@polkadot/util-crypto");
-const operators = require("rxjs/operators");
+const random = require("@polkadot/util-crypto/random");
+const utils = require("../utils/utils.cjs");
+const string = require("@polkadot/util/string");
 const ExtensionWeb2 = require("../api/ExtensionWeb2.cjs");
 const ExtensionWeb3 = require("../api/ExtensionWeb3.cjs");
 const ProsopoCaptchaApi = require("./ProsopoCaptchaApi.cjs");
 const storage = require("./storage.cjs");
-const captcha = require("../contracts/captcha/dist/contract-info/captcha.cjs");
-const defaultState = () => ({
-  showModal: false,
-  loading: false,
-  index: 0,
-  challenge: void 0,
-  solutions: void 0,
-  isHuman: false,
-  captchaApi: void 0,
-  account: void 0
-});
-const buildUpdateState = (state, onStateUpdate) => (nextState) => {
-  Object.assign(state, nextState);
-  onStateUpdate(nextState);
+const defaultState = () => {
+  return {
+    // note order matters! see buildUpdateState. These fields are set in order, so disable modal first, then set loading to false, etc.
+    showModal: false,
+    loading: false,
+    index: 0,
+    challenge: void 0,
+    solutions: void 0,
+    isHuman: false,
+    captchaApi: void 0,
+    account: void 0
+    // don't handle timeout here, this should be handled by the state management
+  };
+};
+const buildUpdateState = (state, onStateUpdate) => {
+  const updateCurrentState = (nextState) => {
+    Object.assign(state, nextState);
+    onStateUpdate(nextState);
+    console.log("Procaptcha state update:", nextState, "\nResult:", state);
+  };
+  return updateCurrentState;
 };
 const getNetwork = (config) => {
   const network = config.networks[config.defaultNetwork];
@@ -39,7 +48,7 @@ const getNetwork = (config) => {
 };
 function Manager(configOptional, state, onStateUpdate, callbacks) {
   const alertError = (error) => {
-    console.error(error);
+    console.log(error);
     alert(error.message);
   };
   const events = Object.assign(
@@ -47,7 +56,7 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
       onAccountNotFound: alertError,
       onError: alertError,
       onHuman: (output) => {
-        console.info("onHuman event triggered", output);
+        console.log("onHuman event triggered", output);
       },
       onExtensionNotFound: () => {
         alert("No extension found");
@@ -62,10 +71,10 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
         alert("Uncompleted challenge has expired, please try again");
       },
       onOpen: () => {
-        console.info("onOpen event triggered");
+        console.log("onOpen event triggered");
       },
       onClose: () => {
-        console.info("onClose event triggered");
+        console.log("onClose event triggered");
       }
     },
     callbacks
@@ -79,10 +88,16 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
     }
   };
   const updateState = buildUpdateState(state, onStateUpdate);
-  const getConfig = () => types.ProcaptchaConfigSchema.parse({
-    ...configOptional,
-    userAccountAddress: state.account ? state.account.account.address : configOptional.userAccountAddress || ""
-  });
+  const getConfig = () => {
+    const config = {
+      userAccountAddress: "",
+      ...configOptional
+    };
+    if (state.account) {
+      config.userAccountAddress = state.account.account.address;
+    }
+    return types.ProcaptchaConfigSchema.parse(config);
+  };
   const fallable = async (fn) => {
     try {
       await fn();
@@ -93,59 +108,131 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
     }
   };
   const start = async () => {
+    console.log("Starting procaptcha");
     events.onOpen();
     await fallable(async () => {
-      if (state.loading || state.isHuman)
+      if (state.loading) {
+        console.log("Procaptcha already loading");
+        return;
+      }
+      if (state.isHuman) {
+        console.log("already human");
         return;
+      }
       resetState();
-      updateState({ dappAccount: getConfig().account.address, loading: true });
+      updateState({ loading: true });
+      const config = getConfig();
+      updateState({ dappAccount: config.account.address });
+      await utils.sleep(100);
       const account = await loadAccount();
-      const contract2 = await loadContract();
-      if (await checkHumanInContract(contract2, account)) {
-        handleHumanInContract(account);
+      const contract$1 = await loadContract();
+      let contractIsHuman = false;
+      try {
+        contractIsHuman = (await contract$1.query.dappOperatorIsHumanUser(account.account.address, config.solutionThreshold)).value.unwrap().unwrap();
+      } catch (error) {
+        console.warn(error);
+      }
+      if (contractIsHuman) {
+        updateState({ isHuman: true, loading: false });
+        events.onHuman({
+          user: account.account.address,
+          dapp: getDappAccount()
+        });
+        setValidChallengeTimeout();
         return;
       }
       const providerUrlFromStorage = storage.getProviderUrl();
+      let providerApi;
       if (providerUrlFromStorage) {
+        providerApi = await loadProviderApi(providerUrlFromStorage);
         try {
-          const verifyDappUserResponse = await getVerifyDappUserFunction(providerUrlFromStorage, account);
+          const verifyDappUserResponse = await providerApi.verifyDappUser(account.account.address);
           if (verifyDappUserResponse.solutionApproved) {
-            handleHumanInCachedProvider(providerUrlFromStorage, account, verifyDappUserResponse);
+            updateState({ isHuman: true, loading: false });
+            events.onHuman({
+              providerUrl: providerUrlFromStorage,
+              user: account.account.address,
+              dapp: getDappAccount(),
+              commitmentId: verifyDappUserResponse.commitmentId
+            });
+            setValidChallengeTimeout();
             return;
           }
         } catch (err) {
           console.error("Error contacting provider from storage", providerUrlFromStorage);
         }
       }
-      const randomProviderResponse = await getRandomProviderResponse(contract2, account);
-      const challenge = await getChallenge(randomProviderResponse, contract2);
+      const payload = {
+        address: account.account.address,
+        data: string.stringToU8a("message"),
+        type: "bytes"
+      };
+      const signed = await account.extension.signer.signRaw(payload);
+      console.log("Signature:", signed);
+      const getRandomProviderResponse = await contract.wrapQuery(
+        contract$1.query.getRandomActiveProvider,
+        contract$1.query
+      )(account.account.address, getDappAccount());
+      const blockNumber = parseInt(getRandomProviderResponse.blockNumber.toString());
+      console.log("provider", getRandomProviderResponse);
+      const providerUrl = common.trimProviderUrl(getRandomProviderResponse.provider.url.toString());
+      providerApi = await loadProviderApi(providerUrl);
+      console.log("providerApi", providerApi);
+      const captchaApi = await loadCaptchaApi(contract$1, getRandomProviderResponse, providerApi);
+      console.log("captchaApi", captchaApi);
+      const challenge = await captchaApi.getCaptchaChallenge();
+      console.log("challenge", challenge);
       if (challenge.captchas.length <= 0) {
         throw new Error("No captchas returned from provider");
       }
+      const timeMillis = challenge.captchas.map((captcha) => captcha.captcha.timeLimitMs || 30 * 1e3).reduce((a, b) => a + b);
+      const timeout = setTimeout(() => {
+        console.log("challenge expired after " + timeMillis + "ms");
+        events.onChallengeExpired();
+        updateState({ isHuman: false, showModal: false, loading: false });
+      }, timeMillis);
       updateState({
-        challenge,
         index: 0,
         solutions: challenge.captchas.map(() => []),
+        challenge,
         showModal: true,
-        timeout: setTimeToComplete(challenge),
-        blockNumber: getBlockNumberFromProvider(randomProviderResponse)
+        timeout,
+        blockNumber
       });
     });
   };
   const submit = async () => {
     await fallable(async () => {
+      console.log("submitting solutions");
       clearTimeout();
-      updateState({ showModal: false });
       if (!state.challenge) {
         throw new Error("cannot submit, no challenge found");
       }
-      const datasetId = getDatasetId();
-      const salt = utilCrypto.randomAsHex();
-      const submission = await getCaptchaApi().submitCaptchaSolution(
-        getAccount().extension.signer,
-        state.challenge.requestHash,
-        datasetId,
-        getSolutionsFromState(salt),
+      updateState({ showModal: false });
+      const challenge = state.challenge;
+      const salt = random.randomAsHex();
+      const captchaSolution = state.challenge.captchas.map((captcha, index) => {
+        const solution = util.at(state.solutions, index);
+        return {
+          captchaId: captcha.captcha.captchaId,
+          captchaContentId: captcha.captcha.captchaContentId,
+          salt,
+          solution
+        };
+      });
+      const account = getAccount();
+      const blockNumber = getBlockNumber();
+      const signer = account.extension.signer;
+      const first = util.at(challenge.captchas, 0);
+      if (!first.captcha.datasetId) {
+        throw new Error("No datasetId set for challenge");
+      }
+      const captchaApi = getCaptchaApi();
+      const submission = await captchaApi.submitCaptchaSolution(
+        signer,
+        challenge.requestHash,
+        first.captcha.datasetId,
+        captchaSolution,
         salt
       );
       const isHuman = submission[0].solutionApproved;
@@ -157,20 +244,26 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
         isHuman,
         loading: false
       });
-      if (isHuman) {
-        const trimmedUrl = common.trimProviderUrl(getCaptchaApi().provider.provider.url.toString());
+      if (state.isHuman) {
+        const trimmedUrl = common.trimProviderUrl(captchaApi.provider.provider.url.toString());
         storage.setProviderUrl(trimmedUrl);
         events.onHuman({
           providerUrl: trimmedUrl,
-          user: getAccount().account.address,
+          user: account.account.address,
           dapp: getDappAccount(),
           commitmentId: submission[1],
-          blockNumber: getBlockNumberFromState()
+          blockNumber
         });
         setValidChallengeTimeout();
       }
     });
   };
+  const cancel = async () => {
+    console.log("cancel");
+    clearTimeout();
+    resetState();
+    events.onClose();
+  };
   const select = (hash) => {
     if (!state.challenge) {
       throw new Error("cannot select, no challenge found");
@@ -178,9 +271,17 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
     if (state.index >= state.challenge.captchas.length || state.index < 0) {
       throw new Error("cannot select, round index out of range");
     }
-    const solution = util.at(state.solutions, state.index);
-    handleIsSelected(solution, hash);
-    updateState({ solutions: state.solutions });
+    const index = state.index;
+    const solutions = state.solutions;
+    const solution = util.at(solutions, index);
+    if (solution.includes(hash)) {
+      console.log("deselecting", hash);
+      solution.splice(solution.indexOf(hash), 1);
+    } else {
+      console.log("selecting", hash);
+      solution.push(hash);
+    }
+    updateState({ solutions });
   };
   const nextRound = () => {
     if (!state.challenge) {
@@ -189,161 +290,44 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
     if (state.index + 1 >= state.challenge.captchas.length) {
       throw new Error("cannot proceed to next round, already at last round");
     }
+    console.log("proceeding to next round");
     updateState({ index: state.index + 1 });
   };
   const loadCaptchaApi = async (contract2, provider, providerApi) => {
-    updateState({
-      captchaApi: new ProsopoCaptchaApi.ProsopoCaptchaApi(
-        getAccount().account.address,
-        contract2,
-        provider,
-        providerApi,
-        getConfig().web2,
-        getDappAccount()
-      )
-    });
-    return getCaptchaApi();
-  };
-  const createBlockObservable = () => new rxjs.Observable(
-    (subscriber) => () => api.ApiPromise.create({ provider: new api.WsProvider(getNetwork(getConfig()).endpoint) }).then((api2) => {
-      api2.rpc.chain.subscribeNewHeads((header) => {
-        subscriber.next(header);
-      });
-    }).catch((error) => {
-      subscriber.error(error);
-    })
-  );
-  const loadAccount = async () => {
     const config = getConfig();
-    if (!config.web2 && !config.userAccountAddress) {
-      throw new Error("Account address has not been set for web3 mode");
-    }
-    const ext = config.web2 ? new ExtensionWeb2() : new ExtensionWeb3();
-    const account = await ext.getAccount(config);
-    storage.setAccount(account.account.address);
-    updateState({ account });
-    return getAccount();
+    const captchaApi = new ProsopoCaptchaApi.ProsopoCaptchaApi(
+      getAccount().account.address,
+      contract2,
+      provider,
+      providerApi,
+      config.web2,
+      getDappAccount()
+    );
+    updateState({ captchaApi });
+    return getCaptchaApi();
   };
   const loadProviderApi = async (providerUrl) => {
     const config = getConfig();
+    const network = getNetwork(config);
     if (!config.account.address) {
       throw new common.ProsopoEnvError("GENERAL.SITE_KEY_MISSING");
     }
-    return new api$1.ProviderApi(getNetwork(config), providerUrl, config.account.address);
-  };
-  const loadContract = async () => {
-    const network = getNetwork(getConfig());
-    const api$12 = await api.ApiPromise.create({ provider: new api.WsProvider(network.endpoint) });
-    const type = "sr25519";
-    return new contract.ProsopoCaptchaContract(
-      api$12,
-      JSON.parse(captcha.ContractAbi),
-      network.contract.address,
-      "prosopo",
-      0,
-      new api.Keyring({ type, ss58Format: api$12.registry.chainSS58 }).addFromAddress(getAccount().account.address)
-    );
-  };
-  function handleIsSelected(solution, hash) {
-    if (solution.includes(hash)) {
-      solution.splice(solution.indexOf(hash), 1);
-    } else {
-      solution.push(hash);
-    }
-  }
-  function getSolutionsFromState(salt) {
-    if (!state.challenge) {
-      throw new Error("cannot get solutions, no challenge found");
-    }
-    return state.challenge.captchas.map((captcha2, index) => ({
-      captchaId: captcha2.captcha.captchaId,
-      captchaContentId: captcha2.captcha.captchaContentId,
-      salt,
-      solution: util.at(state.solutions, index)
-    }));
-  }
-  function handleHumanInCachedProvider(providerUrlFromStorage, account, verifyDappUserResponse) {
-    updateState({ isHuman: true, loading: false });
-    events.onHuman({
-      providerUrl: providerUrlFromStorage,
-      user: account.account.address,
-      dapp: getDappAccount(),
-      commitmentId: verifyDappUserResponse.commitmentId
-    });
-    setValidChallengeTimeout();
-  }
-  function getVerifyDappUserFunction(providerUrlFromStorage, account) {
-    return loadProviderApi(providerUrlFromStorage).then(
-      (providerApi) => providerApi.verifyDappUser(account.account.address)
-    );
-  }
-  function handleHumanInContract(account) {
-    updateState({ isHuman: true, loading: false });
-    events.onHuman({
-      user: account.account.address,
-      dapp: getDappAccount()
-    });
-    setValidChallengeTimeout();
-  }
-  async function checkHumanInContract(contract2, account) {
-    try {
-      return await contract2.query.dappOperatorIsHumanUser(account.account.address, getConfig().solutionThreshold).then((res) => res.value.unwrap().unwrap());
-    } catch (err) {
-      console.error(err);
-      return false;
-    }
-  }
-  function getChallenge(getRandomProviderResponse2, contract2) {
-    return loadProviderApi(common.trimProviderUrl(getRandomProviderResponse2.provider.url.toString())).then((api2) => loadCaptchaApi(contract2, getRandomProviderResponse2, api2)).then((captchaApi) => captchaApi.getCaptchaChallenge());
-  }
-  function getRandomProviderResponse(contract$1, account) {
-    return rxjs.lastValueFrom(
-      rxjs.from(
-        contract.wrapQuery(contract$1.query.getRandomActiveProvider, contract$1.query)(
-          account.account.address,
-          getDappAccount()
-        )
-      ).pipe(
-        operators.retry({
-          count: 3,
-          delay: (error, retryCount) => {
-            console.error(`Attempt ${retryCount} failed. Retrying on next block. Error: ${error}`);
-            return createBlockObservable().pipe(operators.take(1));
-          },
-          resetOnSuccess: true
-        })
-      )
-    );
-  }
-  function setTimeToComplete(challenge) {
-    return setTimeout(
-      () => {
-        events.onChallengeExpired();
-        updateState({ isHuman: false, showModal: false, loading: false });
-      },
-      challenge.captchas.map((captcha2) => captcha2.captcha.timeLimitMs || 30 * 1e3).reduce((a, b) => a + b)
-    );
-  }
-  const setValidChallengeTimeout = () => {
-    updateState({
-      successfullChallengeTimeout: setTimeout(
-        () => {
-          updateState({ isHuman: false });
-          events.onExpired();
-        },
-        configOptional.challengeValidLength || 120 * 1e3
-      )
-    });
-  };
-  const cancel = async () => {
-    clearTimeout();
-    resetState();
-    events.onClose();
+    return new api.ProviderApi(network, providerUrl, config.account.address);
   };
   const clearTimeout = () => {
     window.clearTimeout(state.timeout);
     updateState({ timeout: void 0 });
   };
+  const setValidChallengeTimeout = () => {
+    console.log("setting valid challenge timeout");
+    const timeMillis = configOptional.challengeValidLength || 120 * 1e3;
+    const successfullChallengeTimeout = setTimeout(() => {
+      console.log("valid challenge expired after " + timeMillis + "ms");
+      updateState({ isHuman: false });
+      events.onExpired();
+    }, timeMillis);
+    updateState({ successfullChallengeTimeout });
+  };
   const resetState = () => {
     clearTimeout();
     updateState(defaultState());
@@ -354,37 +338,54 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
     }
     return state.captchaApi;
   };
+  const loadAccount = async () => {
+    const config = getConfig();
+    if (!config.web2 && !config.userAccountAddress) {
+      throw new Error("Account address has not been set for web3 mode");
+    }
+    const ext = config.web2 ? new ExtensionWeb2() : new ExtensionWeb3();
+    const account = await ext.getAccount(config);
+    storage.setAccount(account.account.address);
+    console.log("Using account:", account);
+    updateState({ account });
+    return getAccount();
+  };
   const getAccount = () => {
     if (!state.account) {
       throw new Error("Account not loaded");
     }
-    return state.account;
+    const account = state.account;
+    return account;
   };
   const getDappAccount = () => {
     if (!state.dappAccount) {
       throw new common.ProsopoEnvError("GENERAL.SITE_KEY_MISSING");
     }
-    return state.dappAccount;
+    const dappAccount = state.dappAccount;
+    return dappAccount;
   };
-  const getBlockNumberFromState = () => {
+  const getBlockNumber = () => {
     if (!state.blockNumber) {
       throw new Error("Account not loaded");
     }
-    return state.blockNumber;
+    const blockNumber = state.blockNumber;
+    return blockNumber;
+  };
+  const loadContract = async () => {
+    const config = getConfig();
+    const network = getNetwork(config);
+    const api2 = await Api.ApiPromise.create({ provider: new ws.WsProvider(network.endpoint), initWasm: false });
+    const type = "sr25519";
+    const keyring$1 = new keyring.Keyring({ type, ss58Format: api2.registry.chainSS58 });
+    return new contract.ProsopoCaptchaContract(
+      api2,
+      JSON.parse(contractInfo.ContractAbi),
+      network.contract.address,
+      "prosopo",
+      0,
+      keyring$1.addFromAddress(getAccount().account.address)
+    );
   };
-  function getBlockNumberFromProvider(getRandomProviderResponse2) {
-    return parseInt(getRandomProviderResponse2.blockNumber.toString());
-  }
-  function getDatasetId() {
-    if (!state.challenge) {
-      throw new Error("cannot get datasetId, no challenge found");
-    }
-    const datasetId = util.at(state.challenge.captchas, 0).captcha.datasetId;
-    if (!datasetId) {
-      throw new Error("No datasetId set for challenge");
-    }
-    return datasetId;
-  }
   return {
     start,
     cancel,

package/dist/cjs/modules/ProsopoCaptchaApi.cjs

@@ -1,12 +1,10 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-require("../packages/datasets/dist/index.cjs");
+const datasets = require("@prosopo/datasets");
 const handlers = require("../api/handlers.cjs");
 const common = require("@prosopo/common");
 const util = require("@prosopo/util");
-const util$1 = require("@polkadot/util");
-const merkle = require("../packages/datasets/dist/captcha/merkle.cjs");
-const captcha = require("../packages/datasets/dist/captcha/captcha.cjs");
+const string = require("@polkadot/util/string");
 class ProsopoCaptchaApi {
   constructor(userAccount, contract, provider, providerApi, web2, dappAccount) {
     this.userAccount = userAccount;
@@ -37,7 +35,7 @@ class ProsopoCaptchaApi {
       if (!verifyCaptchaData(captchaWithProof)) {
         throw new common.ProsopoEnvError("CAPTCHA.INVALID_CAPTCHA_CHALLENGE");
       }
-      if (!merkle.verifyProof(captchaWithProof.captcha.captchaContentId, captchaWithProof.proof)) {
+      if (!datasets.verifyProof(captchaWithProof.captcha.captchaContentId, captchaWithProof.proof)) {
         throw new common.ProsopoEnvError("CAPTCHA.INVALID_CAPTCHA_CHALLENGE");
       }
     }
@@ -45,8 +43,8 @@ class ProsopoCaptchaApi {
     return;
   }
   async submitCaptchaSolution(signer, requestHash, datasetId, solutions, salt) {
-    const tree = new merkle.CaptchaMerkleTree();
-    const captchasHashed = solutions.map((captcha$1) => captcha.computeCaptchaSolutionHash(captcha$1));
+    const tree = new datasets.CaptchaMerkleTree();
+    const captchasHashed = solutions.map((captcha) => datasets.computeCaptchaSolutionHash(captcha));
     tree.build(captchasHashed);
     const commitmentId = tree.root.hash;
     console.log("solveCaptchaChallenge commitmentId", commitmentId);
@@ -58,7 +56,7 @@ class ProsopoCaptchaApi {
       }
       const signed = await signer.signRaw({
         address: this.userAccount,
-        data: util$1.stringToHex(requestHash),
+        data: string.stringToHex(requestHash),
         type: "bytes"
       });
       signature = signed.signature;
@@ -79,15 +77,15 @@ class ProsopoCaptchaApi {
   }
 }
 async function verifyCaptchaData(captchaWithProof) {
-  const captcha$1 = captchaWithProof.captcha;
+  const captcha = captchaWithProof.captcha;
   const proof = captchaWithProof.proof;
-  if (!(await Promise.all(captcha$1.items.map(async (item) => (await captcha.computeItemHash(item)).hash === item.hash))).every(
+  if (!(await Promise.all(captcha.items.map(async (item) => (await datasets.computeItemHash(item)).hash === item.hash))).every(
     (hash) => hash === true
   )) {
     return false;
   }
-  const captchaHash = captcha.computeCaptchaHash(captcha$1, false, false, false);
-  if (captchaHash !== captcha$1.captchaContentId) {
+  const captchaHash = datasets.computeCaptchaHash(captcha, false, false, false);
+  if (captchaHash !== captcha.captchaContentId) {
     return false;
   }
   return util.at(proof, 0).indexOf(captchaHash) !== -1;

package/dist/modules/Manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Manager.d.ts","sourceRoot":"","sources":["../../src/modules/Manager.ts"],"names":[],"mappings":"AAaA,OAAO,EAEH,mBAAmB,EACnB,wBAAwB,EAExB,eAAe,EACf,uBAAuB,EAC1B,MAAM,qBAAqB,CAAA;AAG5B,OAAO,EAAmB,4BAA4B,EAA0B,MAAM,gBAAgB,CAAA;AAetG,eAAO,MAAM,YAAY,QAAO,QAAQ,eAAe,CASrD,CAAA;AAQF,eAAO,MAAM,UAAU,WAAY,4BAA4B;;;;;;;;CAM9D,CAAA;AAED;;GAEG;AACH,wBAAgB,OAAO,CACnB,cAAc,EAAE,wBAAwB,EACxC,KAAK,EAAE,eAAe,EACtB,aAAa,EAAE,uBAAuB,EACtC,SAAS,EAAE,mBAAmB;;;;mBAqLR,MAAM;;EA4V/B"}
+{"version":3,"file":"Manager.d.ts","sourceRoot":"","sources":["../../src/modules/Manager.ts"],"names":[],"mappings":"AAaA,OAAO,EAEH,mBAAmB,EACnB,wBAAwB,EAExB,eAAe,EACf,uBAAuB,EAC1B,MAAM,qBAAqB,CAAA;AAG5B,OAAO,EAGH,4BAA4B,EAE/B,MAAM,gBAAgB,CAAA;AAmBvB,eAAO,MAAM,YAAY,QAAO,QAAQ,eAAe,CAatD,CAAA;AAgBD,eAAO,MAAM,UAAU,WAAY,4BAA4B;;;;;;;;CAM9D,CAAA;AAED;;GAEG;AACH,wBAAgB,OAAO,CACnB,cAAc,EAAE,wBAAwB,EACxC,KAAK,EAAE,eAAe,EACtB,aAAa,EAAE,uBAAuB,EACtC,SAAS,EAAE,mBAAmB;;;;mBAmTR,MAAM;;EA+K/B"}