@quiltt/core 5.0.0 → 5.0.2

package/dist/api/rest/index.cjs

@@ -0,0 +1,225 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index_cjs = require('../../config/index.cjs');
+var crossfetch = require('cross-fetch');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var crossfetch__default = /*#__PURE__*/_interopDefault(crossfetch);
+
+// Use `cross-fetch` only if `fetch` is not available on the `globalThis` object
+const effectiveFetch = typeof fetch === 'undefined' ? crossfetch__default.default : fetch;
+const RETRY_DELAY = 150 // ms
+;
+const RETRIES = 10 // 150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500 = 8.250s
+;
+/**
+ * A wrapper around the native `fetch` function that adds automatic retries on failure, including network errors and HTTP 429 responses.
+ * Now treats any response with status < 500 as valid.
+ */ const fetchWithRetry = async (url, options = {
+    retry: false
+})=>{
+    const { retry, retriesRemaining, validateStatus = (status)=>status >= 200 && status < 300, ...fetchOptions } = options;
+    try {
+        const response = await effectiveFetch(url, fetchOptions);
+        const isResponseOk = validateStatus(response.status);
+        if (isResponseOk) {
+            return {
+                data: await response.json().catch(()=>null),
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+                ok: isResponseOk
+            };
+        }
+        // If validateStatus fails, and retry is enabled, prepare to retry for eligible status codes
+        if (retry && (response.status >= 500 || response.status === 429)) {
+            throw new Error('Retryable failure');
+        }
+        throw new Error(`HTTP error with status ${response.status}`);
+    } catch (error) {
+        if (retry) {
+            const currentRetriesRemaining = retriesRemaining !== undefined ? retriesRemaining : RETRIES;
+            if (currentRetriesRemaining > 0) {
+                const delayTime = RETRY_DELAY * (RETRIES - currentRetriesRemaining);
+                await new Promise((resolve)=>setTimeout(resolve, delayTime));
+                return fetchWithRetry(url, {
+                    ...options,
+                    retriesRemaining: currentRetriesRemaining - 1
+                });
+            }
+        }
+        return Promise.reject(error);
+    }
+};
+
+var AuthStrategies = /*#__PURE__*/ function(AuthStrategies) {
+    AuthStrategies["Email"] = "email";
+    AuthStrategies["Phone"] = "phone";
+    return AuthStrategies;
+}({});
+// https://www.quiltt.dev/api-reference/auth
+class AuthAPI {
+    constructor(clientId){
+        /**
+   * Response Statuses:
+   *  - 200: OK           -> Session is Valid
+   *  - 401: Unauthorized -> Session is Invalid
+   */ this.ping = async (token)=>{
+            const response = await fetchWithRetry(index_cjs.endpointAuth, {
+                method: 'GET',
+                ...this.config(token)
+            });
+            return response;
+        };
+        /**
+   * Response Statuses:
+   *  - 201: Created              -> Profile Created, New Session Returned
+   *  - 202: Accepted             -> Profile Found, MFA Code Sent for `authenticate`
+   *  - 422: Unprocessable Entity -> Invalid Payload
+   */ this.identify = async (payload)=>{
+            const response = await fetchWithRetry(index_cjs.endpointAuth, {
+                method: 'POST',
+                body: JSON.stringify(this.body(payload)),
+                ...this.config()
+            });
+            return response;
+        };
+        /**
+   * Response Statuses:
+   *  - 201: Created              -> MFA Validated, New Session Returned
+   *  - 401: Unauthorized         -> MFA Invalid
+   *  - 422: Unprocessable Entity -> Invalid Payload
+   */ this.authenticate = async (payload)=>{
+            const response = await fetchWithRetry(index_cjs.endpointAuth, {
+                method: 'PUT',
+                body: JSON.stringify(this.body(payload)),
+                ...this.config()
+            });
+            return response;
+        };
+        /**
+   * Response Statuses:
+   *  - 204: No Content   -> Session Revoked
+   *  - 401: Unauthorized -> Session Not Found
+   */ this.revoke = async (token)=>{
+            const response = await fetchWithRetry(index_cjs.endpointAuth, {
+                method: 'DELETE',
+                ...this.config(token)
+            });
+            return response;
+        };
+        this.config = (token)=>{
+            const headers = new Headers();
+            headers.set('Content-Type', 'application/json');
+            headers.set('Accept', 'application/json');
+            if (token) {
+                headers.set('Authorization', `Bearer ${token}`);
+            }
+            return {
+                headers,
+                validateStatus: this.validateStatus,
+                retry: true
+            };
+        };
+        this.validateStatus = (status)=>status < 500 && status !== 429;
+        this.body = (payload)=>{
+            if (!this.clientId) {
+                console.error('Quiltt Client ID is not set. Unable to identify & authenticate');
+            }
+            return {
+                session: {
+                    clientId: this.clientId,
+                    ...payload
+                }
+            };
+        };
+        this.clientId = clientId;
+    }
+}
+
+/**
+ * Extracts version number from formatted version string
+ * @param formattedVersion - Formatted version like "@quiltt/core: v4.5.1"
+ * @returns Version number like "4.5.1" or "unknown" if not found
+ */ const extractVersionNumber = (formattedVersion)=>{
+    // Find the 'v' prefix and extract version after it
+    const vIndex = formattedVersion.indexOf('v');
+    if (vIndex === -1) return 'unknown';
+    const versionPart = formattedVersion.substring(vIndex + 1);
+    const parts = versionPart.split('.');
+    // Validate we have at least major.minor.patch
+    if (parts.length < 3) return 'unknown';
+    // Extract numeric parts (handles cases like "4.5.1-beta")
+    const major = parts[0].match(/^\d+/)?.[0];
+    const minor = parts[1].match(/^\d+/)?.[0];
+    const patch = parts[2].match(/^\d+/)?.[0];
+    if (!major || !minor || !patch) return 'unknown';
+    return `${major}.${minor}.${patch}`;
+};
+/**
+ * Generates a User-Agent string following standard format
+ * Format: Quiltt/<version> (<platform-info>)
+ */ const getUserAgent = (sdkVersion, platformInfo)=>{
+    return `Quiltt/${sdkVersion} (${platformInfo})`;
+};
+
+class ConnectorsAPI {
+    constructor(clientId, userAgent = getUserAgent(extractVersionNumber(index_cjs.version), 'Unknown')){
+        /**
+   * Response Statuses:
+   *  - 200: OK           -> Institutions Found
+   *  - 401: Unauthorized -> Invalid Token
+   *  - 403: Forbidden    -> Unsupported SDK
+   *  - 400: Bad Request  -> Invalid Request
+   */ this.searchInstitutions = async (token, connectorId, term, signal)=>{
+            const params = new URLSearchParams();
+            params.append('term', term);
+            const response = await fetchWithRetry(`${index_cjs.endpointRest}/sdk/connectors/${connectorId}/institutions?${params}`, {
+                method: 'GET',
+                signal,
+                ...this.config(token)
+            });
+            return response;
+        };
+        /**
+   * Response Statuses:
+   *  - 200: OK           -> Provider API ID is resolvable or not
+   *  - 401: Unauthorized -> Invalid Token
+   *  - 403: Forbidden    -> Unsupported SDK
+   *  - 400: Bad Request  -> Missing provider API ID parameter
+   *  - 404: Not Found    -> Connector not found
+   */ this.checkResolvable = async (token, connectorId, providerId, signal)=>{
+            const params = new URLSearchParams();
+            const providerKey = Object.keys(providerId)[0];
+            if (providerKey && providerId[providerKey]) {
+                params.append(providerKey, providerId[providerKey]);
+            }
+            const response = await fetchWithRetry(`${index_cjs.endpointRest}/sdk/connectors/${connectorId}/resolvable?${params}`, {
+                method: 'GET',
+                signal,
+                ...this.config(token)
+            });
+            return response;
+        };
+        this.config = (token)=>{
+            const headers = new Headers();
+            headers.set('Content-Type', 'application/json');
+            headers.set('Accept', 'application/json');
+            headers.set('User-Agent', this.userAgent);
+            headers.set('Authorization', `Bearer ${token}`);
+            return {
+                headers,
+                validateStatus: this.validateStatus,
+                retry: true
+            };
+        };
+        this.validateStatus = (status)=>status < 500 && status !== 429;
+        this.clientId = clientId;
+        this.userAgent = userAgent;
+    }
+}
+
+exports.AuthAPI = AuthAPI;
+exports.AuthStrategies = AuthStrategies;
+exports.ConnectorsAPI = ConnectorsAPI;

