@frak-labs/nexus-sdk 0.0.1-alpha

package/dist/client-SCwoh_kP.d.ts

@@ -0,0 +1,246 @@
+import { Hex, Address, RpcSchema } from 'viem';
+import { Prettify } from 'viem/chains';
+
+/**
+ * Configuration for the Frak Wallet SDK
+ */
+type FrakWalletSdkConfig = Readonly<{
+    walletUrl: string;
+    contentId: Hex;
+    contentTitle: string;
+}>;
+
+type PaidArticleUnlockPrice = Readonly<{
+    index: number;
+    unlockDurationInSec: number;
+    frkAmount: Hex;
+}>;
+
+/**
+ * Request to unlock a paid article
+ */
+type StartArticleUnlockParams = Readonly<{
+    articleId: Hex;
+    contentId: Hex;
+    imageUrl: string;
+    articleTitle: string;
+    contentTitle: string;
+    price: PaidArticleUnlockPrice;
+    articleUrl: string;
+    redirectUrl: string;
+    previewUrl?: string;
+}>;
+/**
+ * Return type of the unlock request
+ */
+type StartArticleUnlockReturnType = UnlockSuccess | AlreadyUnlocked | UnlockError;
+type UnlockSuccess = {
+    key: "success";
+    status: "in-progress";
+    user: Address;
+    userOpHash: Hex;
+};
+type AlreadyUnlocked = {
+    key: "already-unlocked";
+    status: "unlocked";
+    user: Address;
+};
+type UnlockError = {
+    key: "error" | "cancelled";
+    status: "locked";
+    user?: Address;
+    reason?: string;
+};
+
+/**
+ * The response to the get unlock options response
+ */
+type UnlockOptionsReturnType = Readonly<{
+    prices: {
+        index: number;
+        unlockDurationInSec: number;
+        frkAmount: Hex;
+        isUserAccessible: boolean | null;
+    }[];
+}>;
+
+/**
+ * The different types of response for the current unlock status
+ */
+type ArticleUnlockStatusReturnType = Readonly<UnlockStatusLocked | UnlockStatusProcessing | UnlockStatusValid | UnlockStatusError>;
+/**
+ * When the content unlocked was expired a few time ago
+ */
+type UnlockStatusLocked = {
+    key: "expired";
+    status: "locked";
+    expiredAt: number;
+} | {
+    key: "not-unlocked";
+    status: "locked";
+};
+/**
+ * When the content unlocked was expired a few time ago
+ */
+type UnlockStatusProcessing = {
+    key: "preparing" | "waiting-user-validation";
+} | {
+    key: "waiting-transaction-bundling";
+    userOpHash: Hex;
+} | {
+    key: "waiting-transaction-confirmation";
+    userOpHash: Hex;
+    txHash: Hex;
+};
+/**
+ * When the content unlocked was expired a few time ago
+ */
+type UnlockStatusValid = {
+    key: "valid";
+    status: "unlocked";
+    allowedUntil: number;
+};
+/**
+ * When the content unlocked was expired a few time ago
+ */
+type UnlockStatusError = {
+    key: "error";
+    status: "locked";
+    reason: string;
+};
+
+type WalletStatusReturnType = Readonly<WalletConnected | WalletNotConnected>;
+type WalletConnected = {
+    key: "connected";
+    wallet: Address;
+    frkBalanceAsHex: Hex;
+};
+type WalletNotConnected = {
+    key: "not-connected";
+};
+
+/**
+ * RPC interface that's used for the iframe communication
+ */
+type IFrameRpcSchema = [
+    /**
+     * Method used to fetch an article unlock options
+     */
+    {
+        Method: "frak_getArticleUnlockOptions";
+        Parameters: [contentId: Hex, articleId: Hex];
+        ReturnType: UnlockOptionsReturnType;
+    },
+    /**
+     * Method used to listen to the wallet status
+     */
+    {
+        Method: "frak_listenToWalletStatus";
+        Parameters?: undefined;
+        ReturnType: WalletStatusReturnType;
+    },
+    /**
+     * Method used to listen to an article unlock status
+     */
+    {
+        Method: "frak_listenToArticleUnlockStatus";
+        Parameters: [contentId: Hex, articleId: Hex];
+        ReturnType: ArticleUnlockStatusReturnType;
+    }
+];
+/**
+ * RPC interface that's used for the redirection communication
+ */
+type RedirectRpcSchema = [
+    /**
+     * Method used to start the unlock of an article
+     */
+    {
+        Method: "frak_startArticleUnlock";
+        Path: "/paywall";
+        Parameters: StartArticleUnlockParams;
+        ReturnType: StartArticleUnlockReturnType;
+    }
+];
+
+/**
+ * Type that extract the possible parameters from a RPC Schema
+ */
+type ExtractedParametersFromRpc<TRpcSchema extends RpcSchema | undefined = undefined> = TRpcSchema extends RpcSchema ? {
+    [K in keyof TRpcSchema]: Prettify<{
+        method: TRpcSchema[K] extends TRpcSchema[number] ? TRpcSchema[K]["Method"] : string;
+    } & (TRpcSchema[K] extends TRpcSchema[number] ? TRpcSchema[K]["Parameters"] extends undefined ? {
+        params?: never;
+    } : {
+        params: TRpcSchema[K]["Parameters"];
+    } : never)>;
+}[number] : {
+    method: string;
+    params?: unknown;
+};
+/**
+ * Type that extract the possible return type from a RPC Schema
+ */
+type ExtractedReturnTypeFromRpc<TRpcSchema extends RpcSchema | undefined = undefined, TParameters extends ExtractedParametersFromRpc<TRpcSchema> = ExtractedParametersFromRpc<TRpcSchema>> = TRpcSchema extends RpcSchema ? ExtractedMethodFromRpc<TRpcSchema, TParameters["method"]>["ReturnType"] : unknown;
+/**
+ * Type that extract the possible return type from a RPC Schema
+ */
+type ExtractedMethodFromRpc<TRpcSchema extends RpcSchema | undefined = undefined, TMethod extends ExtractedParametersFromRpc<TRpcSchema>["method"] = ExtractedParametersFromRpc<TRpcSchema>["method"]> = TRpcSchema extends RpcSchema ? Extract<TRpcSchema[number], {
+    Method: TMethod;
+}> : unknown;
+/**
+ * Type used for a one shot request function
+ */
+type RequestFn<TRpcSchema extends RpcSchema | undefined = undefined> = <TParameters extends ExtractedParametersFromRpc<TRpcSchema> = ExtractedParametersFromRpc<TRpcSchema>, _ReturnType = ExtractedReturnTypeFromRpc<TRpcSchema, TParameters>>(args: TParameters) => Promise<_ReturnType>;
+/**
+ * Type used for a one shot request function
+ */
+type ListenerRequestFn<TRpcSchema extends RpcSchema | undefined = undefined> = <TParameters extends ExtractedParametersFromRpc<TRpcSchema> = ExtractedParametersFromRpc<TRpcSchema>>(args: TParameters, callback: (result: ExtractedReturnTypeFromRpc<TRpcSchema, TParameters>) => void) => Promise<void>;
+/**
+ * IFrame transport interface
+ */
+type IFrameTransport = {
+    /**
+     * Wait for the connection to be established
+     */
+    waitForConnection: Promise<boolean>;
+    /**
+     * Function used to perform a single request via the iframe transport
+     */
+    request: RequestFn<IFrameRpcSchema>;
+    /**
+     * Function used to listen to a request response via the iframe transport
+     */
+    listenerRequest: ListenerRequestFn<IFrameRpcSchema>;
+    /**
+     * Function used to destroy the iframe transport
+     */
+    destroy: () => Promise<void>;
+};
+/**
+ * Represent an iframe event
+ */
+type IFrameEvent = IFrameRpcEvent | IFrameLifecycleEvent;
+/**
+ * Represent an iframe rpc event
+ */
+type IFrameRpcEvent = {
+    id: string;
+    topic: ExtractedParametersFromRpc<IFrameRpcSchema>["method"];
+    data: {
+        compressed: string;
+        compressedHash: string;
+    };
+};
+type IFrameLifecycleEvent = {
+    lifecycle: "connected";
+};
+
+/**
+ * Representing a Frak client
+ */
+type FrakClient = {
+    config: FrakWalletSdkConfig;
+} & IFrameTransport;
+
+export type { ArticleUnlockStatusReturnType as A, ExtractedParametersFromRpc as E, FrakClient as F, IFrameRpcSchema as I, PaidArticleUnlockPrice as P, RedirectRpcSchema as R, StartArticleUnlockReturnType as S, UnlockOptionsReturnType as U, WalletStatusReturnType as W, FrakWalletSdkConfig as a, StartArticleUnlockParams as b, ExtractedReturnTypeFromRpc as c, IFrameTransport as d, IFrameRpcEvent as e, IFrameEvent as f };

