@rainhole/rain-code 1.1.0

package/dist/chunk-75zk7zr1.js

@@ -0,0 +1,309 @@
+// @bun
+import {
+  init_useKeybinding,
+  useKeybindings
+} from "./chunk-xnav6j8h.js";
+import {
+  getOAuthHeaders,
+  init_api,
+  prepareApiRequest
+} from "./chunk-2ekjxh7d.js";
+import {
+  getGlobalConfig,
+  getOauthAccountInfo,
+  getSubscriptionType,
+  init_auth,
+  init_config1 as init_config,
+  isClaudeAISubscriber,
+  saveGlobalConfig
+} from "./chunk-7b6bg1r4.js";
+import {
+  getOauthConfig,
+  init_oauth
+} from "./chunk-q82r31er.js";
+import {
+  init_src,
+  use_app_default
+} from "./chunk-cmsknj6n.js";
+import {
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  init_log,
+  init_privacyLevel,
+  isEssentialTrafficOnly,
+  logError
+} from "./chunk-y3r7v9pq.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-404qm8xt.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-nh3cd07f.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/hooks/useDoublePress.ts
+function useDoublePress(setPending, onDoublePress, onFirstPress) {
+  const lastPressRef = import_react.useRef(0);
+  const timeoutRef = import_react.useRef(undefined);
+  const clearTimeoutSafe = import_react.useCallback(() => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = undefined;
+    }
+  }, []);
+  import_react.useEffect(() => {
+    return () => {
+      clearTimeoutSafe();
+    };
+  }, [clearTimeoutSafe]);
+  return import_react.useCallback(() => {
+    const now = Date.now();
+    const timeSinceLastPress = now - lastPressRef.current;
+    const isDoublePress = timeSinceLastPress <= DOUBLE_PRESS_TIMEOUT_MS && timeoutRef.current !== undefined;
+    if (isDoublePress) {
+      clearTimeoutSafe();
+      setPending(false);
+      onDoublePress();
+    } else {
+      onFirstPress?.();
+      setPending(true);
+      clearTimeoutSafe();
+      timeoutRef.current = setTimeout((setPending2, timeoutRef2) => {
+        setPending2(false);
+        timeoutRef2.current = undefined;
+      }, DOUBLE_PRESS_TIMEOUT_MS, setPending, timeoutRef);
+    }
+    lastPressRef.current = now;
+  }, [setPending, onDoublePress, onFirstPress, clearTimeoutSafe]);
+}
+var import_react, DOUBLE_PRESS_TIMEOUT_MS = 800;
+var init_useDoublePress = __esm(() => {
+  import_react = __toESM(require_react(), 1);
+});
+
+// src/hooks/useExitOnCtrlCD.ts
+function useExitOnCtrlCD(useKeybindingsHook, onInterrupt, onExit, isActive = true) {
+  const { exit } = use_app_default();
+  const [exitState, setExitState] = import_react2.useState({
+    pending: false,
+    keyName: null
+  });
+  const exitFn = import_react2.useMemo(() => onExit ?? exit, [onExit, exit]);
+  const handleCtrlCDoublePress = useDoublePress((pending) => setExitState({ pending, keyName: "Ctrl-C" }), exitFn);
+  const handleCtrlDDoublePress = useDoublePress((pending) => setExitState({ pending, keyName: "Ctrl-D" }), exitFn);
+  const handleInterrupt = import_react2.useCallback(() => {
+    if (onInterrupt?.())
+      return;
+    handleCtrlCDoublePress();
+  }, [handleCtrlCDoublePress, onInterrupt]);
+  const handleExit = import_react2.useCallback(() => {
+    handleCtrlDDoublePress();
+  }, [handleCtrlDDoublePress]);
+  const handlers = import_react2.useMemo(() => ({
+    "app:interrupt": handleInterrupt,
+    "app:exit": handleExit
+  }), [handleInterrupt, handleExit]);
+  useKeybindingsHook(handlers, { context: "Global", isActive });
+  return exitState;
+}
+var import_react2;
+var init_useExitOnCtrlCD = __esm(() => {
+  init_src();
+  init_useDoublePress();
+  import_react2 = __toESM(require_react(), 1);
+});
+
+// src/hooks/useExitOnCtrlCDWithKeybindings.ts
+function useExitOnCtrlCDWithKeybindings(onExit, onInterrupt, isActive) {
+  return useExitOnCtrlCD(useKeybindings, onInterrupt, onExit, isActive);
+}
+var init_useExitOnCtrlCDWithKeybindings = __esm(() => {
+  init_useKeybinding();
+  init_useExitOnCtrlCD();
+});
+
+// src/services/api/referral.ts
+async function fetchReferralEligibility(campaign = "claude_code_guest_pass") {
+  const { accessToken, orgUUID } = await prepareApiRequest();
+  const headers = {
+    ...getOAuthHeaders(accessToken),
+    "x-organization-uuid": orgUUID
+  };
+  const url = `${getOauthConfig().BASE_API_URL}/api/oauth/organizations/${orgUUID}/referral/eligibility`;
+  const response = await axios_default.get(url, {
+    headers,
+    params: { campaign },
+    timeout: 5000
+  });
+  return response.data;
+}
+async function fetchReferralRedemptions(campaign = "claude_code_guest_pass") {
+  const { accessToken, orgUUID } = await prepareApiRequest();
+  const headers = {
+    ...getOAuthHeaders(accessToken),
+    "x-organization-uuid": orgUUID
+  };
+  const url = `${getOauthConfig().BASE_API_URL}/api/oauth/organizations/${orgUUID}/referral/redemptions`;
+  const response = await axios_default.get(url, {
+    headers,
+    params: { campaign },
+    timeout: 1e4
+  });
+  return response.data;
+}
+function shouldCheckForPasses() {
+  return !!(getOauthAccountInfo()?.organizationUuid && isClaudeAISubscriber() && getSubscriptionType() === "max");
+}
+function checkCachedPassesEligibility() {
+  if (!shouldCheckForPasses()) {
+    return {
+      eligible: false,
+      needsRefresh: false,
+      hasCache: false
+    };
+  }
+  const orgId = getOauthAccountInfo()?.organizationUuid;
+  if (!orgId) {
+    return {
+      eligible: false,
+      needsRefresh: false,
+      hasCache: false
+    };
+  }
+  const config = getGlobalConfig();
+  const cachedEntry = config.passesEligibilityCache?.[orgId];
+  if (!cachedEntry) {
+    return {
+      eligible: false,
+      needsRefresh: true,
+      hasCache: false
+    };
+  }
+  const { eligible, timestamp } = cachedEntry;
+  const now = Date.now();
+  const needsRefresh = now - timestamp > CACHE_EXPIRATION_MS;
+  return {
+    eligible,
+    needsRefresh,
+    hasCache: true
+  };
+}
+function formatCreditAmount(reward) {
+  const symbol = CURRENCY_SYMBOLS[reward.currency] ?? `${reward.currency} `;
+  const amount = reward.amount_minor_units / 100;
+  const formatted = amount % 1 === 0 ? amount.toString() : amount.toFixed(2);
+  return `${symbol}${formatted}`;
+}
+function getCachedReferrerReward() {
+  const orgId = getOauthAccountInfo()?.organizationUuid;
+  if (!orgId)
+    return null;
+  const config = getGlobalConfig();
+  const cachedEntry = config.passesEligibilityCache?.[orgId];
+  return cachedEntry?.referrer_reward ?? null;
+}
+function getCachedRemainingPasses() {
+  const orgId = getOauthAccountInfo()?.organizationUuid;
+  if (!orgId)
+    return null;
+  const config = getGlobalConfig();
+  const cachedEntry = config.passesEligibilityCache?.[orgId];
+  return cachedEntry?.remaining_passes ?? null;
+}
+async function fetchAndStorePassesEligibility() {
+  if (fetchInProgress) {
+    logForDebugging("Passes: Reusing in-flight eligibility fetch");
+    return fetchInProgress;
+  }
+  const orgId = getOauthAccountInfo()?.organizationUuid;
+  if (!orgId) {
+    return null;
+  }
+  fetchInProgress = (async () => {
+    try {
+      const response = await fetchReferralEligibility();
+      const cacheEntry = {
+        ...response,
+        timestamp: Date.now()
+      };
+      saveGlobalConfig((current) => ({
+        ...current,
+        passesEligibilityCache: {
+          ...current.passesEligibilityCache,
+          [orgId]: cacheEntry
+        }
+      }));
+      logForDebugging(`Passes eligibility cached for org ${orgId}: ${response.eligible}`);
+      return response;
+    } catch (error) {
+      logForDebugging("Failed to fetch and cache passes eligibility");
+      logError(error);
+      return null;
+    } finally {
+      fetchInProgress = null;
+    }
+  })();
+  return fetchInProgress;
+}
+async function getCachedOrFetchPassesEligibility() {
+  if (!shouldCheckForPasses()) {
+    return null;
+  }
+  const orgId = getOauthAccountInfo()?.organizationUuid;
+  if (!orgId) {
+    return null;
+  }
+  const config = getGlobalConfig();
+  const cachedEntry = config.passesEligibilityCache?.[orgId];
+  const now = Date.now();
+  if (!cachedEntry) {
+    logForDebugging("Passes: No cache, fetching eligibility in background (command unavailable this session)");
+    fetchAndStorePassesEligibility();
+    return null;
+  }
+  if (now - cachedEntry.timestamp > CACHE_EXPIRATION_MS) {
+    logForDebugging("Passes: Cache stale, returning cached data and refreshing in background");
+    fetchAndStorePassesEligibility();
+    const { timestamp: timestamp2, ...response2 } = cachedEntry;
+    return response2;
+  }
+  logForDebugging("Passes: Using fresh cached eligibility data");
+  const { timestamp, ...response } = cachedEntry;
+  return response;
+}
+async function prefetchPassesEligibility() {
+  if (isEssentialTrafficOnly()) {
+    return;
+  }
+  getCachedOrFetchPassesEligibility();
+}
+var CACHE_EXPIRATION_MS, fetchInProgress = null, CURRENCY_SYMBOLS;
+var init_referral = __esm(() => {
+  init_axios();
+  init_oauth();
+  init_auth();
+  init_config();
+  init_debug();
+  init_log();
+  init_privacyLevel();
+  init_api();
+  CACHE_EXPIRATION_MS = 24 * 60 * 60 * 1000;
+  CURRENCY_SYMBOLS = {
+    USD: "$",
+    EUR: "\u20AC",
+    GBP: "\xA3",
+    BRL: "R$",
+    CAD: "CA$",
+    AUD: "A$",
+    NZD: "NZ$",
+    SGD: "S$"
+  };
+});
+
+export { useDoublePress, init_useDoublePress, useExitOnCtrlCDWithKeybindings, init_useExitOnCtrlCDWithKeybindings, fetchReferralRedemptions, checkCachedPassesEligibility, formatCreditAmount, getCachedReferrerReward, getCachedRemainingPasses, getCachedOrFetchPassesEligibility, prefetchPassesEligibility, init_referral };

