@scalar/agent-chat 0.1.2 → 0.2.1

package/dist/helpers.d.ts

@@ -2,7 +2,11 @@ import type { ToolUIPart, UIDataTypes, UIMessagePart } from 'ai';
 import type { MergedSecuritySchemes } from '@scalar/api-client/v2/blocks/scalar-auth-selector-block';
 import type { OpenAPIV3_1 } from '@scalar/openapi-types';
 import type { AuthenticationConfiguration } from '@scalar/types/api-reference';
+import type { WorkspaceStore } from '@scalar/workspace-store/client';
+import type { WorkspaceDocument } from '@scalar/workspace-store/schemas';
+import type { XScalarSelectedSecurity } from '@scalar/workspace-store/schemas/extensions/security/x-scalar-selected-security';
 import type { OpenApiDocument, OperationObject, ParameterObject, PathItemObject, SecurityRequirementObject, SecuritySchemeObject, ServerObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
+import { type SecuritySchemes } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
 import type { Tools } from './state/state.js';
 /** Combine pathItem and operation parameters into a single, dereferenced parameter array */
 export declare const combineParams: (pathParams?: PathItemObject["parameters"], operationParams?: OperationObject["parameters"]) => ParameterObject[];
@@ -36,4 +40,379 @@ export declare const getDefaultSecurity: (securityRequirements: SecurityRequirem
  */
 export declare const filterSelectedSecurity: (document: OpenApiDocument, operation: OperationObject | null, securitySchemes?: MergedSecuritySchemes) => SecuritySchemeObject[];
 export declare function getOperations(doc: Partial<OpenAPIV3_1.Document>): OperationObject[];
+/** Flattens all security requirements from a document */
+export declare function getSecurityFromDocument(document: WorkspaceDocument): SecuritySchemeObject[];
+/** Generate document settings from workspace store */
+export declare function createDocumentSettings(workspaceStore: WorkspaceStore): {
+    [k: string]: {
+        activeServer: ServerObject | null;
+        securitySchemes: SecuritySchemeObject[];
+    };
+};
+/**
+ * Provides an interface to store and retrieve the selected client value
+ * in local storage.
+ */
+export declare const clientStorage: () => {
+    /**
+     * Gets the stored selected client from local storage.
+     */
+    get: () => string | null;
+    /**
+     * Stores the selected client value in local storage.
+     * @param value The value to store
+     */
+    set: (value: string) => void;
+};
+/**
+ * Provides an interface to store and retrieve authentication scheme
+ * information in local storage, including both the available schemes and
+ * the user's selected schemes.
+ */
+export declare const authStorage: () => {
+    /**
+     * Retrieves and coerces the authentication schemes stored in local storage.
+     */
+    getSchemas: (slug: string) => {
+        [x: string]: ({
+            description?: string | undefined;
+        } & {
+            'x-scalar-secret-token': string;
+        } & {
+            type: "apiKey";
+            in: "header" | "query" | "cookie";
+            name: string;
+        }) | ({
+            description?: string | undefined;
+        } & {
+            'x-scalar-secret-token': string;
+        } & {
+            'x-scalar-secret-username': string;
+            'x-scalar-secret-password': string;
+        } & {
+            bearerFormat?: string | undefined;
+            type: "http";
+            scheme: "basic" | "bearer";
+        }) | ({
+            description?: string | undefined;
+        } & {
+            type: "oauth2";
+            flows: {
+                password?: ({
+                    refreshUrl: string;
+                    scopes: {
+                        [x: string]: string;
+                    };
+                } & {
+                    'x-scalar-secret-client-id': string;
+                } & {
+                    'x-scalar-secret-token': string;
+                } & {
+                    'x-scalar-security-query'?: {
+                        [x: string]: string;
+                    } | undefined;
+                } & {
+                    'x-scalar-security-body'?: {
+                        [x: string]: string;
+                    } | undefined;
+                } & {
+                    'x-tokenName'?: string | undefined;
+                } & {
+                    tokenUrl: string;
+                } & {
+                    'x-scalar-secret-username': string;
+                    'x-scalar-secret-password': string;
+                } & {
+                    'x-scalar-secret-client-secret': string;
+                } & {
+                    'x-scalar-credentials-location'?: "body" | "header" | undefined;
+                }) | undefined;
+                implicit?: ({
+                    refreshUrl: string;
+                    scopes: {
+                        [x: string]: string;
+                    };
+                } & {
+                    'x-scalar-secret-client-id': string;
+                } & {
+                    'x-scalar-secret-token': string;
+                } & {
+                    'x-scalar-security-query'?: {
+                        [x: string]: string;
+                    } | undefined;
+                } & {
+                    'x-scalar-security-body'?: {
+                        [x: string]: string;
+                    } | undefined;
+                } & {
+                    'x-tokenName'?: string | undefined;
+                } & {
+                    authorizationUrl: string;
+                } & {
+                    'x-scalar-secret-redirect-uri': string;
+                }) | undefined;
+                clientCredentials?: ({
+                    refreshUrl: string;
+                    scopes: {
+                        [x: string]: string;
+                    };
+                } & {
+                    'x-scalar-secret-client-id': string;
+                } & {
+                    'x-scalar-secret-token': string;
+                } & {
+                    'x-scalar-security-query'?: {
+                        [x: string]: string;
+                    } | undefined;
+                } & {
+                    'x-scalar-security-body'?: {
+                        [x: string]: string;
+                    } | undefined;
+                } & {
+                    'x-tokenName'?: string | undefined;
+                } & {
+                    tokenUrl: string;
+                } & {
+                    'x-scalar-secret-client-secret': string;
+                } & {
+                    'x-scalar-credentials-location'?: "body" | "header" | undefined;
+                }) | undefined;
+                authorizationCode?: ({
+                    refreshUrl: string;
+                    scopes: {
+                        [x: string]: string;
+                    };
+                } & {
+                    'x-scalar-secret-client-id': string;
+                } & {
+                    'x-scalar-secret-token': string;
+                } & {
+                    'x-scalar-security-query'?: {
+                        [x: string]: string;
+                    } | undefined;
+                } & {
+                    'x-scalar-security-body'?: {
+                        [x: string]: string;
+                    } | undefined;
+                } & {
+                    'x-tokenName'?: string | undefined;
+                } & {
+                    authorizationUrl: string;
+                    tokenUrl: string;
+                } & {
+                    'x-scalar-secret-client-secret': string;
+                } & {
+                    'x-scalar-secret-redirect-uri': string;
+                } & {
+                    'x-usePkce': "SHA-256" | "plain" | "no";
+                } & {
+                    'x-scalar-credentials-location'?: "body" | "header" | undefined;
+                }) | undefined;
+            };
+        } & {
+            'x-default-scopes'?: string[] | undefined;
+        }) | ({
+            description?: string | undefined;
+        } & {
+            type: "openIdConnect";
+            openIdConnectUrl: string;
+        }) | ({
+            summary?: string | undefined;
+            description?: string | undefined;
+            $ref: string;
+        } & {
+            $status?: "error" | "loading" | undefined;
+            $global?: boolean | undefined;
+        } & {
+            '$ref-value': ({
+                description?: string | undefined;
+            } & {
+                'x-scalar-secret-token': string;
+            } & {
+                type: "apiKey";
+                in: "header" | "query" | "cookie";
+                name: string;
+            }) | ({
+                description?: string | undefined;
+            } & {
+                'x-scalar-secret-token': string;
+            } & {
+                'x-scalar-secret-username': string;
+                'x-scalar-secret-password': string;
+            } & {
+                bearerFormat?: string | undefined;
+                type: "http";
+                scheme: "basic" | "bearer";
+            }) | ({
+                description?: string | undefined;
+            } & {
+                type: "oauth2";
+                flows: {
+                    password?: ({
+                        refreshUrl: string;
+                        scopes: {
+                            [x: string]: string;
+                        };
+                    } & {
+                        'x-scalar-secret-client-id': string;
+                    } & {
+                        'x-scalar-secret-token': string;
+                    } & {
+                        'x-scalar-security-query'?: {
+                            [x: string]: string;
+                        } | undefined;
+                    } & {
+                        'x-scalar-security-body'?: {
+                            [x: string]: string;
+                        } | undefined;
+                    } & {
+                        'x-tokenName'?: string | undefined;
+                    } & {
+                        tokenUrl: string;
+                    } & {
+                        'x-scalar-secret-username': string;
+                        'x-scalar-secret-password': string;
+                    } & {
+                        'x-scalar-secret-client-secret': string;
+                    } & {
+                        'x-scalar-credentials-location'?: "body" | "header" | undefined;
+                    }) | undefined;
+                    implicit?: ({
+                        refreshUrl: string;
+                        scopes: {
+                            [x: string]: string;
+                        };
+                    } & {
+                        'x-scalar-secret-client-id': string;
+                    } & {
+                        'x-scalar-secret-token': string;
+                    } & {
+                        'x-scalar-security-query'?: {
+                            [x: string]: string;
+                        } | undefined;
+                    } & {
+                        'x-scalar-security-body'?: {
+                            [x: string]: string;
+                        } | undefined;
+                    } & {
+                        'x-tokenName'?: string | undefined;
+                    } & {
+                        authorizationUrl: string;
+                    } & {
+                        'x-scalar-secret-redirect-uri': string;
+                    }) | undefined;
+                    clientCredentials?: ({
+                        refreshUrl: string;
+                        scopes: {
+                            [x: string]: string;
+                        };
+                    } & {
+                        'x-scalar-secret-client-id': string;
+                    } & {
+                        'x-scalar-secret-token': string;
+                    } & {
+                        'x-scalar-security-query'?: {
+                            [x: string]: string;
+                        } | undefined;
+                    } & {
+                        'x-scalar-security-body'?: {
+                            [x: string]: string;
+                        } | undefined;
+                    } & {
+                        'x-tokenName'?: string | undefined;
+                    } & {
+                        tokenUrl: string;
+                    } & {
+                        'x-scalar-secret-client-secret': string;
+                    } & {
+                        'x-scalar-credentials-location'?: "body" | "header" | undefined;
+                    }) | undefined;
+                    authorizationCode?: ({
+                        refreshUrl: string;
+                        scopes: {
+                            [x: string]: string;
+                        };
+                    } & {
+                        'x-scalar-secret-client-id': string;
+                    } & {
+                        'x-scalar-secret-token': string;
+                    } & {
+                        'x-scalar-security-query'?: {
+                            [x: string]: string;
+                        } | undefined;
+                    } & {
+                        'x-scalar-security-body'?: {
+                            [x: string]: string;
+                        } | undefined;
+                    } & {
+                        'x-tokenName'?: string | undefined;
+                    } & {
+                        authorizationUrl: string;
+                        tokenUrl: string;
+                    } & {
+                        'x-scalar-secret-client-secret': string;
+                    } & {
+                        'x-scalar-secret-redirect-uri': string;
+                    } & {
+                        'x-usePkce': "SHA-256" | "plain" | "no";
+                    } & {
+                        'x-scalar-credentials-location'?: "body" | "header" | undefined;
+                    }) | undefined;
+                };
+            } & {
+                'x-default-scopes'?: string[] | undefined;
+            }) | ({
+                description?: string | undefined;
+            } & {
+                type: "openIdConnect";
+                openIdConnectUrl: string;
+            });
+        });
+    };
+    /**
+     * Stores the authentication schemes in local storage.
+     * @param value The SecuritySchemes object to stringify and store.
+     */
+    setSchemas: (slug: string, value: SecuritySchemes) => void;
+    /**
+     * Retrieves and coerces the selected authentication schemes stored in local storage.
+     */
+    getSelectedSchemes: (slug: string) => {
+        'x-scalar-selected-security'?: {
+            selectedSchemes: {}[];
+            selectedIndex: number;
+        } | undefined;
+    };
+    /**
+     * Stores the user's selected authentication schemes in local storage.
+     * @param value The XScalarSelectedSecurity object to stringify and store.
+     */
+    setSelectedSchemes: (slug: string, value: XScalarSelectedSecurity) => void;
+};
+/**
+ * Recursively merges secret values from stored data into the current schema.
+ * Only merges secrets if the corresponding structure exists in the current schema.
+ *
+ * This function walks through both objects in parallel, copying any keys that
+ * start with 'x-scalar-secret-' from the stored object to the current object,
+ * but only if the path exists in the current schema.
+ *
+ * @param current - The current schema object (source of truth for structure)
+ * @param stored - The stored object containing secret values to restore
+ */
+export declare const mergeSecrets: (current: unknown, stored: unknown) => void;
+/**
+ * Restores authentication secrets from local storage to the workspace store.
+ *
+ * This function iterates through stored authentication schemes and restores
+ * any secret values (keys starting with x-scalar-secret-) to the active
+ * document's security schemes. It uses the current security schemes as the
+ * source of truth, only restoring secrets for structures that exist in the
+ * current document.
+ */
+export declare const restoreAuthSecretsFromStorage: ({ documentName, workspaceStore, }: {
+    documentName: string;
+    workspaceStore: WorkspaceStore;
+}) => void;
+export declare function safeParseJson(value: string): any;
 //# sourceMappingURL=helpers.d.ts.map

package/dist/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,IAAI,CAAA;AAGhE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yDAAyD,CAAA;AAGpG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAA;AAG9E,OAAO,KAAK,EACV,eAAe,EACf,eAAe,EACf,eAAe,EACf,cAAc,EACd,yBAAyB,EACzB,oBAAoB,EACpB,YAAY,EACb,MAAM,8DAA8D,CAAA;AAErE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AAE1C,4FAA4F;AAC5F,eAAO,MAAM,aAAa,GACxB,aAAY,cAAc,CAAC,YAAY,CAAM,EAC7C,kBAAiB,eAAe,CAAC,YAAY,CAAM,KAClD,eAAe,EAgBjB,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,GAAG,gBAAgB,EAAE,CAAC,YAAY,EAAE,GAAG,YAAY,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,GACxE,YAAY,GAAG,SAAS,CAyB1B;AAED,4CAA4C;AAC5C,wBAAgB,UAAU,CACxB,IAAI,EAAE,aAAa,CAAC,WAAW,EAAE,KAAK,CAAC,GACtC,IAAI,IAAI,UAAU,CAAC,KAAK,CAAC,CAE3B;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,oBAAoB,GAAG,SAAS,KACvC,MAAM,EAMR,CAAA;AA2CD;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,GAC7B,sBAAsB,yBAAyB,EAAE,EACjD,yBAAyB,2BAA2B,CAAC,yBAAyB,CAAC,EAC/E,iBAAiB,qBAAqB,KACrC,yBAAyB,GAAG,IAc9B,CAAA;AAMD;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,GACjC,UAAU,eAAe,EACzB,WAAW,eAAe,GAAG,IAAI,EACjC,kBAAiB,qBAA0B,KAC1C,oBAAoB,EAsCtB,CAAA;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,CAAC,WAAW,CAAC,QAAQ,CAAC,GAGzD,eAAe,EAAE,CACvB"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"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"}

package/dist/helpers.js

@@ -1,8 +1,11 @@
 import { getSecuritySchemes } from "@scalar/api-client/v2/blocks/operation-block";
-import { getSelectedSecurity } from "@scalar/api-client/v2/features/operation";
+import { getSelectedSecurity, getSelectedServer } from "@scalar/api-client/v2/features/operation";
 import { isDefined } from "@scalar/helpers/array/is-defined";
+import { isObject } from "@scalar/helpers/object/is-object";
+import { REFERENCE_LS_KEYS, safeLocalStorage } from "@scalar/helpers/object/local-storage";
 import { getResolvedRef } from "@scalar/workspace-store/helpers/get-resolved-ref";
-import { unpackProxyObject } from "@scalar/workspace-store/helpers/unpack-proxy";
+import { coerceValue } from "@scalar/workspace-store/schemas/typebox-coerce";
+import { XScalarSelectedSecuritySchema, SecuritySchemesSchema } from "@scalar/workspace-store/schemas/v3.1/strict/openapi-document";
 const combineParams = (pathParams = [], operationParams = []) => {
   const allParams = [...pathParams, ...operationParams].map((param) => getResolvedRef(param)).filter((e) => isDefined(e) && e.name);
   const uniqueParams = /* @__PURE__ */ new Map();
@@ -33,46 +36,6 @@ function getFirstServer(...availableServers) {
   }
   return void 0;
 }
-const getDefaultScopes = (scheme) => {
-  if (!scheme || scheme.type !== "oauth2") {
-    return [];
-  }
-  return scheme["x-default-scopes"] ?? [];
-};
-const addSchemeToRequirement = (acc, schemeName, securitySchemes) => {
-  const scheme = getResolvedRef(securitySchemes[schemeName]);
-  acc[schemeName] = getDefaultScopes(scheme);
-};
-const buildSecurityRequirementFromPreferred = (preferredSecurityScheme, securitySchemes) => {
-  if (!Array.isArray(preferredSecurityScheme)) {
-    const scheme = getResolvedRef(securitySchemes[preferredSecurityScheme]);
-    return { [preferredSecurityScheme]: getDefaultScopes(scheme) };
-  }
-  const requirement = {};
-  for (const item of preferredSecurityScheme) {
-    if (Array.isArray(item)) {
-      for (const schemeName of item) {
-        addSchemeToRequirement(requirement, schemeName, securitySchemes);
-      }
-    } else {
-      addSchemeToRequirement(requirement, item, securitySchemes);
-    }
-  }
-  return requirement;
-};
-const getDefaultSecurity = (securityRequirements, preferredSecurityScheme, securitySchemes) => {
-  if (preferredSecurityScheme) {
-    return buildSecurityRequirementFromPreferred(
-      preferredSecurityScheme,
-      securitySchemes
-    );
-  }
-  const firstRequirement = securityRequirements[0];
-  if (firstRequirement) {
-    return unpackProxyObject(firstRequirement, { depth: 1 });
-  }
-  return null;
-};
 const getKey = (requirement) => Object.keys(requirement).sort().join(",");
 const filterSelectedSecurity = (document, operation, securitySchemes = {}) => {
   const securityRequirements = operation?.security ?? document.security ?? [];
@@ -100,12 +63,139 @@ function getOperations(doc) {
     (path) => Object.values(path ?? {})
   );
 }
+function getSecurityFromDocument(document) {
+  const selectedSchemes = document["x-scalar-selected-security"]?.selectedSchemes ?? [];
+  const schemeKeys = selectedSchemes.flatMap((scheme) => Object.keys(scheme));
+  const securitySchemes = document.components?.securitySchemes;
+  if (!securitySchemes) return [];
+  return schemeKeys.reduce((acc, cur) => {
+    const security = securitySchemes[cur];
+    if (security) acc.push(getResolvedRef(security));
+    return acc;
+  }, []);
+}
+function createDocumentSettings(workspaceStore) {
+  return Object.fromEntries(
+    Object.entries(workspaceStore.workspace.documents).map(
+      ([key, document]) => [
+        key,
+        {
+          activeServer: getSelectedServer(document),
+          securitySchemes: getSecurityFromDocument(document)
+        }
+      ]
+    )
+  );
+}
+const storage = safeLocalStorage();
+const authStorage = () => {
+  const schemasKey = REFERENCE_LS_KEYS.AUTH_SCHEMES;
+  const selectedSchemesKey = REFERENCE_LS_KEYS.SELECTED_AUTH_SCHEMES;
+  const getAuthId = (type, prefix) => {
+    const getKey2 = (type2) => {
+      return type2 === "schemas" ? schemasKey : selectedSchemesKey;
+    };
+    return `${prefix}-${getKey2(type)}`;
+  };
+  return {
+    /**
+     * Retrieves and coerces the authentication schemes stored in local storage.
+     */
+    getSchemas: (slug) => {
+      const parsed = JSON.parse(
+        storage.getItem(getAuthId("schemas", slug)) ?? "{}"
+      );
+      return coerceValue(SecuritySchemesSchema, parsed);
+    },
+    /**
+     * Stores the authentication schemes in local storage.
+     * @param value The SecuritySchemes object to stringify and store.
+     */
+    setSchemas: (slug, value) => {
+      storage.setItem(getAuthId("schemas", slug), JSON.stringify(value));
+    },
+    /**
+     * Retrieves and coerces the selected authentication schemes stored in local storage.
+     */
+    getSelectedSchemes: (slug) => {
+      const parsed = JSON.parse(
+        storage.getItem(getAuthId("selectedSchemes", slug)) ?? "{}"
+      );
+      return coerceValue(XScalarSelectedSecuritySchema, parsed);
+    },
+    /**
+     * Stores the user's selected authentication schemes in local storage.
+     * @param value The XScalarSelectedSecurity object to stringify and store.
+     */
+    setSelectedSchemes: (slug, value) => {
+      storage.setItem(getAuthId("selectedSchemes", slug), JSON.stringify(value));
+    }
+  };
+};
+const mergeSecrets = (current, stored) => {
+  if (!isObject(current) || !isObject(stored)) {
+    return;
+  }
+  for (const [key, storedValue] of Object.entries(stored)) {
+    if (typeof storedValue !== "object") {
+      current[key] = storedValue;
+      continue;
+    }
+    mergeSecrets(getResolvedRef(current[key]), storedValue);
+  }
+};
+const isSchemeValid = (scheme, availableSchemes) => Object.keys(scheme).every((key) => availableSchemes.has(key));
+const clampSelectedIndex = (selectedIndex, schemesLength) => selectedIndex >= schemesLength ? schemesLength - 1 : selectedIndex;
+const restoreAuthSecretsFromStorage = ({
+  documentName,
+  workspaceStore
+}) => {
+  const storedAuthSchemes = authStorage().getSchemas(documentName);
+  const document = workspaceStore.workspace.documents[documentName];
+  if (!document) return;
+  const authPersistence = authStorage();
+  const storedSelectedAuthSchemes = authPersistence.getSelectedSchemes(documentName);
+  const availableSchemes = new Set(
+    Object.keys(document.components?.securitySchemes ?? {})
+  );
+  const selectedSchemes = storedSelectedAuthSchemes["x-scalar-selected-security"]?.selectedSchemes;
+  const validSchemes = selectedSchemes?.filter(
+    (scheme) => isSchemeValid(scheme, availableSchemes)
+  );
+  if (!document["x-scalar-selected-security"] && validSchemes && validSchemes.length > 0) {
+    const selectedIdx = storedSelectedAuthSchemes["x-scalar-selected-security"]?.selectedIndex;
+    const clampedIndex = clampSelectedIndex(
+      selectedIdx ?? 0,
+      validSchemes.length
+    );
+    document["x-scalar-selected-security"] = {
+      selectedIndex: clampedIndex,
+      selectedSchemes: validSchemes
+    };
+  }
+  const securitySchemes = document.components?.securitySchemes ?? {};
+  for (const [key, storedScheme] of Object.entries(storedAuthSchemes)) {
+    const currentScheme = getResolvedRef(securitySchemes[key]);
+    if (isObject(currentScheme)) mergeSecrets(currentScheme, storedScheme);
+  }
+};
+function safeParseJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return;
+  }
+}
 export {
+  authStorage,
   combineParams,
+  createDocumentSettings,
   filterSelectedSecurity,
-  getDefaultScopes,
-  getDefaultSecurity,
   getFirstServer,
-  getOperations
+  getOperations,
+  getSecurityFromDocument,
+  mergeSecrets,
+  restoreAuthSecretsFromStorage,
+  safeParseJson
 };
 //# sourceMappingURL=helpers.js.map