package/dist/core/actions/index.cjs

@@ -0,0 +1,77 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+var _chunk4X75PGSKcjs = require('../../chunk-4X75PGSK.cjs');
+
+// src/core/actions/getUnlockOptions.ts
+function getArticleUnlockOptions(client, { articleId }) {
+  return client.request({
+    method: "frak_getArticleUnlockOptions",
+    params: [client.config.contentId, articleId]
+  });
+}
+
+// src/core/actions/watchUnlockStatus.ts
+function watchUnlockStatus(client, { articleId }, callback) {
+  return client.listenerRequest(
+    {
+      method: "frak_listenToArticleUnlockStatus",
+      params: [client.config.contentId, articleId]
+    },
+    callback
+  );
+}
+
+// src/core/actions/watchWalletStatus.ts
+function watchWalletStatus(client, callback) {
+  return client.listenerRequest(
+    {
+      method: "frak_listenToWalletStatus"
+    },
+    callback
+  );
+}
+
+// src/core/actions/startUnlock.ts
+async function getStartArticleUnlockUrl(config, params) {
+  const { compressed, compressedHash } = await _chunk4X75PGSKcjs.hashAndCompressData.call(void 0, 
+    {
+      method: "frak_startArticleUnlock",
+      params: {
+        ...params,
+        contentId: config.contentId,
+        contentTitle: config.contentTitle
+      }
+    },
+    _chunk4X75PGSKcjs.redirectRequestKeyProvider
+  );
+  const outputUrl = new URL(config.walletUrl);
+  outputUrl.pathname = "/paywall";
+  outputUrl.searchParams.set("params", encodeURIComponent(compressed));
+  outputUrl.searchParams.set("hash", encodeURIComponent(compressedHash));
+  return outputUrl.toString();
+}
+async function decodeStartUnlockReturn({
+  result,
+  hash
+}) {
+  const keyProvider = _chunk4X75PGSKcjs.getRedirectResponseResponseKeyProvider.call(void 0, 
+    "frak_startArticleUnlock"
+  );
+  return _chunk4X75PGSKcjs.decompressDataAndCheckHash.call(void 0, 
+    {
+      compressed: decodeURIComponent(result),
+      compressedHash: decodeURIComponent(hash)
+    },
+    keyProvider
+  );
+}
+
+
+
+
+
+
+exports.decodeStartUnlockReturn = decodeStartUnlockReturn; exports.getArticleUnlockOptions = getArticleUnlockOptions; exports.getStartArticleUnlockUrl = getStartArticleUnlockUrl; exports.watchUnlockStatus = watchUnlockStatus; exports.watchWalletStatus = watchWalletStatus;