package/dist/chunk-760252na.js

@@ -0,0 +1,101 @@
+// @bun
+import {
+  __commonJS
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/base64-js@1.5.1/node_modules/base64-js/index.js
+var require_base64_js = __commonJS((exports) => {
+  exports.byteLength = byteLength;
+  exports.toByteArray = toByteArray;
+  exports.fromByteArray = fromByteArray;
+  var lookup = [];
+  var revLookup = [];
+  var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
+  var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  for (i = 0, len = code.length;i < len; ++i) {
+    lookup[i] = code[i];
+    revLookup[code.charCodeAt(i)] = i;
+  }
+  var i;
+  var len;
+  revLookup[45] = 62;
+  revLookup[95] = 63;
+  function getLens(b64) {
+    var len2 = b64.length;
+    if (len2 % 4 > 0) {
+      throw new Error("Invalid string. Length must be a multiple of 4");
+    }
+    var validLen = b64.indexOf("=");
+    if (validLen === -1)
+      validLen = len2;
+    var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
+    return [validLen, placeHoldersLen];
+  }
+  function byteLength(b64) {
+    var lens = getLens(b64);
+    var validLen = lens[0];
+    var placeHoldersLen = lens[1];
+    return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+  }
+  function _byteLength(b64, validLen, placeHoldersLen) {
+    return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+  }
+  function toByteArray(b64) {
+    var tmp;
+    var lens = getLens(b64);
+    var validLen = lens[0];
+    var placeHoldersLen = lens[1];
+    var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+    var curByte = 0;
+    var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;
+    var i2;
+    for (i2 = 0;i2 < len2; i2 += 4) {
+      tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)];
+      arr[curByte++] = tmp >> 16 & 255;
+      arr[curByte++] = tmp >> 8 & 255;
+      arr[curByte++] = tmp & 255;
+    }
+    if (placeHoldersLen === 2) {
+      tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4;
+      arr[curByte++] = tmp & 255;
+    }
+    if (placeHoldersLen === 1) {
+      tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2;
+      arr[curByte++] = tmp >> 8 & 255;
+      arr[curByte++] = tmp & 255;
+    }
+    return arr;
+  }
+  function tripletToBase64(num) {
+    return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+  }
+  function encodeChunk(uint8, start, end) {
+    var tmp;
+    var output = [];
+    for (var i2 = start;i2 < end; i2 += 3) {
+      tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);
+      output.push(tripletToBase64(tmp));
+    }
+    return output.join("");
+  }
+  function fromByteArray(uint8) {
+    var tmp;
+    var len2 = uint8.length;
+    var extraBytes = len2 % 3;
+    var parts = [];
+    var maxChunkLength = 16383;
+    for (var i2 = 0, len22 = len2 - extraBytes;i2 < len22; i2 += maxChunkLength) {
+      parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));
+    }
+    if (extraBytes === 1) {
+      tmp = uint8[len2 - 1];
+      parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
+    } else if (extraBytes === 2) {
+      tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];
+      parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=");
+    }
+    return parts.join("");
+  }
+});
+
+export { require_base64_js };

