@openfort/react-native 0.0.2 → 0.1.0

package/dist/types/types/oauth.d.ts

@@ -0,0 +1,74 @@
+import type { OAuthProvider } from '@openfort/openfort-js';
+import type { AuthSuccessCallback, ErrorCallback } from './auth';
+/**
+ * OAuth authentication flow state
+ */
+export type OAuthFlowState = {
+    status: 'initial' | 'loading' | 'awaiting-redirect' | 'done';
+    error?: never;
+} | {
+    status: 'error';
+    error: Error | null;
+};
+export declare const mapOAuthStatus: (status: OAuthFlowState) => {
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: Error | null | undefined;
+};
+/**
+ * OAuth tokens interface
+ */
+export interface OAuthTokens {
+    [key: string]: any;
+}
+/**
+ * OAuth tokens hook options
+ */
+export interface UseOAuthTokensOptions {
+    /**
+     * Callback function triggered when OAuth tokens are granted to the user after any OAuth Authorization flow.
+     * @param tokens - The set of OAuth tokens granted to the user.
+     */
+    onOAuthTokenGrant: (tokens: OAuthTokens) => void;
+}
+/**
+ * Login with OAuth input parameters
+ */
+export type LoginWithOAuthInput = LinkWithOAuthInput;
+/**
+ * Link with OAuth input parameters
+ */
+export type LinkWithOAuthInput = {
+    provider: OAuthProvider;
+    redirectUri?: string | undefined;
+    isLegacyAppleIosBehaviorEnabled?: boolean;
+};
+/**
+ * Login with OAuth hook interface
+ */
+export interface UseLoginWithOAuth {
+    state: OAuthFlowState;
+    login: (input: LoginWithOAuthInput) => Promise<import('@openfort/openfort-js').AuthPlayerResponse | undefined>;
+}
+/**
+ * Link with OAuth hook interface
+ */
+export interface UseLinkWithOAuth {
+    state: OAuthFlowState;
+    link: (input: LinkWithOAuthInput) => Promise<import('@openfort/openfort-js').AuthPlayerResponse | undefined>;
+}
+/**
+ * Unlink OAuth hook options
+ */
+export interface UnlinkOAuthOptions {
+    onError?: ErrorCallback;
+    onSuccess?: AuthSuccessCallback;
+}
+/**
+ * Unlink OAuth parameters
+ */
+export interface UnlinkOAuthParams {
+    provider: OAuthProvider;
+    subject: string;
+}

package/dist/types/types/openfortError.d.ts

@@ -0,0 +1,13 @@
+export declare enum OpenfortErrorType {
+    AUTHENTICATION_ERROR = "AUTHENTICATION_ERROR",
+    WALLET_ERROR = "WALLET_ERROR"
+}
+interface Data {
+    [key: string]: any;
+}
+export declare class OpenfortError extends Error {
+    type: OpenfortErrorType;
+    data: Data;
+    constructor(message: string, type: OpenfortErrorType, data?: Data);
+}
+export {};

package/dist/types/types/predicates.d.ts