package/dist/api/rest/index.d.ts

@@ -0,0 +1,128 @@
+type FetchResponse<T> = {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Headers;
+    ok: boolean;
+};
+
+type NoContentData = null;
+type ErrorData = {
+    message: string;
+    instruction: string;
+    error_id: string;
+};
+type UnauthorizedData = {
+    message: string;
+    instruction: string;
+};
+type UnprocessableData = {
+    [attribute: string]: Array<string>;
+};
+type BadRequestResponse = FetchResponse<ErrorData>;
+type UnauthorizedResponse = FetchResponse<UnauthorizedData>;
+type UnprocessableResponse = FetchResponse<UnprocessableData>;
+
+declare enum AuthStrategies {
+    Email = "email",
+    Phone = "phone"
+}
+interface EmailInput {
+    email: string;
+    phone?: never;
+}
+interface PhoneInput {
+    phone: string;
+    email?: never;
+}
+type UsernamePayload = EmailInput | PhoneInput;
+type PasscodePayload = UsernamePayload & {
+    passcode: string;
+};
+type SessionData = {
+    token: string;
+};
+type Ping = SessionData | UnauthorizedData;
+type Identify = SessionData | NoContentData | UnprocessableData;
+type Authenticate = SessionData | UnauthorizedData | UnprocessableData;
+type Revoke = NoContentData | UnauthorizedData;
+type SessionResponse = FetchResponse<SessionData>;
+declare class AuthAPI {
+    clientId: string | undefined;
+    constructor(clientId?: string | undefined);
+    /**
+     * Response Statuses:
+     *  - 200: OK           -> Session is Valid
+     *  - 401: Unauthorized -> Session is Invalid
+     */
+    ping: (token: string) => Promise<FetchResponse<Ping>>;
+    /**
+     * Response Statuses:
+     *  - 201: Created              -> Profile Created, New Session Returned
+     *  - 202: Accepted             -> Profile Found, MFA Code Sent for `authenticate`
+     *  - 422: Unprocessable Entity -> Invalid Payload
+     */
+    identify: (payload: UsernamePayload) => Promise<FetchResponse<Identify>>;
+    /**
+     * Response Statuses:
+     *  - 201: Created              -> MFA Validated, New Session Returned
+     *  - 401: Unauthorized         -> MFA Invalid
+     *  - 422: Unprocessable Entity -> Invalid Payload
+     */
+    authenticate: (payload: PasscodePayload) => Promise<FetchResponse<Authenticate>>;
+    /**
+     * Response Statuses:
+     *  - 204: No Content   -> Session Revoked
+     *  - 401: Unauthorized -> Session Not Found
+     */
+    revoke: (token: string) => Promise<FetchResponse<Revoke>>;
+    private config;
+    private validateStatus;
+    private body;
+}
+
+type InstitutionData = {
+    name: string;
+    logoUrl: string;
+};
+type InstitutionsData = Array<InstitutionData>;
+type ResolvableData = {
+    resolvable: boolean;
+};
+type Search = InstitutionsData | ErrorData | UnauthorizedData;
+type Resolvable = ResolvableData | ErrorData | UnauthorizedData;
+type SearchResponse = FetchResponse<InstitutionsData>;
+type ResolvableResponse = FetchResponse<ResolvableData>;
+declare class ConnectorsAPI {
+    clientId: string;
+    userAgent: string;
+    constructor(clientId: string, userAgent?: string);
+    /**
+     * Response Statuses:
+     *  - 200: OK           -> Institutions Found
+     *  - 401: Unauthorized -> Invalid Token
+     *  - 403: Forbidden    -> Unsupported SDK
+     *  - 400: Bad Request  -> Invalid Request
+     */
+    searchInstitutions: (token: string, connectorId: string, term: string, signal?: AbortSignal) => Promise<FetchResponse<Search>>;
+    /**
+     * Response Statuses:
+     *  - 200: OK           -> Provider API ID is resolvable or not
+     *  - 401: Unauthorized -> Invalid Token
+     *  - 403: Forbidden    -> Unsupported SDK
+     *  - 400: Bad Request  -> Missing provider API ID parameter
+     *  - 404: Not Found    -> Connector not found
+     */
+    checkResolvable: (token: string, connectorId: string, providerId: {
+        plaid?: string;
+        mock?: string;
+        mx?: string;
+        finicity?: string;
+        akoya?: string;
+    }, signal?: AbortSignal) => Promise<FetchResponse<Resolvable>>;
+    private config;
+    private validateStatus;
+}
+
+export { AuthAPI, AuthStrategies, ConnectorsAPI };
+export type { BadRequestResponse, ErrorData, InstitutionData, InstitutionsData, NoContentData, PasscodePayload, ResolvableData, ResolvableResponse, SearchResponse, SessionResponse, UnauthorizedData, UnauthorizedResponse, UnprocessableData, UnprocessableResponse, UsernamePayload };