package/dist/chunk-764ec4ja.js

@@ -0,0 +1,173 @@
+// @bun
+import {
+  ENV_KEY,
+  ENV_SECRET,
+  fromEnv,
+  init_dist_es
+} from "./chunk-3h8a89gy.js";
+import {
+  require_dist_cjs as require_dist_cjs2
+} from "./chunk-n0qaeaa5.js";
+import {
+  require_dist_cjs
+} from "./chunk-hk9xz7gk.js";
+import {
+  __esm,
+  __require,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@aws-sdk+credential-provider-node@3.972.28/node_modules/@aws-sdk/credential-provider-node/dist-es/remoteProvider.js
+var import_property_provider, ENV_IMDS_DISABLED = "AWS_EC2_METADATA_DISABLED", remoteProvider = async (init) => {
+  const { ENV_CMDS_FULL_URI, ENV_CMDS_RELATIVE_URI, fromContainerMetadata, fromInstanceMetadata } = await import("./chunk-238g70xa.js");
+  if (process.env[ENV_CMDS_RELATIVE_URI] || process.env[ENV_CMDS_FULL_URI]) {
+    init.logger?.debug("@aws-sdk/credential-provider-node - remoteProvider::fromHttp/fromContainerMetadata");
+    const { fromHttp } = await import("./chunk-hh7cmy4k.js");
+    return import_property_provider.chain(fromHttp(init), fromContainerMetadata(init));
+  }
+  if (process.env[ENV_IMDS_DISABLED] && process.env[ENV_IMDS_DISABLED] !== "false") {
+    return async () => {
+      throw new import_property_provider.CredentialsProviderError("EC2 Instance Metadata Service access disabled", { logger: init.logger });
+    };
+  }
+  init.logger?.debug("@aws-sdk/credential-provider-node - remoteProvider::fromInstanceMetadata");
+  return fromInstanceMetadata(init);
+};
+var init_remoteProvider = __esm(() => {
+  import_property_provider = __toESM(require_dist_cjs(), 1);
+});
+
+// node_modules/.bun/@aws-sdk+credential-provider-node@3.972.28/node_modules/@aws-sdk/credential-provider-node/dist-es/runtime/memoize-chain.js
+function memoizeChain(providers, treatAsExpired) {
+  const chain2 = internalCreateChain(providers);
+  let activeLock;
+  let passiveLock;
+  let credentials;
+  const provider = async (options) => {
+    if (options?.forceRefresh) {
+      return await chain2(options);
+    }
+    if (credentials?.expiration) {
+      if (credentials?.expiration?.getTime() < Date.now()) {
+        credentials = undefined;
+      }
+    }
+    if (activeLock) {
+      await activeLock;
+    } else if (!credentials || treatAsExpired?.(credentials)) {
+      if (credentials) {
+        if (!passiveLock) {
+          passiveLock = chain2(options).then((c) => {
+            credentials = c;
+          }).finally(() => {
+            passiveLock = undefined;
+          });
+        }
+      } else {
+        activeLock = chain2(options).then((c) => {
+          credentials = c;
+        }).finally(() => {
+          activeLock = undefined;
+        });
+        return provider(options);
+      }
+    }
+    return credentials;
+  };
+  return provider;
+}
+var internalCreateChain = (providers) => async (awsIdentityProperties) => {
+  let lastProviderError;
+  for (const provider of providers) {
+    try {
+      return await provider(awsIdentityProperties);
+    } catch (err) {
+      lastProviderError = err;
+      if (err?.tryNextLink) {
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw lastProviderError;
+};
+var init_memoize_chain = () => {};
+
+// node_modules/.bun/@aws-sdk+credential-provider-node@3.972.28/node_modules/@aws-sdk/credential-provider-node/dist-es/defaultProvider.js
+var import_property_provider2, import_shared_ini_file_loader, multipleCredentialSourceWarningEmitted = false, defaultProvider = (init = {}) => memoizeChain([
+  async () => {
+    const profile = init.profile ?? process.env[import_shared_ini_file_loader.ENV_PROFILE];
+    if (profile) {
+      const envStaticCredentialsAreSet = process.env[ENV_KEY] && process.env[ENV_SECRET];
+      if (envStaticCredentialsAreSet) {
+        if (!multipleCredentialSourceWarningEmitted) {
+          const warnFn = init.logger?.warn && init.logger?.constructor?.name !== "NoOpLogger" ? init.logger.warn.bind(init.logger) : console.warn;
+          warnFn(`@aws-sdk/credential-provider-node - defaultProvider::fromEnv WARNING:
+    Multiple credential sources detected: 
+    Both AWS_PROFILE and the pair AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY static credentials are set.
+    This SDK will proceed with the AWS_PROFILE value.
+    
+    However, a future version may change this behavior to prefer the ENV static credentials.
+    Please ensure that your environment only sets either the AWS_PROFILE or the
+    AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY pair.
+`);
+          multipleCredentialSourceWarningEmitted = true;
+        }
+      }
+      throw new import_property_provider2.CredentialsProviderError("AWS_PROFILE is set, skipping fromEnv provider.", {
+        logger: init.logger,
+        tryNextLink: true
+      });
+    }
+    init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromEnv");
+    return fromEnv(init)();
+  },
+  async (awsIdentityProperties) => {
+    init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromSSO");
+    const { ssoStartUrl, ssoAccountId, ssoRegion, ssoRoleName, ssoSession } = init;
+    if (!ssoStartUrl && !ssoAccountId && !ssoRegion && !ssoRoleName && !ssoSession) {
+      throw new import_property_provider2.CredentialsProviderError("Skipping SSO provider in default chain (inputs do not include SSO fields).", { logger: init.logger });
+    }
+    const { fromSSO } = await import("./chunk-ca147npg.js");
+    return fromSSO(init)(awsIdentityProperties);
+  },
+  async (awsIdentityProperties) => {
+    init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromIni");
+    const { fromIni } = await import("./chunk-4ptqcw4p.js");
+    return fromIni(init)(awsIdentityProperties);
+  },
+  async (awsIdentityProperties) => {
+    init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromProcess");
+    const { fromProcess } = await import("./chunk-677as3nh.js");
+    return fromProcess(init)(awsIdentityProperties);
+  },
+  async (awsIdentityProperties) => {
+    init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromTokenFile");
+    const { fromTokenFile } = await import("./chunk-12hn2mhy.js");
+    return fromTokenFile(init)(awsIdentityProperties);
+  },
+  async () => {
+    init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::remoteProvider");
+    return (await remoteProvider(init))();
+  },
+  async () => {
+    throw new import_property_provider2.CredentialsProviderError("Could not load credentials from any providers", {
+      tryNextLink: false,
+      logger: init.logger
+    });
+  }
+], credentialsTreatedAsExpired), credentialsWillNeedRefresh = (credentials) => credentials?.expiration !== undefined, credentialsTreatedAsExpired = (credentials) => credentials?.expiration !== undefined && credentials.expiration.getTime() - Date.now() < 300000;
+var init_defaultProvider = __esm(() => {
+  init_dist_es();
+  init_remoteProvider();
+  init_memoize_chain();
+  import_property_provider2 = __toESM(require_dist_cjs(), 1);
+  import_shared_ini_file_loader = __toESM(require_dist_cjs2(), 1);
+});
+
+// node_modules/.bun/@aws-sdk+credential-provider-node@3.972.28/node_modules/@aws-sdk/credential-provider-node/dist-es/index.js
+var init_dist_es2 = __esm(() => {
+  init_defaultProvider();
+});
+
+export { defaultProvider, credentialsWillNeedRefresh, credentialsTreatedAsExpired, init_dist_es2 as init_dist_es };

package/dist/chunk-76vgnv24.js

@@ -0,0 +1,108 @@
+// @bun
+import {
+  authLogin,
+  authLogout,
+  authStatus,
+  init_auth1 as init_auth,
+  installOAuthTokens
+} from "./chunk-hknbjky3.js";
+import"./chunk-a4psxnr1.js";
+import"./chunk-613f6fbv.js";
+import"./chunk-zejm280k.js";
+import"./chunk-57qz90z8.js";
+import"./chunk-4nspekjp.js";
+import"./chunk-heq3rn8t.js";
+import"./chunk-var1et7e.js";
+import"./chunk-e0pth8g7.js";
+import"./chunk-ws5d6qs4.js";
+import"./chunk-bxcfz5gy.js";
+import"./chunk-wp1568nt.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-8h6sdj66.js";
+import"./chunk-75zk7zr1.js";
+import"./chunk-j5bth84e.js";
+import"./chunk-qm7nbd10.js";
+import"./chunk-5pevjsyw.js";
+import"./chunk-xnav6j8h.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-2t0xa4dt.js";
+import"./chunk-bgpkemkg.js";
+import"./chunk-rrtzz2pv.js";
+import"./chunk-zsgha506.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-xkt36p6r.js";
+import"./chunk-2ekjxh7d.js";
+import"./chunk-85tag8nv.js";
+import"./chunk-mx28h61f.js";
+import"./chunk-kraf793v.js";
+import"./chunk-bj8x29tz.js";
+import"./chunk-zae0t3p4.js";
+import"./chunk-t58wfamm.js";
+import"./chunk-chsyvavm.js";
+import"./chunk-6mpw9h55.js";
+import"./chunk-7b6bg1r4.js";
+import"./chunk-sg66v252.js";
+import"./chunk-8bwqtasa.js";
+import"./chunk-j9gxwbe3.js";
+import"./chunk-1cwdhk7a.js";
+import"./chunk-rtnjk8ge.js";
+import"./chunk-64c1avct.js";
+import"./chunk-8g5pe1gr.js";
+import"./chunk-gx8016vp.js";
+import"./chunk-4cp6193g.js";
+import"./chunk-8g747a8x.js";
+import"./chunk-d7886r6a.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-r7j395t6.js";
+import"./chunk-tv9pcdnz.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-n9ktjngj.js";
+import"./chunk-q82r31er.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-64hks9ax.js";
+import"./chunk-crmjpsqe.js";
+import"./chunk-cmsknj6n.js";
+import"./chunk-g338npwr.js";
+import"./chunk-h0rbjg6x.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-h1mr3371.js";
+import"./chunk-36b2q5fg.js";
+import"./chunk-a7rhvq9b.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-m74w3187.js";
+import"./chunk-b81hd3m6.js";
+import"./chunk-y3r7v9pq.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-awb4vc41.js";
+import"./chunk-cbrt5vsb.js";
+import"./chunk-5z28bqne.js";
+import"./chunk-qajrkk97.js";
+import"./chunk-404qm8xt.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-jaaxk89e.js";
+import"./chunk-h4b85amj.js";
+import"./chunk-07069jq1.js";
+import"./chunk-vf612n57.js";
+import"./chunk-d4mdda98.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-nh3cd07f.js";
+import"./chunk-8pn8tvgg.js";
+import"./chunk-netzwgv1.js";
+import"./chunk-qp2qdcda.js";
+init_auth();
+
+export {
+  installOAuthTokens,
+  authStatus,
+  authLogout,
+  authLogin
+};