@@ -0,0 +1,64 @@
+import type { EmbeddedEthereumWalletState, EmbeddedSolanaWalletState, EmbeddedSolanaWalletConnectedState, EmbeddedSolanaWalletConnectingState, EmbeddedSolanaWalletReconnectingState, EmbeddedSolanaWalletDisconnectedState, EmbeddedSolanaWalletNeedsRecoveryState, EmbeddedSolanaWalletCreatingState, EmbeddedSolanaWalletErrorState } from './wallet';
+/**
+ * Type guard to check if embedded wallet is connected
+ */
+export declare function isConnected(s: EmbeddedSolanaWalletState): s is EmbeddedSolanaWalletConnectedState;
+/**
+ * Type guard to check if embedded wallet is reconnecting
+ */
+export declare function isReconnecting(s: EmbeddedSolanaWalletState): s is EmbeddedSolanaWalletReconnectingState;
+/**
+ * Type guard to check if embedded wallet is connecting
+ */
+export declare function isConnecting(s: EmbeddedSolanaWalletState): s is EmbeddedSolanaWalletConnectingState;
+/**
+ * Type guard to check if embedded wallet is disconnected
+ */
+export declare function isDisconnected(s: EmbeddedSolanaWalletState): s is EmbeddedSolanaWalletDisconnectedState;
+/**
+ * Type guard to check if embedded wallet is not created
+ */
+export declare function isNotCreated(s: EmbeddedSolanaWalletState): s is EmbeddedSolanaWalletDisconnectedState;
+/**
+ * Type guard to check if embedded wallet is being created
+ */
+export declare function isCreating(s: EmbeddedSolanaWalletState): s is EmbeddedSolanaWalletCreatingState;
+/**
+ * Type guard to check if embedded wallet has an error
+ */
+export declare function hasError(s: EmbeddedSolanaWalletState): s is EmbeddedSolanaWalletErrorState;
+/**
+ * Type guard to check if embedded wallet needs recovery
+ */
+export declare function needsRecovery(s: EmbeddedSolanaWalletState): s is EmbeddedSolanaWalletNeedsRecoveryState;
+/**
+ * Additional utility predicates
+ */
+/**
+ * Type guard to check if wallet is in a loading state (connecting, creating, reconnecting)
+ */
+export declare function isLoading(s: EmbeddedEthereumWalletState | EmbeddedSolanaWalletState): boolean;
+/**
+ * Type guard to check if wallet is ready for use
+ */
+export declare function isReady(s: EmbeddedEthereumWalletState | EmbeddedSolanaWalletState): boolean;
+/**
+ * Type guard to check if wallet needs user action
+ */
+export declare function needsUserAction(s: EmbeddedEthereumWalletState | EmbeddedSolanaWalletState): boolean;
+/**
+ * Type guard to check if wallet state is stable (not in transition)
+ */
+export declare function isStable(s: EmbeddedEthereumWalletState | EmbeddedSolanaWalletState): boolean;
+/**
+ * Type guard to check if wallet can perform transactions
+ */
+export declare function canTransact(s: EmbeddedEthereumWalletState | EmbeddedSolanaWalletState): boolean;
+/**
+ * Gets a human-readable description of the wallet state
+ */
+export declare function getStateDescription(s: EmbeddedEthereumWalletState | EmbeddedSolanaWalletState): string;
+/**
+ * Gets appropriate action text for the current state
+ */
+export declare function getActionText(s: EmbeddedEthereumWalletState | EmbeddedSolanaWalletState): string;

package/dist/types/types/wallet.d.ts