package/dist/core/actions/index.d.cts

@@ -0,0 +1,63 @@
+import { Hex } from 'viem';
+import { F as FrakClient, A as ArticleUnlockStatusReturnType, W as WalletStatusReturnType, a as FrakWalletSdkConfig, S as StartArticleUnlockReturnType, b as StartArticleUnlockParams } from '../../client-SCwoh_kP.cjs';
+import 'viem/chains';
+
+/**
+ * Type used to get the unlock options
+ */
+type GetUnlockOptionsParams = {
+    articleId: Hex;
+};
+/**
+ * Function used to fetch the unlock option for the given client
+ * @param client
+ * @param articleId
+ */
+declare function getArticleUnlockOptions(client: FrakClient, { articleId }: GetUnlockOptionsParams): Promise<Readonly<{
+    prices: {
+        index: number;
+        unlockDurationInSec: number;
+        frkAmount: `0x${string}`;
+        isUserAccessible: boolean | null;
+    }[];
+}>>;
+
+/**
+ * Type used to get the unlock options
+ */
+type WatchUnlockStatusParams = {
+    articleId: Hex;
+};
+/**
+ * Function used to watch a current article unlock status
+ * @param client
+ * @param articleId
+ * @param callback
+ */
+declare function watchUnlockStatus(client: FrakClient, { articleId }: WatchUnlockStatusParams, callback: (status: ArticleUnlockStatusReturnType) => void): Promise<void>;
+
+/**
+ * Function used to watch the current nexus wallet status
+ * @param client
+ * @param callback
+ */
+declare function watchWalletStatus(client: FrakClient, callback: (status: WalletStatusReturnType) => void): Promise<void>;
+
+type GetStartUnlockUrlParams = Omit<StartArticleUnlockParams, "contentId" | "contentTitle">;
+/**
+ * Function used to build the unlock URL for a given article
+ * @param config
+ * @param params
+ */
+declare function getStartArticleUnlockUrl(config: FrakWalletSdkConfig, params: GetStartUnlockUrlParams): Promise<string>;
+/**
+ * Function used to decode the response from the start unlock request (return typed passed as query param)
+ */
+declare function decodeStartUnlockReturn({ result, hash, }: {
+    result: string;
+    hash: string;
+}): Promise<Readonly<StartArticleUnlockReturnType & {
+    validationHash: string;
+}>>;
+
+export { decodeStartUnlockReturn, getArticleUnlockOptions, getStartArticleUnlockUrl, watchUnlockStatus, watchWalletStatus };

