@prosopo/procaptcha-bundle 3.0.9 → 3.0.11

package/dist/bundle/{web3Chunk-DrUvbVNW.js → web3Chunk-B8txCqUJ.js}

@@ -1,9 +1,9 @@
 var vn = Object.defineProperty;
 var rn = (e, n, f) => n in e ? vn(e, n, { enumerable: !0, configurable: !0, writable: !0, value: f }) : e[n] = f;
 var c = (e, n, f) => rn(e, typeof n != "symbol" ? n + "" : n, f);
-import { E as Pn } from "./web2Chunk-7Vd8yt2r.js";
-import { P as D } from "./commonChunk-24zMb_mF.js";
-import { u as zn } from "./utilCryptoChunk-CIPUtfoO.js";
+import { P as D } from "./commonChunk-HCVkoCqn.js";
+import { E as Pn } from "./web2Chunk-DCsWA5PR.js";
+import { t as zn } from "./utilCryptoChunk-qm-BM2eT.js";
 import { v as I, s as cn, o as dn } from "./utilChunk-sqstc6C5.js";
 const R = { getRandomValues: zn }, sn = { crypto: R };
 class bn {

package/dist/index.js

@@ -9,127 +9,161 @@ let procaptchaRoots = [];
 const widgetFactory = new WidgetFactory(new WidgetThemeResolver());
 const PROCAPTCHA_EXECUTE_EVENT = "procaptcha:execute";
 const implicitRender = async () => {
-    const elements = Array.from(document.getElementsByClassName("procaptcha")).filter((element) => element.tagName.toLowerCase() !== "button");
-    if (elements.length) {
-        const siteKey = at(elements, 0).getAttribute("data-sitekey");
-        const web3 = at(elements, 0).getAttribute("data-web3");
-        if (!siteKey) {
-            console.error("No siteKey found");
-            return;
-        }
-        const captchaType = getCaptchaType(elements);
-        const root = await widgetFactory.createWidgets(elements, {
-            captchaType: captchaType,
-            siteKey: siteKey,
-        }, !(web3 === "true"));
-        procaptchaRoots.push(...root);
+  const elements = Array.from(
+    document.getElementsByClassName("procaptcha")
+  ).filter((element) => element.tagName.toLowerCase() !== "button");
+  if (elements.length) {
+    const siteKey = at(elements, 0).getAttribute("data-sitekey");
+    const web3 = at(elements, 0).getAttribute("data-web3");
+    if (!siteKey) {
+      console.error("No siteKey found");
+      return;
     }
-    const invisibleButtons = Array.from(document.getElementsByClassName("procaptcha")).filter((button) => button.tagName.toLowerCase() === "button");
-    if (invisibleButtons.length) {
-        for (const button of invisibleButtons) {
-            const siteKey = button.getAttribute("data-sitekey") || "";
-            const callback = button.getAttribute("data-callback") || "";
-            const captchaType = getCaptchaType([button]);
-            const root = await widgetFactory.createWidgets([button], {
-                captchaType: captchaType,
-                siteKey: siteKey,
-                callback: callback,
-            }, true, true);
-            procaptchaRoots.push(...root);
-            button.addEventListener("click", async (event) => {
-                event.preventDefault();
-                execute();
-            });
-        }
+    const captchaType = getCaptchaType(elements);
+    const root = await widgetFactory.createWidgets(
+      elements,
+      {
+        captchaType,
+        siteKey
+      },
+      !(web3 === "true")
+    );
+    procaptchaRoots.push(...root);
+  }
+  const invisibleButtons = Array.from(
+    document.getElementsByClassName("procaptcha")
+  ).filter((button) => button.tagName.toLowerCase() === "button");
+  if (invisibleButtons.length) {
+    for (const button of invisibleButtons) {
+      const siteKey = button.getAttribute("data-sitekey") || "";
+      const callback = button.getAttribute("data-callback") || "";
+      const captchaType = getCaptchaType([button]);
+      const root = await widgetFactory.createWidgets(
+        [button],
+        {
+          captchaType,
+          siteKey,
+          callback
+        },
+        true,
+        true
+      );
+      procaptchaRoots.push(...root);
+      button.addEventListener("click", async (event) => {
+        event.preventDefault();
+        execute();
+      });
     }
+  }
 };
-export const render = async (element, renderOptions) => {
-    const hasInvisibleSize = Object.prototype.hasOwnProperty.call(renderOptions, "size") &&
-        renderOptions.size === "invisible";
-    const isWeb2 = !renderOptions.web3;
-    if (hasInvisibleSize || element.tagName.toLowerCase() === "button") {
-        const roots = await widgetFactory.createWidgets([element], renderOptions, isWeb2, true);
-        procaptchaRoots.push(...roots);
-        return;
-    }
-    const roots = await widgetFactory.createWidgets([element], renderOptions, isWeb2, false);
-    procaptchaRoots.push(...roots);
+const render = async (element, renderOptions) => {
+  const hasInvisibleSize = Object.prototype.hasOwnProperty.call(renderOptions, "size") && renderOptions.size === "invisible";
+  const isWeb2 = !renderOptions.web3;
+  if (hasInvisibleSize || element.tagName.toLowerCase() === "button") {
+    const roots2 = await widgetFactory.createWidgets(
+      [element],
+      renderOptions,
+      isWeb2,
+      true
+    );
+    procaptchaRoots.push(...roots2);
+    return;
+  }
+  const roots = await widgetFactory.createWidgets(
+    [element],
+    renderOptions,
+    isWeb2,
+    false
+  );
+  procaptchaRoots.push(...roots);
 };
-export default function ready(fn) {
-    if (document && document.readyState !== "loading") {
-        console.log("document.readyState ready!");
-        fn();
-    }
-    else {
-        console.log("DOMContentLoaded listener!");
-        document.addEventListener("DOMContentLoaded", () => {
-            console.log("DOMContentLoaded fired");
-            console.log(window);
-            fn();
-        });
-    }
-}
-export const execute = () => {
-    const containers = findProcaptchaContainers();
-    if (containers.length === 0) {
-        console.error("No Procaptcha containers found for execution");
-        return;
-    }
-    const executeEvent = new CustomEvent(PROCAPTCHA_EXECUTE_EVENT, {
-        detail: {
-            containerId: containers[0]?.id || "procaptcha-container",
-            containerCount: containers.length,
-            timestamp: Date.now(),
-        },
-        bubbles: true,
-        cancelable: true,
+function ready(fn) {
+  if (document && document.readyState !== "loading") {
+    console.log("document.readyState ready!");
+    fn();
+  } else {
+    console.log("DOMContentLoaded listener!");
+    document.addEventListener("DOMContentLoaded", () => {
+      console.log("DOMContentLoaded fired");
+      console.log(window);
+      fn();
     });
-    document.dispatchEvent(executeEvent);
+  }
+}
+const execute = () => {
+  const containers = findProcaptchaContainers();
+  if (containers.length === 0) {
+    console.error("No Procaptcha containers found for execution");
+    return;
+  }
+  const executeEvent = new CustomEvent(PROCAPTCHA_EXECUTE_EVENT, {
+    detail: {
+      containerId: containers[0]?.id || "procaptcha-container",
+      containerCount: containers.length,
+      timestamp: Date.now()
+    },
+    bubbles: true,
+    cancelable: true
+  });
+  document.dispatchEvent(executeEvent);
 };
 function findProcaptchaContainers() {
-    const containers = [];
-    const invisibleContainers = Array.from(document.querySelectorAll('[data-size="invisible"]'));
-    containers.push(...invisibleContainers);
-    const idContainers = Array.from(document.querySelectorAll('#procaptcha-container, [id$="-procaptcha-container"]'));
-    const classContainers = Array.from(document.getElementsByClassName("p-procaptcha"));
-    containers.push(...classContainers);
-    for (const container of idContainers) {
-        if (!containers.includes(container)) {
-            containers.push(container);
-        }
+  const containers = [];
+  const invisibleContainers = Array.from(
+    document.querySelectorAll('[data-size="invisible"]')
+  );
+  containers.push(...invisibleContainers);
+  const idContainers = Array.from(
+    document.querySelectorAll(
+      '#procaptcha-container, [id$="-procaptcha-container"]'
+    )
+  );
+  const classContainers = Array.from(
+    document.getElementsByClassName("p-procaptcha")
+  );
+  containers.push(...classContainers);
+  for (const container of idContainers) {
+    if (!containers.includes(container)) {
+      containers.push(container);
     }
-    return containers;
+  }
+  return containers;
 }
 const start = () => {
-    const { onloadUrlCallback, renderExplicit } = extractParams(BUNDLE_NAME);
-    let readyCalled = false;
-    if (renderExplicit !== "explicit") {
-        getProcaptchaScript(BUNDLE_NAME)?.addEventListener("load", () => {
-            ready(implicitRender);
-            readyCalled = true;
-        });
-        if (document.readyState === "complete" && !readyCalled) {
-            ready(implicitRender);
-        }
+  const { onloadUrlCallback, renderExplicit } = extractParams(BUNDLE_NAME);
+  let readyCalled = false;
+  if (renderExplicit !== "explicit") {
+    getProcaptchaScript(BUNDLE_NAME)?.addEventListener("load", () => {
+      ready(implicitRender);
+      readyCalled = true;
+    });
+    if (document.readyState === "complete" && !readyCalled) {
+      ready(implicitRender);
     }
-    if (onloadUrlCallback) {
-        getProcaptchaScript(BUNDLE_NAME)?.addEventListener("load", () => {
-            const onloadCallback = getWindowCallback(onloadUrlCallback);
-            ready(onloadCallback);
-        });
-        if (document.readyState === "complete" && !readyCalled) {
-            const onloadCallback = getWindowCallback(onloadUrlCallback);
-            ready(onloadCallback);
-        }
+  }
+  if (onloadUrlCallback) {
+    getProcaptchaScript(BUNDLE_NAME)?.addEventListener("load", () => {
+      const onloadCallback = getWindowCallback(onloadUrlCallback);
+      ready(onloadCallback);
+    });
+    if (document.readyState === "complete" && !readyCalled) {
+      const onloadCallback = getWindowCallback(onloadUrlCallback);
+      ready(onloadCallback);
     }
+  }
 };
-export const reset = () => {
-    for (const root of procaptchaRoots) {
-        root.unmount();
-    }
-    procaptchaRoots = [];
-    start();
+const reset = () => {
+  for (const root of procaptchaRoots) {
+    root.unmount();
+  }
+  procaptchaRoots = [];
+  start();
 };
 window.procaptcha = { ready, render, reset, execute };
 start();
-//# sourceMappingURL=index.js.map
+export {
+  ready as default,
+  execute,
+  render,
+  reset
+};

package/dist/util/captcha/captchaComponentProvider.js

@@ -1,15 +1,23 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx } from "react/jsx-runtime";
 import { CaptchaType } from "@prosopo/types";
 import { captchaComponentsList } from "./captchaComponentsList.js";
 class CaptchaComponentProvider {
-    getCaptchaComponent(captchaType, captchaProps) {
-        if (captchaType === CaptchaType.invisible) {
-            throw new Error("Not Implemented");
-        }
-        const CaptchaComponent = captchaComponentsList[captchaType];
-        console.log(`rendering ${captchaType}`);
-        return (_jsx(CaptchaComponent, { config: captchaProps.config, callbacks: captchaProps.callbacks, i18n: captchaProps.i18n }));
+  getCaptchaComponent(captchaType, captchaProps) {
+    if (captchaType === CaptchaType.invisible) {
+      throw new Error("Not Implemented");
     }
+    const CaptchaComponent = captchaComponentsList[captchaType];
+    console.log(`rendering ${captchaType}`);
+    return /* @__PURE__ */ jsx(
+      CaptchaComponent,
+      {
+        config: captchaProps.config,
+        callbacks: captchaProps.callbacks,
+        i18n: captchaProps.i18n
+      }
+    );
+  }
 }
-export { CaptchaComponentProvider };
-//# sourceMappingURL=captchaComponentProvider.js.map
+export {
+  CaptchaComponentProvider
+};

package/dist/util/captcha/captchaComponentsList.js

@@ -3,9 +3,10 @@ import { FrictionlessCaptcha } from "./components/frictionlessCaptcha.js";
 import { ImageCaptcha } from "./components/imageCaptcha.js";
 import { PowCaptcha } from "./components/powCaptcha.js";
 const captchaComponentsList = {
-    [CaptchaType.image]: ImageCaptcha,
-    [CaptchaType.pow]: PowCaptcha,
-    [CaptchaType.frictionless]: FrictionlessCaptcha,
+  [CaptchaType.image]: ImageCaptcha,
+  [CaptchaType.pow]: PowCaptcha,
+  [CaptchaType.frictionless]: FrictionlessCaptcha
+};
+export {
+  captchaComponentsList
 };
-export { captchaComponentsList };
-//# sourceMappingURL=captchaComponentsList.js.map

package/dist/util/captcha/captchaRenderer.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx } from "react/jsx-runtime";
 import createCache from "@emotion/cache";
 import { CacheProvider } from "@emotion/react";
 import { createRoot } from "react-dom/client";
@@ -6,43 +6,61 @@ import { createConfig } from "../configCreator.js";
 import { setLanguage } from "../language.js";
 import { setValidChallengeLength } from "../timeout.js";
 class CaptchaRenderer {
-    constructor(captchaComponentProvider) {
-        this.captchaComponentProvider = captchaComponentProvider;
-    }
-    renderCaptcha(settings, container, renderOptions, callbacks, isWeb2, i18n, invisible = false) {
-        const captchaType = renderOptions?.captchaType ||
-            settings.defaultCaptchaType;
-        const config = createConfig(renderOptions.siteKey, renderOptions.theme, renderOptions.language, isWeb2, invisible, renderOptions.userAccountAddress);
-        this.readAndValidateSettings(container, config, renderOptions);
-        const reactRoot = this.createReactRoot(container, settings.identifierPrefix);
-        const emotionCache = this.makeEmotionCache(settings.emotionCacheKey, container);
-        const captchaComponent = this.captchaComponentProvider.getCaptchaComponent(captchaType, {
-            config: config,
-            i18n: i18n,
-            callbacks,
-        });
-        this.renderCaptchaComponent(reactRoot, emotionCache, captchaComponent);
-        return reactRoot;
-    }
-    readAndValidateSettings(element, config, renderOptions) {
-        setValidChallengeLength(renderOptions, element, config);
-        setLanguage(renderOptions, element, config);
-    }
-    makeEmotionCache(cacheKey, container) {
-        return createCache({
-            key: cacheKey,
-            prepend: true,
-            container: container,
-        });
-    }
-    createReactRoot(container, identifierPrefix) {
-        return createRoot(container, {
-            identifierPrefix: identifierPrefix,
-        });
-    }
-    renderCaptchaComponent(reactRoot, emotionCache, captchaComponent) {
-        reactRoot.render(_jsx(CacheProvider, { value: emotionCache, children: captchaComponent }));
-    }
+  constructor(captchaComponentProvider) {
+    this.captchaComponentProvider = captchaComponentProvider;
+  }
+  renderCaptcha(settings, container, renderOptions, callbacks, isWeb2, i18n, invisible = false) {
+    const captchaType = renderOptions?.captchaType || settings.defaultCaptchaType;
+    const config = createConfig(
+      renderOptions.siteKey,
+      renderOptions.theme,
+      renderOptions.language,
+      isWeb2,
+      invisible,
+      renderOptions.userAccountAddress
+    );
+    this.readAndValidateSettings(container, config, renderOptions);
+    const reactRoot = this.createReactRoot(
+      container,
+      settings.identifierPrefix
+    );
+    const emotionCache = this.makeEmotionCache(
+      settings.emotionCacheKey,
+      container
+    );
+    const captchaComponent = this.captchaComponentProvider.getCaptchaComponent(
+      captchaType,
+      {
+        config,
+        i18n,
+        callbacks
+      }
+    );
+    this.renderCaptchaComponent(reactRoot, emotionCache, captchaComponent);
+    return reactRoot;
+  }
+  readAndValidateSettings(element, config, renderOptions) {
+    setValidChallengeLength(renderOptions, element, config);
+    setLanguage(renderOptions, element, config);
+  }
+  makeEmotionCache(cacheKey, container) {
+    return createCache({
+      key: cacheKey,
+      prepend: true,
+      container
+    });
+  }
+  createReactRoot(container, identifierPrefix) {
+    return createRoot(container, {
+      identifierPrefix
+    });
+  }
+  renderCaptchaComponent(reactRoot, emotionCache, captchaComponent) {
+    reactRoot.render(
+      /* @__PURE__ */ jsx(CacheProvider, { value: emotionCache, children: captchaComponent })
+    );
+  }
 }
-export { CaptchaRenderer };
-//# sourceMappingURL=captchaRenderer.js.map
+export {
+  CaptchaRenderer
+};

package/dist/util/captcha/captchaType.js

@@ -1,8 +1,12 @@
 import { CaptchaType } from "@prosopo/types";
 import { at } from "@prosopo/util";
-export function getCaptchaType(elements) {
-    const features = Object.values(CaptchaType);
-    const captchaType = features.find((feature) => feature === at(elements, 0).getAttribute("data-captcha-type")) || "frictionless";
-    return captchaType;
+function getCaptchaType(elements) {
+  const features = Object.values(CaptchaType);
+  const captchaType = features.find(
+    (feature) => feature === at(elements, 0).getAttribute("data-captcha-type")
+  ) || "frictionless";
+  return captchaType;
 }
-//# sourceMappingURL=captchaType.js.map
+export {
+  getCaptchaType
+};

package/dist/util/captcha/components/frictionlessCaptcha.js

@@ -1,14 +1,24 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx } from "react/jsx-runtime";
 import { getDefaultEvents } from "@prosopo/procaptcha-common";
 import { ProcaptchaFrictionless } from "@prosopo/procaptcha-frictionless";
 import { useState } from "react";
 const FrictionlessCaptcha = (props) => {
-    const { config, callbacks, i18n } = props;
-    const [componentKey, setComponentKey] = useState(0);
-    const restart = () => {
-        setComponentKey((prevKey) => prevKey + 1);
-    };
-    return (_jsx(ProcaptchaFrictionless, { config: config, callbacks: getDefaultEvents(callbacks), restart: restart, i18n: i18n }, componentKey));
+  const { config, callbacks, i18n } = props;
+  const [componentKey, setComponentKey] = useState(0);
+  const restart = () => {
+    setComponentKey((prevKey) => prevKey + 1);
+  };
+  return /* @__PURE__ */ jsx(
+    ProcaptchaFrictionless,
+    {
+      config,
+      callbacks: getDefaultEvents(callbacks),
+      restart,
+      i18n
+    },
+    componentKey
+  );
+};
+export {
+  FrictionlessCaptcha
 };
-export { FrictionlessCaptcha };
-//# sourceMappingURL=frictionlessCaptcha.js.map

package/dist/util/captcha/components/imageCaptcha.js

@@ -1,9 +1,17 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx } from "react/jsx-runtime";
 import { getDefaultEvents } from "@prosopo/procaptcha-common";
 import { Procaptcha } from "@prosopo/procaptcha-react";
 const ImageCaptcha = (props) => {
-    const { config, callbacks, i18n } = props;
-    return (_jsx(Procaptcha, { config: config, callbacks: getDefaultEvents(callbacks), i18n: i18n }));
+  const { config, callbacks, i18n } = props;
+  return /* @__PURE__ */ jsx(
+    Procaptcha,
+    {
+      config,
+      callbacks: getDefaultEvents(callbacks),
+      i18n
+    }
+  );
+};
+export {
+  ImageCaptcha
 };
-export { ImageCaptcha };
-//# sourceMappingURL=imageCaptcha.js.map

package/dist/util/captcha/components/powCaptcha.js

@@ -1,9 +1,17 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx } from "react/jsx-runtime";
 import { getDefaultEvents } from "@prosopo/procaptcha-common";
 import { ProcaptchaPow } from "@prosopo/procaptcha-pow";
 const PowCaptcha = (props) => {
-    const { config, callbacks, i18n } = props;
-    return (_jsx(ProcaptchaPow, { config: config, callbacks: getDefaultEvents(callbacks), i18n: i18n }));
+  const { config, callbacks, i18n } = props;
+  return /* @__PURE__ */ jsx(
+    ProcaptchaPow,
+    {
+      config,
+      callbacks: getDefaultEvents(callbacks),
+      i18n
+    }
+  );
+};
+export {
+  PowCaptcha
 };
-export { PowCaptcha };
-//# sourceMappingURL=powCaptcha.js.map

package/dist/util/config.js

@@ -1,13 +1,16 @@
-export const getProcaptchaScript = (name) => document.querySelector(`script[src*="${name}"]`);
-export const extractParams = (name) => {
-    const script = getProcaptchaScript(name);
-    if (script && script.src.indexOf(`${name}`) !== -1) {
-        const params = new URLSearchParams(script.src.split("?")[1]);
-        return {
-            onloadUrlCallback: params.get("onload") || undefined,
-            renderExplicit: params.get("render") || undefined,
-        };
-    }
-    return { onloadUrlCallback: undefined, renderExplicit: undefined };
+const getProcaptchaScript = (name) => document.querySelector(`script[src*="${name}"]`);
+const extractParams = (name) => {
+  const script = getProcaptchaScript(name);
+  if (script && script.src.indexOf(`${name}`) !== -1) {
+    const params = new URLSearchParams(script.src.split("?")[1]);
+    return {
+      onloadUrlCallback: params.get("onload") || void 0,
+      renderExplicit: params.get("render") || void 0
+    };
+  }
+  return { onloadUrlCallback: void 0, renderExplicit: void 0 };
+};
+export {
+  extractParams,
+  getProcaptchaScript
 };
-//# sourceMappingURL=config.js.map

package/dist/util/configCreator.js

@@ -1,24 +1,23 @@
-import { EnvironmentTypesSchema, ProcaptchaConfigSchema, } from "@prosopo/types";
+import { ProcaptchaConfigSchema, EnvironmentTypesSchema } from "@prosopo/types";
 function createConfig(siteKey, theme = "light", language, web2 = true, invisible = false, userAccountAddress) {
-    if (!siteKey) {
-        siteKey = process.env.PROSOPO_SITE_KEY || "";
-    }
-    return ProcaptchaConfigSchema.parse({
-        defaultEnvironment: process.env.PROSOPO_DEFAULT_ENVIRONMENT
-            ? EnvironmentTypesSchema.parse(process.env.PROSOPO_DEFAULT_ENVIRONMENT)
-            : EnvironmentTypesSchema.enum.development,
-        userAccountAddress: userAccountAddress || "",
-        account: {
-            address: siteKey,
-        },
-        serverUrl: process.env.PROSOPO_SERVER_URL || "",
-        mongoAtlasUri: process.env.PROSOPO_MONGO_EVENTS_URI || "",
-        devOnlyWatchEvents: process.env._DEV_ONLY_WATCH_EVENTS === "true" || false,
-        web2,
-        mode: invisible ? "invisible" : "visible",
-        theme,
-        language,
-    });
+  if (!siteKey) {
+    siteKey = process.env.PROSOPO_SITE_KEY || "";
+  }
+  return ProcaptchaConfigSchema.parse({
+    defaultEnvironment: process.env.PROSOPO_DEFAULT_ENVIRONMENT ? EnvironmentTypesSchema.parse(process.env.PROSOPO_DEFAULT_ENVIRONMENT) : EnvironmentTypesSchema.enum.development,
+    userAccountAddress: userAccountAddress || "",
+    account: {
+      address: siteKey
+    },
+    serverUrl: process.env.PROSOPO_SERVER_URL || "",
+    mongoAtlasUri: process.env.PROSOPO_MONGO_EVENTS_URI || "",
+    devOnlyWatchEvents: process.env._DEV_ONLY_WATCH_EVENTS === "true" || false,
+    web2,
+    mode: invisible ? "invisible" : "visible",
+    theme,
+    language
+  });
 }
-export { createConfig };
-//# sourceMappingURL=configCreator.js.map
+export {
+  createConfig
+};

package/dist/util/language.js

@@ -1,17 +1,18 @@
 import { LanguageSchema } from "@prosopo/locale";
-export const setLanguage = (renderOptions, element, config) => {
-    const languageAttribute = renderOptions?.language || element.getAttribute("data-language");
-    if (languageAttribute) {
-        config.language = validateLanguage(languageAttribute);
-    }
+const setLanguage = (renderOptions, element, config) => {
+  const languageAttribute = renderOptions?.language || element.getAttribute("data-language");
+  if (languageAttribute) {
+    config.language = validateLanguage(languageAttribute);
+  }
 };
 const validateLanguage = (languageAttribute) => {
-    try {
-        return LanguageSchema.parse(languageAttribute);
-    }
-    catch (error) {
-        console.error(`Invalid language attribute: ${languageAttribute}`);
-        return LanguageSchema.parse("en");
-    }
+  try {
+    return LanguageSchema.parse(languageAttribute);
+  } catch (error) {
+    console.error(`Invalid language attribute: ${languageAttribute}`);
+    return LanguageSchema.parse("en");
+  }
+};
+export {
+  setLanguage
 };
-//# sourceMappingURL=language.js.map