@@ -0,0 +1,262 @@
+export interface OpenfortEmbeddedEthereumWalletProvider {
+    request: (args: {
+        method: string;
+        params?: any[];
+    }) => Promise<any>;
+    on: (event: string, handler: (...args: any[]) => void) => void;
+    removeListener: (event: string, handler: (...args: any[]) => void) => void;
+    [key: string]: any;
+}
+export interface OpenfortEmbeddedSolanaWalletProvider {
+    signTransaction: (transaction: any) => Promise<any>;
+    signAllTransactions: (transactions: any[]) => Promise<any[]>;
+    publicKey: string;
+    [key: string]: any;
+}
+export interface OpenfortEthereumEmbeddedWalletAccount {
+    address: string;
+    ownerAddress?: string;
+    implementationType?: string;
+    chainType: 'ethereum';
+    walletIndex: number;
+}
+export interface OpenfortSolanaEmbeddedWalletAccount {
+    address: string;
+    chainType: 'solana';
+    walletIndex: number;
+}
+import { ChainTypeEnum } from '@openfort/openfort-js';
+import type { ErrorCallback } from './auth';
+import { Hex } from './hex';
+/**
+ * Openfort embedded wallet account union type
+ */
+export type OpenfortEmbeddedWalletAccount = OpenfortEthereumEmbeddedWalletAccount | OpenfortSolanaEmbeddedWalletAccount;
+/**
+ * Wallet recovery callbacks
+ */
+export type WalletRecoveryCallbacks = {
+    onError?: ErrorCallback;
+    onSuccess?: (provider: OpenfortEmbeddedEthereumWalletProvider) => void;
+};
+/**
+ * Solana wallet recovery callbacks
+ */
+export type SolanaWalletRecoveryCallbacks = {
+    onError?: ErrorCallback;
+    onSuccess?: (provider: OpenfortEmbeddedSolanaWalletProvider) => void;
+};
+/**
+ * Recovery method options
+ */
+export type RecoveryMethodOptions = string | undefined | {
+    recoveryMethod: 'automatic';
+} | {
+    recoveryMethod: 'password';
+    password: string;
+};
+/**
+ * Solana wallet creation options
+ */
+export type CreateSolanaEmbeddedWalletOpts = (undefined | {
+    recoveryMethod: 'automatic';
+}) & {
+    createAdditional?: boolean;
+};
+/**
+ * Solana wallet recovery options
+ */
+export type RecoverSolanaEmbeddedWalletOpts = undefined | {
+    recoveryMethod: 'automatic';
+} | {
+    recoveryMethod: 'password';
+    password: string;
+};
+export type UserWallet = {
+    address: Hex;
+    ownerAddress?: string;
+    implementationType?: string;
+    chainType: ChainTypeEnum;
+    isActive?: boolean;
+    isConnecting?: boolean;
+    getProvider: () => Promise<OpenfortEmbeddedEthereumWalletProvider>;
+};
+/**
+ * Connected embedded wallet state
+ */
+interface IEmbeddedEthereumWalletConnectedState {
+    status: 'connected';
+    provider: OpenfortEmbeddedEthereumWalletProvider;
+    activeWallet: UserWallet;
+}
+/**
+ * Connecting embedded wallet state
+ */
+interface IEmbeddedEthereumWalletConnectingState {
+    status: 'connecting';
+    activeWallet: UserWallet;
+}
+/**
+ * Reconnecting embedded wallet state
+ */
+interface IEmbeddedEthereumWalletReconnectingState {
+    status: 'reconnecting';
+    activeWallet: UserWallet;
+}
+/**
+ * Disconnected embedded wallet state
+ */
+interface IEmbeddedEthereumWalletDisconnectedState {
+    status: 'disconnected';
+    activeWallet: null;
+}
+/**
+ * Needs recovery embedded wallet state
+ */
+interface IEmbeddedEthereumWalletNeedsRecoveryState {
+    status: 'needs-recovery';
+    activeWallet: UserWallet;
+}
+/**
+ * Creating embedded wallet state
+ */
+interface IEmbeddedEthereumWalletCreatingState {
+    status: 'creating';
+    activeWallet: null;
+}
+/**
+ * Error embedded wallet state
+ */
+interface IEmbeddedEthereumWalletErrorState {
+    status: 'error';
+    activeWallet: UserWallet | null;
+    error: string;
+}
+/**
+ * Embedded wallet actions
+ */
+export type EmbeddedEthereumWalletActions = {
+    /**
+     * Configure an embedded wallet for this user.
+     */
+    create: (args?: {
+        chainId?: number;
+        recoveryPassword?: string;
+        policyId?: string;
+    }) => Promise<import('@openfort/openfort-js').EmbeddedAccount>;
+    /**
+     * List of embedded ethereum wallets at each derived HD index.
+     */
+    wallets: ConnectedEmbeddedEthereumWallet[];
+};
+export type EthereumWalletState = IEmbeddedEthereumWalletConnectedState | IEmbeddedEthereumWalletConnectingState | IEmbeddedEthereumWalletReconnectingState | IEmbeddedEthereumWalletDisconnectedState | IEmbeddedEthereumWalletNeedsRecoveryState | IEmbeddedEthereumWalletCreatingState | IEmbeddedEthereumWalletErrorState;
+/**
+ * Main embedded wallet state union
+ */
+export type EmbeddedEthereumWalletState = EthereumWalletState & EmbeddedEthereumWalletActions;
+/**
+ * Embedded wallet status
+ */
+export type EmbeddedWalletStatus = EmbeddedEthereumWalletState['status'];
+/**
+ * Connected embedded Solana wallet state
+ */
+interface IEmbeddedSolanaWalletConnectedState {
+    status: 'connected';
+    activeWallet: OpenfortSolanaEmbeddedWalletAccount;
+    provider: OpenfortEmbeddedEthereumWalletProvider;
+}
+/**
+ * Connecting embedded Solana wallet state
+ */
+interface IEmbeddedSolanaWalletConnectingState {
+    status: 'connecting';
+}
+/**
+ * Reconnecting embedded Solana wallet state
+ */
+interface IEmbeddedSolanaWalletReconnectingState {
+    status: 'reconnecting';
+    activeWallet: OpenfortSolanaEmbeddedWalletAccount;
+}
+/**
+ * Disconnected embedded Solana wallet state
+ */
+interface IEmbeddedSolanaWalletDisconnectedState {
+    status: 'disconnected';
+    activeWallet: null;
+}
+/**
+ * Needs recovery embedded Solana wallet state
+ */
+interface IEmbeddedSolanaWalletNeedsRecoveryState {
+    status: 'needs-recovery';
+    activeWallet: OpenfortSolanaEmbeddedWalletAccount;
+}
+/**
+ * Creating embedded Solana wallet state
+ */
+interface IEmbeddedSolanaWalletCreatingState {
+    status: 'creating';
+    activeWallet: null;
+}
+/**
+ * Error embedded Solana wallet state
+ */
+interface IEmbeddedSolanaWalletErrorState {
+    status: 'error';
+    activeWallet: OpenfortSolanaEmbeddedWalletAccount | null;
+    error: string;
+}
+/**
+ * Connected embedded Solana wallet
+ */
+export type ConnectedEmbeddedSolanaWallet = {
+    address: string;
+    chainType: 'solana';
+    walletIndex: number;
+    getProvider: () => Promise<OpenfortEmbeddedSolanaWalletProvider>;
+};
+/**
+ * Embedded Solana wallet actions
+ */
+export type EmbeddedSolanaWalletActions = {
+    /**
+     * Configure an embedded wallet for this user.
+     */
+    create: (args?: {
+        chainId?: number;
+        recoveryPassword?: string;
+    }) => Promise<import('@openfort/openfort-js').EmbeddedAccount>;
+    /**
+     * List of embedded solana wallets
+     */
+    wallets: ConnectedEmbeddedSolanaWallet[];
+};
+export type EmbeddedSolanaWalletConnectedState = EmbeddedSolanaWalletActions & IEmbeddedSolanaWalletConnectedState;
+export type EmbeddedSolanaWalletConnectingState = EmbeddedSolanaWalletActions & IEmbeddedSolanaWalletConnectingState;
+export type EmbeddedSolanaWalletReconnectingState = EmbeddedSolanaWalletActions & IEmbeddedSolanaWalletReconnectingState;
+export type EmbeddedSolanaWalletDisconnectedState = Partial<EmbeddedSolanaWalletActions> & IEmbeddedSolanaWalletDisconnectedState;
+export type EmbeddedSolanaWalletNeedsRecoveryState = EmbeddedSolanaWalletActions & IEmbeddedSolanaWalletNeedsRecoveryState;
+export type EmbeddedSolanaWalletCreatingState = EmbeddedSolanaWalletActions & IEmbeddedSolanaWalletCreatingState;
+export type EmbeddedSolanaWalletErrorState = EmbeddedSolanaWalletActions & IEmbeddedSolanaWalletErrorState;
+/**
+ * Main embedded Solana wallet state union
+ */
+export type EmbeddedSolanaWalletState = EmbeddedSolanaWalletConnectedState | EmbeddedSolanaWalletConnectingState | EmbeddedSolanaWalletReconnectingState | EmbeddedSolanaWalletDisconnectedState | EmbeddedSolanaWalletNeedsRecoveryState | EmbeddedSolanaWalletCreatingState | EmbeddedSolanaWalletErrorState;
+/**
+ * Embedded Solana wallet status
+ */
+export type EmbeddedSolanaWalletStatus = EmbeddedSolanaWalletState['status'];
+/**
+ * Connected Ethereum wallet
+ */
+export type ConnectedEmbeddedEthereumWallet = {
+    address: string;
+    ownerAddress?: string;
+    implementationType?: string;
+    chainType: 'ethereum';
+    walletIndex: number;
+    getProvider: () => Promise<OpenfortEmbeddedEthereumWalletProvider>;
+};
+export {};