package/dist/core/actions/index.d.ts

@@ -0,0 +1,63 @@
+import { Hex } from 'viem';
+import { F as FrakClient, A as ArticleUnlockStatusReturnType, W as WalletStatusReturnType, a as FrakWalletSdkConfig, S as StartArticleUnlockReturnType, b as StartArticleUnlockParams } from '../../client-SCwoh_kP.js';
+import 'viem/chains';
+
+/**
+ * Type used to get the unlock options
+ */
+type GetUnlockOptionsParams = {
+    articleId: Hex;
+};
+/**
+ * Function used to fetch the unlock option for the given client
+ * @param client
+ * @param articleId
+ */
+declare function getArticleUnlockOptions(client: FrakClient, { articleId }: GetUnlockOptionsParams): Promise<Readonly<{
+    prices: {
+        index: number;
+        unlockDurationInSec: number;
+        frkAmount: `0x${string}`;
+        isUserAccessible: boolean | null;
+    }[];
+}>>;
+
+/**
+ * Type used to get the unlock options
+ */
+type WatchUnlockStatusParams = {
+    articleId: Hex;
+};
+/**
+ * Function used to watch a current article unlock status
+ * @param client
+ * @param articleId
+ * @param callback
+ */
+declare function watchUnlockStatus(client: FrakClient, { articleId }: WatchUnlockStatusParams, callback: (status: ArticleUnlockStatusReturnType) => void): Promise<void>;
+
+/**
+ * Function used to watch the current nexus wallet status
+ * @param client
+ * @param callback
+ */
+declare function watchWalletStatus(client: FrakClient, callback: (status: WalletStatusReturnType) => void): Promise<void>;
+
+type GetStartUnlockUrlParams = Omit<StartArticleUnlockParams, "contentId" | "contentTitle">;
+/**
+ * Function used to build the unlock URL for a given article
+ * @param config
+ * @param params
+ */
+declare function getStartArticleUnlockUrl(config: FrakWalletSdkConfig, params: GetStartUnlockUrlParams): Promise<string>;
+/**
+ * Function used to decode the response from the start unlock request (return typed passed as query param)
+ */
+declare function decodeStartUnlockReturn({ result, hash, }: {
+    result: string;
+    hash: string;
+}): Promise<Readonly<StartArticleUnlockReturnType & {
+    validationHash: string;
+}>>;
+
+export { decodeStartUnlockReturn, getArticleUnlockOptions, getStartArticleUnlockUrl, watchUnlockStatus, watchWalletStatus };

package/dist/core/actions/index.js