package/dist/api/rest/index.js

@@ -0,0 +1,217 @@
+import { endpointAuth, endpointRest, version } from '../../config/index.js';
+import crossfetch from 'cross-fetch';
+
+// Use `cross-fetch` only if `fetch` is not available on the `globalThis` object
+const effectiveFetch = typeof fetch === 'undefined' ? crossfetch : fetch;
+const RETRY_DELAY = 150 // ms
+;
+const RETRIES = 10 // 150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500 = 8.250s
+;
+/**
+ * A wrapper around the native `fetch` function that adds automatic retries on failure, including network errors and HTTP 429 responses.
+ * Now treats any response with status < 500 as valid.
+ */ const fetchWithRetry = async (url, options = {
+    retry: false
+})=>{
+    const { retry, retriesRemaining, validateStatus = (status)=>status >= 200 && status < 300, ...fetchOptions } = options;
+    try {
+        const response = await effectiveFetch(url, fetchOptions);
+        const isResponseOk = validateStatus(response.status);
+        if (isResponseOk) {
+            return {
+                data: await response.json().catch(()=>null),
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+                ok: isResponseOk
+            };
+        }
+        // If validateStatus fails, and retry is enabled, prepare to retry for eligible status codes
+        if (retry && (response.status >= 500 || response.status === 429)) {
+            throw new Error('Retryable failure');
+        }
+        throw new Error(`HTTP error with status ${response.status}`);
+    } catch (error) {
+        if (retry) {
+            const currentRetriesRemaining = retriesRemaining !== undefined ? retriesRemaining : RETRIES;
+            if (currentRetriesRemaining > 0) {
+                const delayTime = RETRY_DELAY * (RETRIES - currentRetriesRemaining);
+                await new Promise((resolve)=>setTimeout(resolve, delayTime));
+                return fetchWithRetry(url, {
+                    ...options,
+                    retriesRemaining: currentRetriesRemaining - 1
+                });
+            }
+        }
+        return Promise.reject(error);
+    }
+};
+
+var AuthStrategies = /*#__PURE__*/ function(AuthStrategies) {
+    AuthStrategies["Email"] = "email";
+    AuthStrategies["Phone"] = "phone";
+    return AuthStrategies;
+}({});
+// https://www.quiltt.dev/api-reference/auth
+class AuthAPI {
+    constructor(clientId){
+        /**
+   * Response Statuses:
+   *  - 200: OK           -> Session is Valid
+   *  - 401: Unauthorized -> Session is Invalid
+   */ this.ping = async (token)=>{
+            const response = await fetchWithRetry(endpointAuth, {
+                method: 'GET',
+                ...this.config(token)
+            });
+            return response;
+        };
+        /**
+   * Response Statuses:
+   *  - 201: Created              -> Profile Created, New Session Returned
+   *  - 202: Accepted             -> Profile Found, MFA Code Sent for `authenticate`
+   *  - 422: Unprocessable Entity -> Invalid Payload
+   */ this.identify = async (payload)=>{
+            const response = await fetchWithRetry(endpointAuth, {
+                method: 'POST',
+                body: JSON.stringify(this.body(payload)),
+                ...this.config()
+            });
+            return response;
+        };
+        /**
+   * Response Statuses:
+   *  - 201: Created              -> MFA Validated, New Session Returned
+   *  - 401: Unauthorized         -> MFA Invalid
+   *  - 422: Unprocessable Entity -> Invalid Payload
+   */ this.authenticate = async (payload)=>{
+            const response = await fetchWithRetry(endpointAuth, {
+                method: 'PUT',
+                body: JSON.stringify(this.body(payload)),
+                ...this.config()
+            });
+            return response;
+        };
+        /**
+   * Response Statuses:
+   *  - 204: No Content   -> Session Revoked
+   *  - 401: Unauthorized -> Session Not Found
+   */ this.revoke = async (token)=>{
+            const response = await fetchWithRetry(endpointAuth, {
+                method: 'DELETE',
+                ...this.config(token)
+            });
+            return response;
+        };
+        this.config = (token)=>{
+            const headers = new Headers();
+            headers.set('Content-Type', 'application/json');
+            headers.set('Accept', 'application/json');
+            if (token) {
+                headers.set('Authorization', `Bearer ${token}`);
+            }
+            return {
+                headers,
+                validateStatus: this.validateStatus,
+                retry: true
+            };
+        };
+        this.validateStatus = (status)=>status < 500 && status !== 429;
+        this.body = (payload)=>{
+            if (!this.clientId) {
+                console.error('Quiltt Client ID is not set. Unable to identify & authenticate');
+            }
+            return {
+                session: {
+                    clientId: this.clientId,
+                    ...payload
+                }
+            };
+        };
+        this.clientId = clientId;
+    }
+}
+
+/**
+ * Extracts version number from formatted version string
+ * @param formattedVersion - Formatted version like "@quiltt/core: v4.5.1"
+ * @returns Version number like "4.5.1" or "unknown" if not found
+ */ const extractVersionNumber = (formattedVersion)=>{
+    // Find the 'v' prefix and extract version after it
+    const vIndex = formattedVersion.indexOf('v');
+    if (vIndex === -1) return 'unknown';
+    const versionPart = formattedVersion.substring(vIndex + 1);
+    const parts = versionPart.split('.');
+    // Validate we have at least major.minor.patch
+    if (parts.length < 3) return 'unknown';
+    // Extract numeric parts (handles cases like "4.5.1-beta")
+    const major = parts[0].match(/^\d+/)?.[0];
+    const minor = parts[1].match(/^\d+/)?.[0];
+    const patch = parts[2].match(/^\d+/)?.[0];
+    if (!major || !minor || !patch) return 'unknown';
+    return `${major}.${minor}.${patch}`;
+};
+/**
+ * Generates a User-Agent string following standard format
+ * Format: Quiltt/<version> (<platform-info>)
+ */ const getUserAgent = (sdkVersion, platformInfo)=>{
+    return `Quiltt/${sdkVersion} (${platformInfo})`;
+};
+
+class ConnectorsAPI {
+    constructor(clientId, userAgent = getUserAgent(extractVersionNumber(version), 'Unknown')){
+        /**
+   * Response Statuses:
+   *  - 200: OK           -> Institutions Found
+   *  - 401: Unauthorized -> Invalid Token
+   *  - 403: Forbidden    -> Unsupported SDK
+   *  - 400: Bad Request  -> Invalid Request
+   */ this.searchInstitutions = async (token, connectorId, term, signal)=>{
+            const params = new URLSearchParams();
+            params.append('term', term);
+            const response = await fetchWithRetry(`${endpointRest}/sdk/connectors/${connectorId}/institutions?${params}`, {
+                method: 'GET',
+                signal,
+                ...this.config(token)
+            });
+            return response;
+        };
+        /**
+   * Response Statuses:
+   *  - 200: OK           -> Provider API ID is resolvable or not
+   *  - 401: Unauthorized -> Invalid Token
+   *  - 403: Forbidden    -> Unsupported SDK
+   *  - 400: Bad Request  -> Missing provider API ID parameter
+   *  - 404: Not Found    -> Connector not found
+   */ this.checkResolvable = async (token, connectorId, providerId, signal)=>{
+            const params = new URLSearchParams();
+            const providerKey = Object.keys(providerId)[0];
+            if (providerKey && providerId[providerKey]) {
+                params.append(providerKey, providerId[providerKey]);
+            }
+            const response = await fetchWithRetry(`${endpointRest}/sdk/connectors/${connectorId}/resolvable?${params}`, {
+                method: 'GET',
+                signal,
+                ...this.config(token)
+            });
+            return response;
+        };
+        this.config = (token)=>{
+            const headers = new Headers();
+            headers.set('Content-Type', 'application/json');
+            headers.set('Accept', 'application/json');
+            headers.set('User-Agent', this.userAgent);
+            headers.set('Authorization', `Bearer ${token}`);
+            return {
+                headers,
+                validateStatus: this.validateStatus,
+                retry: true
+            };
+        };
+        this.validateStatus = (status)=>status < 500 && status !== 429;
+        this.clientId = clientId;
+        this.userAgent = userAgent;
+    }
+}
+
+export { AuthAPI, AuthStrategies, ConnectorsAPI };