package/dist/types/wallet.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,44 +1,57 @@
 {
   "name": "@openfort/react-native",
   "main": "dist/index.js",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "license": "MIT",
+  "description": "React Native SDK for Openfort platform integration",
   "scripts": {
     "build": "rimraf dist && tsc",
-    "lint": "eslint . --ignore-pattern dist"
+    "lint": "eslint . --ignore-pattern dist",
+    "link": "yarn link",
+    "unlink": "yarn unlink"
   },
   "types": "dist/types/index.d.ts",
   "files": [
-    "dist",
-    "polyfills"
+    "dist"
   ],
+  "exports": {
+    ".": {
+      "require": "./dist/index.js",
+      "import": "./dist/index.js",
+      "types": "./dist/types/index.d.ts"
+    }
+  },
   "dependencies": {
-    "events": "^3.3.0",
-    "jsrsasign": "^11.1.0",
-    "react-native-get-random-values": "^1.11.0",
-    "react-native-mmkv": "^3.2.0",
-    "react-native-randombytes": "^3.6.1",
-    "react-native-webview": "13.12.5",
-    "text-encoding": "^0.7.0",
-    "uuid": "^11.1.0"
+    "@openfort/openfort-js": "^0.9.8"
   },
   "peerDependencies": {
-    "@openfort/openfort-js": "^0.8.31",
+    "expo-apple-authentication": "*",
+    "expo-crypto": "*",
+    "expo-linking": "*",
+    "expo-secure-store": "*",
+    "expo-web-browser": "*",
     "react": "*",
-    "react-native": "*"
+    "expo-application": "*",
+    "react-native": "*",
+    "react-native-webview": "*"
   },
   "devDependencies": {
     "@eslint/js": "^9.17.0",
-    "@openfort/openfort-js": "^0.8.31",
-    "@types/jsrsasign": "^10.5.15",
     "@types/react": "~18.3.12",
     "@types/react-test-renderer": "^18.3.0",
+    "buffer": "^5.4.3",
     "eslint": "^9.17.0",
     "eslint-plugin-react": "^7.37.3",
-    "globals": "^15.14.0",
-    "react": "18.3.1",
-    "react-native": "0.76.5",
-    "typescript": "^5.3.3",
+    "expo-apple-authentication": "^7.2.4",
+    "expo-application": "^6.1.4",
+    "expo-crypto": "14.0.2",
+    "expo-linking": "^7.1.5",
+    "expo-secure-store": "^14.2.3",
+    "expo-web-browser": "^14.1.6",
+    "react": "^18.3.1",
+    "react-native": "0.77.1",
+    "react-native-webview": "^13.15.0",
+    "typescript": "^5.5.3",
     "typescript-eslint": "^8.19.0"
   },
   "private": false,

package/dist/Iframe.js

@@ -1,72 +0,0 @@
-import React from 'react';
-import { useEffect, useRef, useState } from "react";
-import { View } from "react-native";
-import WebView from "react-native-webview";
-const debugInjectedCode = `
-  console.log = function(...message) {
-    const safeMessage = JSON.stringify({ ...message, type: "log" });
-    window.ReactNativeWebView.postMessage(safeMessage);
-  };
-
-  console.warn = console.log;
-  console.error = console.log;
-  console.info = console.log;
-  console.debug = console.log;
-
-  console.log("injecting Code");
-`;
-const injectedCode = `
-  window.parent = {};
-  window.parent.postMessage = (msg) =>  {console.log("---", msg); window.ReactNativeWebView.postMessage(JSON.stringify(msg))}
-`;
-export default function Iframe({ customUri, debug, debugVisible }) {
-    const webViewRef = useRef(null);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const fnCallbackRef = useRef(null); // Ref to store the callback
-    const [loaded, setLoaded] = useState(false);
-    useEffect(() => {
-        global.openfortListener = (fn) => {
-            fnCallbackRef.current = fn; // Store the callback in the ref
-        };
-        global.openfortPostMessage = (message) => {
-            webViewRef?.current?.postMessage(JSON.stringify(message));
-            if (debug)
-                console.log("[Send message to web view]", message);
-            setLoaded(true);
-        };
-    }, [webViewRef?.current]);
-    const handleMessage = (event) => {
-        // Trigger the stored callback, if any
-        if (fnCallbackRef.current) {
-            const origin = event.nativeEvent.url.endsWith('/') ? event.nativeEvent.url.slice(0, -1) : event.nativeEvent.url;
-            try {
-                const data = JSON.parse(event.nativeEvent.data);
-                if (data?.type === "log") {
-                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                    const { type, ...dataWithoutType } = data;
-                    if (debug)
-                        console.log("[Webview LOG]", Object.values(dataWithoutType).join(", "));
-                }
-                else {
-                    if (debug)
-                        console.log("[Webview message received]", data);
-                }
-            }
-            catch {
-                if (debug)
-                    console.log("[Webview message received]", event.nativeEvent.data);
-            }
-            fnCallbackRef.current({ origin, data: event.nativeEvent.data });
-        }
-    };
-    if (!loaded)
-        return null;
-    const uri = customUri ? customUri : "https://embedded.openfort.xyz";
-    const finalUri = new URL(uri);
-    if (debug) {
-        finalUri.searchParams.set('debug', 'true');
-    }
-    const uriWithParams = finalUri.toString();
-    return (React.createElement(View, { style: { flex: debugVisible ? 1 : 0 } },
-        React.createElement(WebView, { ref: webViewRef, source: { uri: uriWithParams }, onMessage: handleMessage, injectedJavaScript: injectedCode + (debug ? debugInjectedCode : "") })));
-}

package/dist/types/Iframe.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-export default function Iframe({ customUri, debug, debugVisible }: {
-    customUri?: string;
-    debug?: boolean;
-    debugVisible?: boolean;
-}): React.JSX.Element | null;

package/polyfills/index.ts

@@ -1,88 +0,0 @@
-import { polyfillGlobal } from "react-native/Libraries/Utilities/PolyfillFunctions"
-import { KEYUTIL, KJUR } from 'jsrsasign';
-
-// This is a workaround to fix the issue with process.version
-if (process.version === undefined) {
-  Object.defineProperty(process, 'version', {
-    value: "",  // Set the desired version (you can use any string)
-    writable: false,
-  });
-}
-
-// Crypto module needs getRandomValues
-import 'react-native-get-random-values';
-
-crypto.randomUUID = require('uuid').v4;
-
-const MMKVStorage = require("react-native-mmkv").MMKV;
-
-// Initialize MMKVStorage
-const MMKV = new MMKVStorage();
-
-const localStorage: Storage = {
-  getItem: (key: string): string | null => {
-    try {
-      const value = MMKV.getString(key);
-      // console.log("getItem", key, value);
-      return value !== undefined ? value : null;  // Ensure it returns string or null
-    } catch (e) {
-      console.error('Error reading value from localStorage polyfill', e);
-      return null;
-    }
-  },
-  setItem: (key: string, value: string) => {
-    try {
-      // console.log("setItem", key, value);
-      MMKV.set(key, value);  // Sets value synchronously
-    } catch (e) {
-      console.error('Error saving value to localStorage polyfill', e);
-    }
-  },
-  removeItem: (key: string) => {
-    try {
-      // console.log("removeItem", key);
-      MMKV.delete(key);  // Removes item synchronously
-    } catch (e) {
-      console.error('Error removing value from localStorage polyfill', e);
-    }
-  },
-  clear: () => {
-    try {
-      // console.log("clear");
-      MMKV.clearAll();  // Clears store synchronously
-    } catch (e) {
-      console.error('Error clearing localStorage polyfill', e);
-    }
-  },
-  key: (index: number): string | null => {
-    return MMKV.getAllKeys()[index] || null;
-  },
-  get length(): number {
-    try {
-      return MMKV.getAllKeys().length;
-    } catch {
-      console.error('Error: localStorage.length is not supported');
-      return -1;
-    }
-  }
-};
-
-global.localStorage = localStorage;
-global.sessionStorage = localStorage;
-
-global.JWK_UTILS = {
-  getKey: KEYUTIL.getKey,
-  parse: KJUR.jws.JWS.parse,
-  verifyJWT: KJUR.jws.JWS.verifyJWT,
-  getNow: KJUR.jws.IntDate.getNow,
-};
-
-// for TextEncoder and TextDecoder
-const applyGlobalPolyfills = () => {
-  const { TextEncoder, TextDecoder } = require("text-encoding")
-
-  polyfillGlobal("TextEncoder", () => TextEncoder)
-  polyfillGlobal("TextDecoder", () => TextDecoder)
-}
-
-applyGlobalPolyfills()