@@ -0,0 +1,77 @@
+import {
+  decompressDataAndCheckHash,
+  getRedirectResponseResponseKeyProvider,
+  hashAndCompressData,
+  redirectRequestKeyProvider
+} from "../../chunk-JE64MPH2.js";
+
+// src/core/actions/getUnlockOptions.ts
+function getArticleUnlockOptions(client, { articleId }) {
+  return client.request({
+    method: "frak_getArticleUnlockOptions",
+    params: [client.config.contentId, articleId]
+  });
+}
+
+// src/core/actions/watchUnlockStatus.ts
+function watchUnlockStatus(client, { articleId }, callback) {
+  return client.listenerRequest(
+    {
+      method: "frak_listenToArticleUnlockStatus",
+      params: [client.config.contentId, articleId]
+    },
+    callback
+  );
+}
+
+// src/core/actions/watchWalletStatus.ts
+function watchWalletStatus(client, callback) {
+  return client.listenerRequest(
+    {
+      method: "frak_listenToWalletStatus"
+    },
+    callback
+  );
+}
+
+// src/core/actions/startUnlock.ts
+async function getStartArticleUnlockUrl(config, params) {
+  const { compressed, compressedHash } = await hashAndCompressData(
+    {
+      method: "frak_startArticleUnlock",
+      params: {
+        ...params,
+        contentId: config.contentId,
+        contentTitle: config.contentTitle
+      }
+    },
+    redirectRequestKeyProvider
+  );
+  const outputUrl = new URL(config.walletUrl);
+  outputUrl.pathname = "/paywall";
+  outputUrl.searchParams.set("params", encodeURIComponent(compressed));
+  outputUrl.searchParams.set("hash", encodeURIComponent(compressedHash));
+  return outputUrl.toString();
+}
+async function decodeStartUnlockReturn({
+  result,
+  hash
+}) {
+  const keyProvider = getRedirectResponseResponseKeyProvider(
+    "frak_startArticleUnlock"
+  );
+  return decompressDataAndCheckHash(
+    {
+      compressed: decodeURIComponent(result),
+      compressedHash: decodeURIComponent(hash)
+    },
+    keyProvider
+  );
+}
+export {
+  decodeStartUnlockReturn,
+  getArticleUnlockOptions,
+  getStartArticleUnlockUrl,
+  watchUnlockStatus,
+  watchWalletStatus
+};

package/dist/core/index.cjs

