@espressif/rainmaker-neo-base-sdk 1.0.0

package/dist/esm/utils/awsUtils.js

@@ -0,0 +1,163 @@
+import { ESPRMNeoBase } from '../ESPRMNeoBase.js';
+import { ESPRMNeoUser } from '../ESPRMNeoUser.js';
+import { ESPRMNeoStorage } from '../services/ESPRMNeoStorage/ESPRMNeoStorage.js';
+import { isTokenExpired } from '../services/ESPRMNeoHelpers/CheckTokenExpiry.js';
+import { stripTrailingSlash } from './baseUtils.js';
+import { APIPathV1, StorageKeys, TokenErrorCodes, AWSCredentialsErrorMessages } from './constants.js';
+import { ESPTokenError } from './error/ESPTokenError.js';
+import { Logger } from './logger.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new Logger("awsUtils");
+/**
+ * Builds a full URL on the main RainMaker API gateway (not the User API).
+ * /v1/user/credentials uses CognitoAuthorizer but lives on the main API.
+ */
+function buildMainApiUrl(path) {
+    const baseUrl = stripTrailingSlash(ESPRMNeoBase.getConfig().baseUrl ?? "");
+    const pathWithSlash = path.startsWith("/") ? path : `/${path}`;
+    return `${baseUrl}${pathWithSlash}`;
+}
+/** URL for POST /v1/user/credentials. */
+function buildUserCredentialsUrl() {
+    return buildMainApiUrl(APIPathV1.USER_CREDENTIALS);
+}
+/**
+ * Extends the Cognito session using the stored refresh token.
+ * @throws {ESPTokenError} When no refresh token is stored.
+ */
+async function refreshUserSession() {
+    const refreshToken = await ESPRMNeoStorage.getItem(StorageKeys.REFRESHTOKEN);
+    if (!refreshToken) {
+        throw new ESPTokenError(TokenErrorCodes.MISSING_REFRESH_TOKEN);
+    }
+    await ESPRMNeoUser.extendSession(refreshToken);
+}
+/**
+ * Ensures a non-expired ID token is available before calling the credentials API.
+ * Refreshes the session when the stored ID token is expired or undecodable.
+ * @throws {ESPTokenError} When the ID token is missing or session refresh fails.
+ */
+async function ensureValidIdToken() {
+    const idToken = await ESPRMNeoStorage.getItem(StorageKeys.IDTOKEN);
+    if (!idToken) {
+        throw new ESPTokenError(TokenErrorCodes.MISSING_ID_TOKEN);
+    }
+    let needsRefresh = false;
+    try {
+        needsRefresh = isTokenExpired(idToken);
+    }
+    catch {
+        needsRefresh = true;
+    }
+    if (!needsRefresh) {
+        return;
+    }
+    logger.debug(AWSCredentialsErrorMessages.ID_TOKEN_REFRESH);
+    await refreshUserSession();
+}
+/**
+ * Best-effort error string from a credentials API response.
+ */
+function parseCredentialsErrorMessage(response, data, responseText) {
+    const fromJson = (typeof data?.message === "string" && data.message.trim()) ||
+        (typeof data?.error === "string" && data.error.trim());
+    if (fromJson) {
+        return fromJson;
+    }
+    const trimmed = responseText.trim();
+    if (trimmed) {
+        return trimmed;
+    }
+    return AWSCredentialsErrorMessages.HTTP_ERROR(response.status);
+}
+/** True when the credentials API rejected the request due to an expired token. */
+function isExpiredTokenAuthError(status, message) {
+    return status === 401 && message.toLowerCase().includes("expired");
+}
+/**
+ * Maps a credentials API payload to {@link ESPAWSCredentials}.
+ * @throws {Error} When required credential fields are missing.
+ */
+function extractTemporaryCredentials(data) {
+    if (!data?.access_key_id ||
+        !data?.secret_access_key ||
+        !data?.session_token) {
+        logger.error(AWSCredentialsErrorMessages.INCOMPLETE_CREDENTIALS_LOG, {
+            hasAccessKey: !!data?.access_key_id,
+            hasSecretKey: !!data?.secret_access_key,
+            hasSessionToken: !!data?.session_token,
+        });
+        throw new Error(AWSCredentialsErrorMessages.INCOMPLETE_CREDENTIALS);
+    }
+    const expiration = data.expiration
+        ? new Date(data.expiration * 1000).toISOString()
+        : new Date(Date.now() + 3600000).toISOString();
+    return {
+        accessKey: data.access_key_id,
+        secretKey: data.secret_access_key,
+        sessionToken: data.session_token,
+        expiration,
+        ...(typeof data.message === "string" ? { message: data.message } : {}),
+    };
+}
+/**
+ * POSTs /v1/user/credentials with the access token as Bearer auth and the
+ * ID token in the body. Both must come from the same sign-in.
+ */
+async function postUserCredentials(url) {
+    const [accessToken, idToken] = await Promise.all([
+        ESPRMNeoStorage.getItem(StorageKeys.ACCESSTOKEN),
+        ESPRMNeoStorage.getItem(StorageKeys.IDTOKEN),
+    ]);
+    if (!accessToken) {
+        logger.error(AWSCredentialsErrorMessages.MISSING_ACCESS_TOKEN);
+        throw new ESPTokenError(TokenErrorCodes.MISSING_ACCESS_TOKEN);
+    }
+    if (!idToken) {
+        logger.error(AWSCredentialsErrorMessages.MISSING_ID_TOKEN);
+        throw new ESPTokenError(TokenErrorCodes.MISSING_ID_TOKEN);
+    }
+    let response;
+    try {
+        response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${accessToken}`,
+            },
+            body: JSON.stringify({ id_token: idToken }),
+        });
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        logger.error(AWSCredentialsErrorMessages.NETWORK_ERROR(detail), error);
+        throw new Error(AWSCredentialsErrorMessages.NETWORK_ERROR(detail));
+    }
+    let data = null;
+    let responseText = "";
+    try {
+        responseText = await response.text();
+        if (responseText) {
+            try {
+                data = JSON.parse(responseText);
+            }
+            catch {
+                // non-JSON body; parseCredentialsErrorMessage falls back to responseText
+            }
+        }
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        logger.error(AWSCredentialsErrorMessages.READ_RESPONSE_FAILED(detail), error);
+        throw new Error(AWSCredentialsErrorMessages.READ_RESPONSE_FAILED(detail));
+    }
+    return { response, data, responseText };
+}
+
+export { buildMainApiUrl, buildUserCredentialsUrl, ensureValidIdToken, extractTemporaryCredentials, isExpiredTokenAuthError, parseCredentialsErrorMessage, postUserCredentials, refreshUserSession };
+//# sourceMappingURL=awsUtils.js.map

package/dist/esm/utils/awsUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"awsUtils.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/utils/baseUtils.js

@@ -0,0 +1,280 @@
+import { ESPRMNeoAuth } from '../ESPRMNeoAuth.js';
+import { ESPRMNeoStorage, _resetESPRMNeoStorageForTests } from '../services/ESPRMNeoStorage/ESPRMNeoStorage.js';
+import { initializeAPIManager, _resetAPIManagerForTests } from '../services/ESPRMNeoAPIManager.js';
+import { initializeSigV4APIManager, _resetSigV4APIManagerForTests } from '../services/ESPSigV4APIManager.js';
+import { ESPRMNeoMqtt } from '../services/ESPRMNeoMqtt/ESPRMNeoMqtt.js';
+import { NodeMQTTOrchestrator } from '../services/NodeMQTTOrchestrator.js';
+import { ESPRMNeoSubscriptionManager } from '../services/ESPRMNeoSubscriptionManager.js';
+import { registerMqttChannelIfNeeded } from '../services/ESPRMNeoHelpers/ChannelRegistration.js';
+import { DEFAULT_TRANSPORT_ORDER } from '../types/transport.js';
+import { ConfigErrorCodes } from './constants.js';
+import { ESPConfigError } from './error/ESPConfigError.js';
+import { configErrorMessages } from './error/errorMessages.js';
+import { Logger } from './logger.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Internal helpers for {@link ESPRMNeoBase} configure / dispose / validation.
+ *
+ * Not part of the public SDK barrel — used only by the base facade so
+ * lifecycle orchestration stays out of the class body.
+ */
+const logger = new Logger("baseUtils");
+/**
+ * Stable log message strings for base SDK lifecycle events.
+ */
+const BaseLogMessages = {
+    RESOLVE_USER_API_BASE: "Resolved User API base",
+    EXTRACT_ADAPTERS: "Extracted adapters from config",
+    MQTT_SKIP: "MQTT adapter not configured; skipping MQTT init",
+    MQTT_INIT: "Initializing MQTT transport and NodeMQTTOrchestrator",
+    API_STACK_INIT: "Initializing storage and API managers",
+    SUBSCRIPTION_CREATE: "Creating subscription manager",
+    SUBSCRIPTION_MQTT_REGISTER: "Registering default MQTT subscription channel",
+    AUTH_CREATE: "Creating auth instance",
+    DISPOSE_PEERS: "Disposing peer singletons",
+    DISPOSE_SUBSCRIPTION_FAILED: "Subscription manager dispose failed",
+    MQTT_CLEAR_SKIPPED: "ESPRMNeoMqtt.clear skipped",
+    ORCHESTRATOR_CLEAR_SKIPPED: "NodeMQTTOrchestrator.clear skipped",
+    TRANSPORT_ORDER_INVALID: "Invalid transport order provided",
+    SDK_NOT_INITIALIZED: "SDK not initialized",
+    ADAPTER_INVALID: "Invalid adapter provided",
+    CONFIG_SUMMARY: "Configuration summary",
+};
+/**
+ * Removes a single trailing `/` from a URL or path segment.
+ *
+ * @param url - Absolute URL or path that may end with a slash.
+ * @returns The same string without a trailing slash.
+ */
+function stripTrailingSlash(url) {
+    return url.replace(/\/$/, "");
+}
+/**
+ * Resolves and normalizes the User/auth API base URL.
+ *
+ * @param config - SDK configuration; `userApiBase` is required.
+ * @returns Normalized User/auth API base (no trailing slash).
+ * @throws {ESPConfigError} With {@link ConfigErrorCodes.INVALID_USER_API_BASE}
+ *   when `userApiBase` is missing or empty.
+ */
+function resolveUserApiBase(config) {
+    if (config.userApiBase == null || config.userApiBase === "") {
+        logger.error(BaseLogMessages.RESOLVE_USER_API_BASE, {
+            code: ConfigErrorCodes.INVALID_USER_API_BASE,
+        });
+        throw new ESPConfigError(ConfigErrorCodes.INVALID_USER_API_BASE);
+    }
+    const resolved = stripTrailingSlash(config.userApiBase);
+    logger.debug(BaseLogMessages.RESOLVE_USER_API_BASE, { resolved });
+    return resolved;
+}
+/**
+ * Reads optional adapters from config without writing {@link ESPRMNeoBase} statics.
+ * The caller assigns the returned values onto Base fields.
+ *
+ * @param config - SDK configuration from {@link ESPRMNeoBase.configure}.
+ * @returns Adapter bag (any field may be `undefined` if not supplied).
+ */
+function extractAdaptersFromConfig(config) {
+    const adapters = {
+        storage: config.customStorageAdapter,
+        provision: config.provisionAdapter,
+        localControl: config.localControlAdapter,
+        localDiscovery: config.localDiscoveryAdapter,
+    };
+    logger.debug(BaseLogMessages.EXTRACT_ADAPTERS, {
+        hasStorage: !!adapters.storage,
+        hasProvision: !!adapters.provision,
+        hasLocalControl: !!adapters.localControl,
+        hasLocalDiscovery: !!adapters.localDiscovery,
+    });
+    return adapters;
+}
+/**
+ * Initializes {@link ESPRMNeoMqtt} and {@link NodeMQTTOrchestrator} when
+ * `config.mqttAdapter` is present. No-op when MQTT is not configured.
+ *
+ * @param config - SDK configuration from {@link ESPRMNeoBase.configure}.
+ * @throws {Error} If MQTT / orchestrator are already initialized (call
+ *   {@link disposePeerSingletons} first).
+ */
+function initializeMqttIfConfigured(config) {
+    if (!config.mqttAdapter) {
+        logger.debug(BaseLogMessages.MQTT_SKIP);
+        return;
+    }
+    logger.info(BaseLogMessages.MQTT_INIT);
+    ESPRMNeoMqtt.initialize(config.mqttAdapter);
+    NodeMQTTOrchestrator.initialize(ESPRMNeoMqtt.getInstance());
+}
+/**
+ * Initializes storage, the User API manager, and the SigV4 API manager.
+ *
+ * @param config - SDK configuration (provides `baseUrl`, `awsRegion`, User API base).
+ * @param storageAdapter - Optional custom storage; when omitted, storage uses its default.
+ * @throws {Error} If an API manager is already initialized (call
+ *   {@link disposePeerSingletons} first).
+ */
+function initializeApiStack(config, storageAdapter) {
+    const userApiBase = resolveUserApiBase(config);
+    const baseUrl = stripTrailingSlash(config.baseUrl);
+    logger.info(BaseLogMessages.API_STACK_INIT, {
+        baseUrl,
+        userApiBase,
+        hasCustomStorage: !!storageAdapter,
+        awsRegion: config.awsRegion,
+    });
+    ESPRMNeoStorage.initialize(storageAdapter);
+    initializeAPIManager({ userApiBase });
+    initializeSigV4APIManager({
+        baseUrl,
+        awsRegion: config.awsRegion,
+    });
+}
+/**
+ * Creates an {@link ESPRMNeoSubscriptionManager} and, when MQTT is configured,
+ * registers the default MQTT channel synchronously.
+ *
+ * @param config - SDK configuration (MQTT presence controls channel registration).
+ * @returns A new subscription manager owned by the caller (typically Base).
+ */
+function createSubscriptionManager(config) {
+    logger.debug(BaseLogMessages.SUBSCRIPTION_CREATE, {
+        registerMqtt: !!config.mqttAdapter,
+    });
+    const manager = new ESPRMNeoSubscriptionManager();
+    if (config.mqttAdapter) {
+        logger.info(BaseLogMessages.SUBSCRIPTION_MQTT_REGISTER);
+        registerMqttChannelIfNeeded(manager);
+    }
+    return manager;
+}
+/**
+ * Constructs {@link ESPRMNeoAuth} for the given config.
+ * Call only after config validation; the caller retains ownership.
+ *
+ * @param config - Validated SDK configuration.
+ * @returns A new auth instance for the given config.
+ */
+function createAuthInstance(config) {
+    logger.debug(BaseLogMessages.AUTH_CREATE, {
+        awsRegion: config.awsRegion,
+    });
+    return new ESPRMNeoAuth(config);
+}
+/**
+ * Resets peer module singletons (subscription channels, MQTT, API managers,
+ * storage) so {@link ESPRMNeoBase.configure} can run again.
+ *
+ * Does **not** clear {@link ESPRMNeoBase} static fields — the caller must do that.
+ *
+ * @param subscriptionManager - Active manager to dispose, or `null` if none.
+ */
+function disposePeerSingletons(subscriptionManager) {
+    logger.info(BaseLogMessages.DISPOSE_PEERS, {
+        hasSubscriptionManager: !!subscriptionManager,
+    });
+    if (subscriptionManager) {
+        void subscriptionManager.dispose().catch((error) => {
+            logger.error(BaseLogMessages.DISPOSE_SUBSCRIPTION_FAILED, error);
+        });
+    }
+    try {
+        ESPRMNeoMqtt.clear();
+    }
+    catch (error) {
+        logger.debug(BaseLogMessages.MQTT_CLEAR_SKIPPED, error);
+    }
+    try {
+        NodeMQTTOrchestrator.clear();
+    }
+    catch (error) {
+        logger.debug(BaseLogMessages.ORCHESTRATOR_CLEAR_SKIPPED, error);
+    }
+    _resetAPIManagerForTests();
+    _resetSigV4APIManagerForTests();
+    _resetESPRMNeoStorageForTests();
+}
+/**
+ * Returns a fresh copy of {@link DEFAULT_TRANSPORT_ORDER} for Base init / reset.
+ *
+ * @returns New array of default transport modes (safe to mutate).
+ */
+function createDefaultTransportOrder() {
+    return [...DEFAULT_TRANSPORT_ORDER];
+}
+/**
+ * Validates and shallow-copies a transport priority order.
+ *
+ * @param order - Non-empty ordered list of {@link ESPTransportMode} values or custom keys.
+ * @returns A copy of `order`.
+ * @throws {ESPConfigError} With {@link ConfigErrorCodes.INVALID_TRANSPORT_ORDER}
+ *   if `order` is missing, empty, or not an array.
+ */
+function copyTransportOrder(order) {
+    if (!Array.isArray(order) || order.length === 0) {
+        logger.error(BaseLogMessages.TRANSPORT_ORDER_INVALID, {
+            code: ConfigErrorCodes.INVALID_TRANSPORT_ORDER,
+            isArray: Array.isArray(order),
+            length: Array.isArray(order) ? order.length : undefined,
+        });
+        throw new ESPConfigError(ConfigErrorCodes.INVALID_TRANSPORT_ORDER);
+    }
+    return [...order];
+}
+/**
+ * Guards Base getters/setters that require a prior {@link ESPRMNeoBase.configure}.
+ *
+ * @param isInitialized - Whether the relevant Base state is present.
+ * @throws {ESPConfigError} With {@link ConfigErrorCodes.SDK_NOT_CONFIGURED}
+ *   when `isInitialized` is false.
+ */
+function assertSdkInitialized(isInitialized) {
+    if (!isInitialized) {
+        logger.error(BaseLogMessages.SDK_NOT_INITIALIZED, {
+            code: ConfigErrorCodes.SDK_NOT_CONFIGURED,
+        });
+        throw new ESPConfigError(ConfigErrorCodes.SDK_NOT_CONFIGURED);
+    }
+}
+/**
+ * Guards adapter setters: the adapter argument must be a non-falsy value.
+ *
+ * @param adapter - Adapter instance supplied by the app.
+ * @param code - Matching adapter {@link ConfigErrorCodes} entry for the error message.
+ * @throws {ESPConfigError} With `code` when `adapter` is missing or falsy.
+ */
+function assertAdapterProvided(adapter, code) {
+    if (!adapter) {
+        logger.error(BaseLogMessages.ADAPTER_INVALID, {
+            code,
+            message: configErrorMessages[code],
+        });
+        throw new ESPConfigError(code);
+    }
+}
+/**
+ * Logs which optional pieces of {@link ESPRMNeoBaseConfig} are present (debug).
+ *
+ * @param config - SDK configuration about to be applied.
+ */
+function logConfigSummary(config) {
+    logger.debug(BaseLogMessages.CONFIG_SUMMARY, {
+        hasBaseUrl: !!config.baseUrl,
+        hasUserApiBase: !!config.userApiBase,
+        hasAwsRegion: !!config.awsRegion,
+        hasCustomStorageAdapter: !!config.customStorageAdapter,
+        hasProvisionAdapter: !!config.provisionAdapter,
+        hasMqttAdapter: !!config.mqttAdapter,
+        hasLocalControlAdapter: !!config.localControlAdapter,
+        hasLocalDiscoveryAdapter: !!config.localDiscoveryAdapter,
+    });
+}
+
+export { assertAdapterProvided, assertSdkInitialized, copyTransportOrder, createAuthInstance, createDefaultTransportOrder, createSubscriptionManager, disposePeerSingletons, extractAdaptersFromConfig, initializeApiStack, initializeMqttIfConfigured, logConfigSummary, resolveUserApiBase, stripTrailingSlash };
+//# sourceMappingURL=baseUtils.js.map

package/dist/esm/utils/baseUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseUtils.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/utils/coerce.js

@@ -0,0 +1,42 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Coerces a raw value to a finite number, or `undefined` if it cannot be
+ * parsed (wrong type, NaN, ±Infinity).
+ *
+ * Accepts both `number` and `string` inputs; all other types return `undefined`.
+ */
+function coerceToFiniteNumber(raw) {
+    if (typeof raw !== "number" && typeof raw !== "string")
+        return undefined;
+    const n = Number(raw);
+    return Number.isFinite(n) ? n : undefined;
+}
+/**
+ * Coerces a raw value to a non-empty string, or `undefined` if the value is
+ * not a string or is an empty string.
+ */
+function coerceToNonEmptyString(raw) {
+    return typeof raw === "string" && raw.length > 0 ? raw : undefined;
+}
+/**
+ * Coerces a raw value to a trimmed non-empty string.
+ * - `string` → trimmed; empty after trim → `undefined`
+ * - finite `number` → decimal string (legacy firmware timestamps)
+ * - all other types → `undefined`
+ */
+function coerceToString(raw) {
+    if (typeof raw === "string") {
+        const s = raw.trim();
+        return s || undefined;
+    }
+    if (typeof raw === "number" && Number.isFinite(raw))
+        return String(raw);
+    return undefined;
+}
+
+export { coerceToFiniteNumber, coerceToNonEmptyString, coerceToString };
+//# sourceMappingURL=coerce.js.map

package/dist/esm/utils/coerce.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coerce.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/utils/common.js

@@ -0,0 +1,37 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** True if `value` is a member of the given enum. */
+function isEnumValue(value, enumObj) {
+    return Object.values(enumObj).includes(value);
+}
+/** True if `obj` has no own enumerable keys. */
+function isEmptyObject(obj) {
+    return !obj || Object.keys(obj).length === 0;
+}
+/**
+ * Coerces `value` to an object. Non-objects become `{}`.
+ */
+function asObject(value) {
+    return (typeof value === "object" && value !== null ? value : {});
+}
+/**
+ * Normalizes an optional string or string array into a new `string[]`.
+ * - `string[]` → shallow copy
+ * - non-empty `string` → single-element array
+ * - `undefined` / empty string → `[]`
+ */
+function asStringArray(value) {
+    if (Array.isArray(value)) {
+        return [...value];
+    }
+    if (value) {
+        return [value];
+    }
+    return [];
+}
+
+export { asObject, asStringArray, isEmptyObject, isEnumValue };
+//# sourceMappingURL=common.js.map

package/dist/esm/utils/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}