package/dist/auth/index.cjs

@@ -0,0 +1,21 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const MATCHER = /^(?:[\w-]+\.){2}[\w-]+$/;
+const JsonWebTokenParse = (token)=>{
+    if (typeof token === 'undefined' || token === null) return token;
+    if (!MATCHER.test(token)) {
+        console.error(`Invalid Session Token: ${token}`);
+        return;
+    }
+    const [_header, payload, _signature] = token.split('.');
+    try {
+        return {
+            token,
+            claims: JSON.parse(atob(payload))
+        };
+    } catch (error) {
+        console.error(`Invalid Session Token: ${error}`);
+    }
+};
+
+exports.JsonWebTokenParse = JsonWebTokenParse;

package/dist/auth/index.d.ts

@@ -0,0 +1,29 @@
+import { Maybe } from '../types.js';
+
+type RegisteredClaims = {
+    iss: string;
+    sub: string;
+    aud: string;
+    exp: number;
+    nbf: number;
+    iat: number;
+    jti: string;
+};
+type PrivateClaims = {
+    oid: string;
+    eid: string;
+    cid: string;
+    aid: string;
+    ver: number;
+    rol: 'basic' | 'core' | 'manager' | 'super-admin';
+};
+type Claims<T> = RegisteredClaims & T;
+type JsonWebToken<T> = {
+    token: string;
+    claims: Claims<T>;
+};
+type QuilttJWT = JsonWebToken<PrivateClaims>;
+declare const JsonWebTokenParse: <T>(token: Maybe<string> | undefined) => Maybe<JsonWebToken<T>> | undefined;
+
+export { JsonWebTokenParse };
+export type { Claims, JsonWebToken, PrivateClaims, QuilttJWT, RegisteredClaims };