@@ -0,0 +1,179 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+
+var _chunk4X75PGSKcjs = require('../chunk-4X75PGSK.cjs');
+
+// src/core/utils/Deferred.ts
+var Deferred = class {
+  constructor() {
+    _chunk4X75PGSKcjs.__publicField.call(void 0, this, "_promise");
+    _chunk4X75PGSKcjs.__publicField.call(void 0, this, "_resolve");
+    _chunk4X75PGSKcjs.__publicField.call(void 0, this, "_reject");
+    _chunk4X75PGSKcjs.__publicField.call(void 0, this, "resolve", (value) => {
+      _optionalChain([this, 'access', _ => _._resolve, 'optionalCall', _2 => _2(value)]);
+    });
+    _chunk4X75PGSKcjs.__publicField.call(void 0, this, "reject", (reason) => {
+      _optionalChain([this, 'access', _3 => _3._reject, 'optionalCall', _4 => _4(reason)]);
+    });
+    this._promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  get promise() {
+    return this._promise;
+  }
+};
+
+// src/core/clients/transports/iframeChannelManager.ts
+function createIFrameChannelManager() {
+  const channels = /* @__PURE__ */ new Map();
+  return {
+    // TODO: Better id system?? uid stuff?
+    createChannel: (resolver) => {
+      const id = Math.random().toString(36).substring(7);
+      channels.set(id, resolver);
+      return id;
+    },
+    getRpcResolver: (id) => channels.get(id),
+    removeChannel: (id) => channels.delete(id),
+    destroy: () => channels.clear()
+  };
+}
+
+// src/core/clients/transports/iframeMessageHandler.ts
+function createIFrameMessageHandler({
+  frakWalletUrl,
+  iframe,
+  channelManager
+}) {
+  if (typeof window === "undefined") {
+    throw new Error("iframe client should be used in the browser");
+  }
+  if (!iframe.contentWindow) {
+    throw new Error("The iframe does not have a content window");
+  }
+  const contentWindow = iframe.contentWindow;
+  const isConnected = new Deferred();
+  const msgHandler = async (event) => {
+    if (!event.origin) {
+      return;
+    }
+    if (new URL(event.origin).origin.toLowerCase() !== new URL(frakWalletUrl).origin.toLowerCase()) {
+      return;
+    }
+    if ("lifecycle" in event.data) {
+      isConnected.resolve(event.data.lifecycle === "connected");
+      return;
+    }
+    const channel = event.data.id;
+    const resolver = channelManager.getRpcResolver(channel);
+    if (!resolver) {
+      return;
+    }
+    await resolver(event.data);
+  };
+  window.addEventListener("message", msgHandler);
+  const sendEvent = (message) => {
+    contentWindow.postMessage(message, {
+      targetOrigin: frakWalletUrl
+    });
+  };
+  const cleanup = () => {
+    window.removeEventListener("message", msgHandler);
+  };
+  return {
+    isConnected: isConnected.promise,
+    sendEvent,
+    cleanup
+  };
+}
+
+// src/core/clients/createIFrameFrakClient.ts
+function createIFrameFrakClient({
+  config,
+  iframe
+}) {
+  const channelManager = createIFrameChannelManager();
+  const messageHandler = createIFrameMessageHandler({
+    frakWalletUrl: config.walletUrl,
+    iframe,
+    channelManager
+  });
+  const request = async (args) => {
+    const isConnected = await messageHandler.isConnected;
+    if (!isConnected) {
+      throw new Error("The iframe provider isn't connected yet");
+    }
+    const result = new Deferred();
+    const resultCompressionKeyProvider = _chunk4X75PGSKcjs.getIFrameResponseKeyProvider.call(void 0, args);
+    const channelId = channelManager.createChannel(async (message) => {
+      const decompressed = await _chunk4X75PGSKcjs.decompressDataAndCheckHash.call(void 0, 
+        message.data,
+        resultCompressionKeyProvider
+      );
+      result.resolve(decompressed);
+      channelManager.removeChannel(channelId);
+    });
+    const compressedMessage = await _chunk4X75PGSKcjs.hashAndCompressData.call(void 0, 
+      args,
+      _chunk4X75PGSKcjs.iFrameRequestKeyProvider
+    );
+    messageHandler.sendEvent({
+      id: channelId,
+      topic: args.method,
+      data: compressedMessage
+    });
+    return result.promise;
+  };
+  const listenerRequest = async (args, callback) => {
+    const isConnected = await messageHandler.isConnected;
+    if (!isConnected) {
+      throw new Error("The iframe provider isn't connected yet");
+    }
+    const resultCompressionKeyProvider = _chunk4X75PGSKcjs.getIFrameResponseKeyProvider.call(void 0, args);
+    const channelId = channelManager.createChannel(async (message) => {
+      const decompressed = await _chunk4X75PGSKcjs.decompressDataAndCheckHash.call(void 0, 
+        message.data,
+        resultCompressionKeyProvider
+      );
+      callback(decompressed);
+    });
+    const compressedMessage = await _chunk4X75PGSKcjs.hashAndCompressData.call(void 0, 
+      args,
+      _chunk4X75PGSKcjs.iFrameRequestKeyProvider
+    );
+    messageHandler.sendEvent({
+      id: channelId,
+      topic: args.method,
+      data: compressedMessage
+    });
+  };
+  const destroy = async () => {
+    channelManager.destroy();
+    messageHandler.cleanup();
+  };
+  return {
+    config,
+    waitForConnection: messageHandler.isConnected,
+    request,
+    listenerRequest,
+    destroy
+  };
+}
+
+
+
+
+
+
+
+
+
+exports.createIFrameFrakClient = createIFrameFrakClient; exports.createIframe = _chunk4X75PGSKcjs.createIframe; exports.decompressDataAndCheckHash = _chunk4X75PGSKcjs.decompressDataAndCheckHash; exports.getIFrameResponseKeyProvider = _chunk4X75PGSKcjs.getIFrameResponseKeyProvider; exports.getRedirectResponseResponseKeyProvider = _chunk4X75PGSKcjs.getRedirectResponseResponseKeyProvider; exports.hashAndCompressData = _chunk4X75PGSKcjs.hashAndCompressData; exports.iFrameRequestKeyProvider = _chunk4X75PGSKcjs.iFrameRequestKeyProvider; exports.redirectRequestKeyProvider = _chunk4X75PGSKcjs.redirectRequestKeyProvider;