package/dist/auth/index.js

@@ -0,0 +1,19 @@
+const MATCHER = /^(?:[\w-]+\.){2}[\w-]+$/;
+const JsonWebTokenParse = (token)=>{
+    if (typeof token === 'undefined' || token === null) return token;
+    if (!MATCHER.test(token)) {
+        console.error(`Invalid Session Token: ${token}`);
+        return;
+    }
+    const [_header, payload, _signature] = token.split('.');
+    try {
+        return {
+            token,
+            claims: JSON.parse(atob(payload))
+        };
+    } catch (error) {
+        console.error(`Invalid Session Token: ${error}`);
+    }
+};
+
+export { JsonWebTokenParse };

package/dist/config/index.cjs

@@ -0,0 +1,44 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var name = "@quiltt/core";
+var version$1 = "5.0.2";
+
+const QUILTT_API_INSECURE = (()=>{
+    try {
+        return process.env.QUILTT_API_INSECURE === 'true';
+    } catch  {
+        return false;
+    }
+})();
+const QUILTT_API_DOMAIN = (()=>{
+    try {
+        return process.env.QUILTT_API_DOMAIN;
+    } catch  {
+        return undefined;
+    }
+})();
+const QUILTT_DEBUG = (()=>{
+    try {
+        return process.env.NODE_ENV !== 'production' && process.env.QUILTT_DEBUG === 'true';
+    } catch  {
+        return false;
+    }
+})();
+const domain = QUILTT_API_DOMAIN || 'quiltt.io';
+const protocolHttp = `http${QUILTT_API_INSECURE ? '' : 's'}`;
+const protocolWebsockets = `ws${QUILTT_API_INSECURE ? '' : 's'}`;
+const debugging = QUILTT_DEBUG;
+const version = `${name}: v${version$1}`;
+const cdnBase = `${protocolHttp}://cdn.${domain}`;
+const endpointAuth = `${protocolHttp}://auth.${domain}/v1/users/session`;
+const endpointGraphQL = `${protocolHttp}://api.${domain}/v1/graphql`;
+const endpointRest = `${protocolHttp}://api.${domain}/v1`;
+const endpointWebsockets = `${protocolWebsockets}://api.${domain}/websockets`;
+
+exports.cdnBase = cdnBase;
+exports.debugging = debugging;
+exports.endpointAuth = endpointAuth;
+exports.endpointGraphQL = endpointGraphQL;
+exports.endpointRest = endpointRest;
+exports.endpointWebsockets = endpointWebsockets;
+exports.version = version;